fix(wasm64): heal toolchain and bump binaryen to v129

Resolves #1576.

Building for wasm64-unknown-unknown failed in two ways introduced by
#1553:

1. `rustup target add wasm64-unknown-unknown` failed because wasm64 is
   a tier-3 target with no prebuilt artifacts. Users had to work around
   this with `--mode force`.
2. The bundled wasm-opt (binaryen v117) could not parse 64-bit tables;
   support landed in binaryen v118.

The cargo target triple — declared in `.cargo/config.toml`,
`CARGO_BUILD_TARGET`, or as an extra cargo argument
(`-- --target wasm64-unknown-unknown`) — is the source of truth for
what wasm-pack builds. The target triple resolver now follows the same
precedence cargo uses (CLI > env > `.cargo/config.toml` walk-up >
`$CARGO_HOME/config.toml` > default), so wasm-pack and cargo always
agree on the target.

For tier-3 wasm targets (currently the `wasm64-*` family) wasm-pack
stays out of the cargo invocation — it does not inject `+nightly` or
`-Z build-std` (those would override a project's `rust-toolchain.toml`
pin or surprise users who hadn't intended a nightly build). Instead it:

* verifies the active toolchain is nightly, with a helpful error
  pointing at `rust-toolchain.toml` and `[unstable] build-std` in
  `.cargo/config.toml` if it isn't,
* heals the `rust-src` component for the active toolchain via rustup
  if missing,
* skips the `rustup target add` attempt (which always fails for tier-3
  targets),
* passes `--enable-memory64` to wasm-opt so the optimiser accepts
  64-bit memories and tables.

The bundled binaryen is bumped from `version_117` to `version_129`
(latest stable) so wasm-opt accepts 64-bit memories and tables.

`--panic-unwind` is untouched.

Tests:

* New unit test `build::tests::tier3_wasm_detection` covers the
  triple-classification helper.
* New `command::build::tests` unit tests cover the cargo-config
  walk-up resolution.
* New `wasm_opt_prebuilt_url_is_pinned_version` test guards against
  regressing the binaryen version below v118 (the first release with
  64-bit table support).
* Existing `all_latest_tool_download_urls_valid` validates the v129
  release URLs across all supported architectures.

Author: guybedford

Cargo.lock

@@ -35,6 +35,7 @@ ureq = { version = "2.12.1", features = ["json", "socks-proxy"] }
 walkdir = "2.5.0"
 which = "8.0.0"
 path-clean = "1.0.1"
+dirs = "6.0.0"
 
 [dev-dependencies]
 assert_cmd = "2.1.1"

Cargo.toml

@@ -21,7 +21,7 @@ The available configuration options and their default values are shown below:
 #
 # In most cases, the `-O[X]` flag is enough. However, if you require extreme
 # optimizations, see the full list of `wasm-opt` optimization flags
-# https://github.com/WebAssembly/binaryen/blob/version_117/test/lit/help/wasm-opt.test
+# https://github.com/WebAssembly/binaryen/blob/version_129/test/lit/help/wasm-opt.test
 wasm-opt = ['-O']
 
 [package.metadata.wasm-pack.profile.dev.wasm-bindgen]

docs/src/cargo-toml-configuration.md

@@ -174,6 +174,68 @@ See [Non-`rustup` setups][non-rustup].
 
 `--panic-unwind` is also available for [`wasm-pack test`](./test.md).
 
+## 64-bit WebAssembly (`wasm64-unknown-unknown`)
+
+The cargo target triple is the source of truth for which WebAssembly ABI
+`wasm-pack` builds. To produce a `memory64` binary, declare the target the
+cargo-native way — either in `.cargo/config.toml`:
+
+```toml
+# .cargo/config.toml
+[build]
+target = "wasm64-unknown-unknown"
+```
+
+or as an extra cargo argument:
+
+```
+wasm-pack build -- --target wasm64-unknown-unknown
+```
+
+or via `CARGO_BUILD_TARGET=wasm64-unknown-unknown` in the environment.
+
+`wasm64-unknown-unknown` is a [tier-3 Rust target][tier-3], so `rustup`
+has no prebuilt artifacts for it. You need to provide two pieces yourself
+via cargo's native config:
+
+1. **A nightly toolchain** — `rust-toolchain.toml` is the cargo-native
+   way to pin one to your project:
+
+   ```toml
+   # rust-toolchain.toml
+   [toolchain]
+   channel = "nightly"
+   components = ["rust-src"]
+   ```
+
+   Or set `RUSTUP_TOOLCHAIN=nightly` for one-off invocations.
+
+2. **`-Z build-std` to build `std` from source**, since there is no
+   prebuilt one. Add to your `.cargo/config.toml`:
+
+   ```toml
+   [unstable]
+   build-std = ["std", "panic_abort"]
+   ```
+
+   Or pass `-Z build-std=std,panic_abort` as an extra cargo argument.
+
+`wasm-pack` itself stays out of the cargo invocation — it does not inject
+`+nightly` or `-Z build-std` (those would override your toolchain pin or
+surprise users who hadn't intended a nightly build). What it does do when
+it sees a `wasm64-*` triple:
+
+- Verifies the active toolchain is nightly, with a helpful error pointing
+  at the config above if it isn't.
+- Installs the `rust-src` component for the active toolchain via `rustup`
+  if missing.
+- Does **not** attempt `rustup target add wasm64-*` (which would always
+  fail for a tier-3 target).
+- Passes `--enable-memory64` to `wasm-opt` so the optimiser accepts
+  64-bit memories and tables.
+
+[tier-3]: https://doc.rust-lang.org/nightly/rustc/platform-support.html
+
 [wbg-catch-unwind]: https://wasm-bindgen.github.io/wasm-bindgen/reference/catch-unwind.html
 [non-rustup]: ../prerequisites/non-rustup-setups.md
 

docs/src/commands/build.md

@@ -74,6 +74,13 @@ fn wasm_pack_local_version() -> Option<String> {
     Some(output.to_string())
 }
 
+/// Returns true for tier-3 wasm targets that have no rustup-prebuilt sysroot
+/// and must be built via `-Z build-std`. Currently this is the wasm64 family
+/// (`wasm64-unknown-unknown`, future `wasm64-*` variants).
+pub fn is_tier3_wasm(target_triple: &str) -> bool {
+    target_triple.starts_with("wasm64")
+}
+
 /// Run `cargo build` for Wasm with config derived from the given `BuildProfile`.
 pub fn cargo_build_wasm(
     path: &Path,
@@ -260,3 +267,18 @@ pub fn cargo_build_wasm_tests(
     child::run(cmd, "cargo build").context("Compilation of your program failed")?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn tier3_wasm_detection() {
+        assert!(is_tier3_wasm("wasm64-unknown-unknown"));
+        assert!(is_tier3_wasm("wasm64-wasi"));
+        assert!(!is_tier3_wasm("wasm32-unknown-unknown"));
+        assert!(!is_tier3_wasm("wasm32-wasi"));
+        assert!(!is_tier3_wasm("wasm32-unknown-emscripten"));
+        assert!(!is_tier3_wasm("x86_64-unknown-linux-gnu"));
+    }
+}

src/build/mod.rs

@@ -56,6 +56,17 @@ pub fn check_for_wasm_target(target: &str) -> Result<()> {
     let msg = format!("{}Checking for the Wasm target...", emoji::TARGET);
     PBAR.info(&msg);
 
+    // Tier-3 wasm targets (`wasm64-unknown-unknown`) have no rustup-prebuilt
+    // sysroot — they are built from source via `-Z build-std`, which requires
+    // a nightly toolchain and the `rust-src` component. wasm-pack doesn't
+    // inject `+nightly` or `-Z build-std` itself (those would override the
+    // user's `rust-toolchain.toml` or surprise users who hadn't intended a
+    // nightly build); instead we verify the active toolchain is nightly,
+    // heal the `rust-src` component if missing, and let cargo run.
+    if crate::build::is_tier3_wasm(target) {
+        return check_tier3_wasm_prerequisites(target);
+    }
+
     // Check if wasm32 target is present, otherwise bail.
     match check_target(target) {
         Ok(ref wasm32_check) if wasm32_check.found => Ok(()),
@@ -64,6 +75,67 @@ pub fn check_for_wasm_target(target: &str) -> Result<()> {
     }
 }
 
+/// Tier-3 (currently `wasm64-*`) prerequisites: nightly active toolchain +
+/// `rust-src` component. Does not inject any cargo flags.
+fn check_tier3_wasm_prerequisites(target: &str) -> Result<()> {
+    if !is_active_toolchain_nightly()? {
+        bail!(
+            "`{target}` is a tier-3 Rust target and requires the nightly \
+             toolchain (rustup has no prebuilt artifacts for it).\n\n\
+             Pin nightly for this project by adding a `rust-toolchain.toml`:\n\n\
+                 [toolchain]\n\
+                 channel = \"nightly\"\n\
+                 components = [\"rust-src\"]\n\n\
+             Or set `RUSTUP_TOOLCHAIN=nightly` for a one-off invocation.\n\n\
+             You also need cargo to build `std` from source. Add to your \
+             `.cargo/config.toml`:\n\n\
+                 [unstable]\n\
+                 build-std = [\"std\", \"panic_abort\"]\n\n\
+             Or pass `-Z build-std=std,panic_abort` as an extra cargo argument."
+        );
+    }
+
+    if !has_rust_src_component_for_active_toolchain()? {
+        install_rust_src_for_active_toolchain()?;
+    }
+
+    Ok(())
+}
+
+/// Returns true if the currently-active rustc resolves to a nightly channel.
+fn is_active_toolchain_nightly() -> Result<bool> {
+    let output = Command::new("rustc").arg("--version").output()?;
+    if !output.status.success() {
+        bail!("`rustc --version` failed: {}", output.status);
+    }
+    let stdout = String::from_utf8(output.stdout)?;
+    // `rustc --version` prints e.g. `rustc 1.79.0-nightly (abc123 2024-04-01)`.
+    Ok(stdout.contains("-nightly") || stdout.contains("-dev"))
+}
+
+fn has_rust_src_component_for_active_toolchain() -> Result<bool> {
+    let output = Command::new("rustup")
+        .args(["component", "list", "--installed"])
+        .output()?;
+    if !output.status.success() {
+        return Ok(false);
+    }
+    let stdout = String::from_utf8(output.stdout)?;
+    Ok(stdout.lines().any(|line| line.starts_with("rust-src")))
+}
+
+fn install_rust_src_for_active_toolchain() -> Result<()> {
+    let msg = format!(
+        "{}Installing rust-src component for the active toolchain...",
+        emoji::TARGET
+    );
+    PBAR.info(&msg);
+    let mut cmd = Command::new("rustup");
+    cmd.arg("component").arg("add").arg("rust-src");
+    child::run(cmd, "rustup").context("Adding the rust-src component with rustup")?;
+    Ok(())
+}
+
 /// Get rustc's sysroot as a PathBuf
 fn get_rustc_sysroot() -> Result<PathBuf> {
     let command = Command::new("rustc")