From d74241e69506e6361dc269044e30ac0e95ffc15e Mon Sep 17 00:00:00 2001
From: Luke Curley <432854+kixelated@users.noreply.github.com>
Date: Fri, 6 Nov 2026 23:18:14 -0800
Subject: [PATCH 1/5] chore(quest): claim quest/m4/bench-moq-pin.md

Quest-Claim: 1b78c0bd989c3ff1

From 010a9352ccb28ae07e3a1df82ecfaf14cafe0666 Mon Sep 17 00:00:00 2001
From: Luke Curley <432854+kixelated@users.noreply.github.com>
Date: Fri, 6 Nov 2026 23:31:06 -0800
Subject: [PATCH 2/5] chore(bench): bump the moq corpus past poll-first and
 drop moq-pure-crypto

moq main moved moq-relay's crypto onto rind, so the moq corpus is now the
pure-crypto build: it takes moq-pure-crypto's no-c guard and that corpus goes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/bench.yml |  2 --
 bench/build/README.md       |  7 +++----
 bench/build/corpus.toml     | 35 ++++++++++++++---------------------
 quest/m4/README.md          |  1 -
 quest/m4/bench-moq-pin.md   | 27 ---------------------------
 5 files changed, 17 insertions(+), 55 deletions(-)
 delete mode 100644 quest/m4/bench-moq-pin.md

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index c4fb39faa..6c23f7696 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -117,8 +117,6 @@ jobs:
             args: --corpus moq --variant nightly --variant jobs-frontend --variant cranelift --variant cache-proc-macros --variant nightly-control
           - name: moq ra-jit
             args: --corpus moq --variant ra-jit-baseline --variant ra-jit --no-attribute
-          - name: moq pure-crypto
-            args: --corpus moq --corpus moq-pure-crypto --variant baseline
           - name: pure
             args: --corpus regex --corpus wasmparser
 
diff --git a/bench/build/README.md b/bench/build/README.md
index d71731a33..cab6d2048 100644
--- a/bench/build/README.md
+++ b/bench/build/README.md
@@ -18,8 +18,7 @@ The run also ignores the caller's `CARGO*`, `RUSTC*`, `RUSTDOC*`, `RUSTUP*`, and
 
 ## Corpus
 
-- **moq** builds `moq-relay`, which pulls in moq-net, the QUIC stack, and C code through aws-lc-sys.
-- **moq-pure-crypto** builds the same `moq-relay` with its crypto on graviola and RustCrypto, so it compiles no C: the run fails if any crate in its build gains a `links` key or pulls in cc or cmake, while pure-Rust build scripts stay allowed.
+- **moq** builds `moq-relay`, which pulls in moq-net and the QUIC stack. Its crypto is on rind, which is pure Rust, so it compiles no C: the run fails if any crate in its build gains a `links` key or pulls in cc or cmake, while pure-Rust build scripts stay allowed.
 - **regex** and **wasmparser** are pure Rust: the run fails if any crate in their build gains a build script or a `links` key.
 
 Each corpus pins a git revision (and a lockfile when the project commits none).
@@ -32,7 +31,7 @@ Bump a pin in its own change, since numbers on either side of it do not compare.
 - `edit-leaf`: rebuild after a body edit in a crate nothing else in the build depends on.
 - `edit-hub`: the same edit in a crate most of the build depends on (moq-net in moq).
 - `edit-sync`: rebuild after an edit to the body of a sync function the build calls, in a module of the hub (moq: `goaway::Producer::send`, which moq-relay calls to drain a session).
-- `edit-async`: the same in an `async fn` (moq: `Session::closed`, which moq-relay awaits).
+- `edit-async`: the same in an `async fn` (moq: `Session::closed`, which moq-relay awaits, a wrapper over the sync `poll_closed`).
 - `test-build`: a clean build of the corpus's tests with `cargo nextest run --no-run`, as CI builds them with a cold cache.
 - `test-run`: run those tests, already built.
 - `test-edit`: rebuild the tests after the hub edit, as CI does when its compilation cache serves every dependency.
@@ -58,7 +57,7 @@ To measure a new build-speed change, add a variant whose base is the configurati
 
 The `ra-jit` variant builds with `cargo ra-jit` ([ra-jit](https://github.com/indexable-inc/ra-jit), pinned in `flake.nix` and compiled from source on a run that selects it), a daemon that compiles only the functions an edit changed and splices them into the program cargo linked, or hands the build back to cargo.
 ra-jit works with one rustc only, so its base, `ra-jit-baseline`, is plain cargo on that toolchain.
-Both run on the moq corpora only, since ra-jit needs a program to load, and skip `check`, which `cargo ra-jit` fails on moq.
+Both run on the moq corpus only, since ra-jit needs a program to load, and skip `check`, which `cargo ra-jit` fails on moq.
 The daemon keeps working after a build returns, so each ra-jit run waits for it to go idle before and after, and none of its work overlaps another run.
 Its CPU time adds the daemon's, its peak RSS adds what the daemon holds, and its instructions read `n/a`; the report also says how many of its runs the daemon built, and why cargo built the rest.
 The leaf and hub markers are functions nothing calls: rustc recompiles their crate and every crate that depends on it, while ra-jit, when it builds the edit itself, compiles nothing, so its times there are a lower bound.
diff --git a/bench/build/corpus.toml b/bench/build/corpus.toml
index e0518c36d..9733d358c 100644
--- a/bench/build/corpus.toml
+++ b/bench/build/corpus.toml
@@ -14,24 +14,28 @@
 [[corpus]]
 name = "moq"
 git = "https://github.com/moq-dev/moq"
-rev = "f36c8482066bb5704d02d7cf7ea5350f5f78e025"
+rev = "142b03bd5c8360444750872223b03db04b106978"
 args = ["-p", "moq-relay"]
 leaf = "rs/moq-relay/src/lib.rs"
 hub = "rs/moq-net/src/lib.rs"
-# What moq-relay calls to drain a session at shutdown, and awaits to see it close.
+no-c = true
+# What moq-relay calls to drain a session at shutdown, and awaits to see it close:
+# a wrapper over `poll_closed`, as moq writes an async fn.
 sync = ["rs/moq-net/src/goaway.rs", "pub fn send(self, goaway: Goaway) -> Result<()> {"]
 async = ["rs/moq-net/src/session.rs", "pub async fn closed(&self) -> Error {"]
 # The tests of every workspace crate moq-relay builds, under the profile moq's CI
-# uses. Not moq-auth's: its tests depend on its published self, so no package
-# spec names it alone. The versions pick the workspace crate over a published one.
+# uses. Not moq-auth's or moq-pattern's: moq-auth's tests depend on its published
+# self, which brings a published moq-pattern, and both share their workspace
+# twin's version, so no package spec names either alone. qmux's version picks the
+# workspace crate over a published one.
 test = [
     "--profile=ci",
-    "--package=kio@0.6.2",
-    "--package=moq-clock",
-    "--package=moq-flate",
+    "--package=kio",
+    "--package=kio-macros",
+    "--package=moq-congestion",
+    "--package=moq-crypto",
     "--package=moq-json",
     "--package=moq-net",
-    "--package=moq-pattern@0.1.2",
     "--package=moq-quic",
     "--package=moq-relay",
     "--package=moq-sock",
@@ -40,17 +44,6 @@ test = [
     "--package=qmux@0.7.0",
 ]
 
-# The moq corpus's rev plus moq-dev/moq's spike/pure-crypto branch, which moves
-# moq-relay's crypto off aws-lc-rs onto graviola and RustCrypto. Compare it with moq.
-[[corpus]]
-name = "moq-pure-crypto"
-git = "https://github.com/moq-dev/moq"
-rev = "fd53b86f6d3fd2b3d40be5e0c8c00f77f464c149"
-args = ["-p", "moq-relay"]
-leaf = "rs/moq-relay/src/lib.rs"
-hub = "rs/moq-net/src/lib.rs"
-no-c = true
-
 [[corpus]]
 name = "regex"
 git = "https://github.com/rust-lang/regex"
@@ -142,7 +135,7 @@ toolchain = "nightly"
 [[variant]]
 name = "ra-jit-baseline"
 toolchain = "ra-jit"
-corpora = ["moq", "moq-pure-crypto"]
+corpora = ["moq"]
 scenarios = ["build", "edit-leaf", "edit-hub", "edit-sync", "edit-async"]
 
 [[variant]]
@@ -150,5 +143,5 @@ name = "ra-jit"
 base = "ra-jit-baseline"
 toolchain = "ra-jit"
 subcommand = "ra-jit"
-corpora = ["moq", "moq-pure-crypto"]
+corpora = ["moq"]
 scenarios = ["build", "edit-leaf", "edit-hub", "edit-sync", "edit-async"]
diff --git a/quest/m4/README.md b/quest/m4/README.md
index d92634831..570b8fb9c 100644
--- a/quest/m4/README.md
+++ b/quest/m4/README.md
@@ -28,7 +28,6 @@ build's retired instructions by 16%.
 
 ## Required
 
-- [Bump the build benchmark's moq pin past poll-first](/quest/m4/bench-moq-pin.md) - the benchmark builds moq after poll-first, so its hub edit rebuilds the 10 crates main does
 - [Bench TPDE on moq](/quest/m4/tpde.md) - what TPDE cuts from moq's clean build and non-incremental edit; waits on `-Zllvm-tpde` reaching a nightly
 - [Waiting: a rustc and cargo fork](/quest/m4/fork.md) - the evidence ledger for carrying a fork; condition: enough measured reasons to pay for one
 - [moq in pure Go](/quest/m4/go/README.md) - rust2-go translating moq-net, with no cgo, fast enough to replace the cgo bindings for Go users
diff --git a/quest/m4/bench-moq-pin.md b/quest/m4/bench-moq-pin.md
deleted file mode 100644
index d41a9eedb..000000000
--- a/quest/m4/bench-moq-pin.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# [S] Bump the build benchmark's moq pin past poll-first
-
-## Goal
-
-The `moq` corpus in [corpus.toml](/bench/build/corpus.toml) pins a moq main
-after poll-first ([moq-dev/moq#7607](https://github.com/moq-dev/moq/pull/7607)),
-so the benchmark measures the moq its developers edit: the hub edit rebuilds the
-10 crates it rebuilds at main, not the pin's 8, and the async body edit is a
-thin wrapper over a `poll_*` function, as moq's rule makes it.
-
-## Plan
-
-Decided with the maintainer on 2026-11-07: m4. Found by the subset-compiler
-report ([moq-dev/rust2#615](https://github.com/moq-dev/rust2/pull/615)), which
-measured at moq main because the pin (`f36c848`) predates poll-first.
-
-- Land the bump on its own, as corpus.toml asks, so no report compares numbers
-  across it.
-- Update what names the old tree: the `sync` and `async` lines (at main,
-  `Session::closed` awaits `poll_closed`), the `test` package versions, and the
-  bench README's moq notes, such as the ra-jit bugs seen at the pin. At main,
-  the report saw `edit-async` fall back on usage-argv's `parsed_values_given`.
-- `moq-pure-crypto` is the old rev plus moq's `spike/pure-crypto` branch, so the
-  bump leaves it comparing a different tree. Recommended: merge moq main into a
-  new spike branch in moq-dev/moq and pin that, so the comparison still holds.
-- Out of scope: [nix.toml](/bench/build/nix.toml)'s own moq pin, which the Nix
-  comparison keeps for crane's dependency layer.

From 75e3896555d2eb25fe796fbc83dc6ee7c9796765 Mon Sep 17 00:00:00 2001
From: Luke Curley <432854+kixelated@users.noreply.github.com>
Date: Sat, 7 Nov 2026 00:33:20 -0800
Subject: [PATCH 3/5] fix(bench): build moq's rind with LLVM under the
 cranelift variant

rind's naked_asm! takes sym operands, which cg_clif cannot compile yet
(rust-lang/rustc_codegen_cranelift#1620). A variant's new `config` key passes
cargo --config values, so the cranelift variant picks its backend by profile
and overrides it for rind; RUSTFLAGS would come after any per-package flag.
The README's ra-jit notes now come from the run at the new pin.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 bench/build/README.md   | 10 +++++-----
 bench/build/corpus.toml |  9 ++++++---
 bench/build/run.sh      | 16 +++++++++-------
 3 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/bench/build/README.md b/bench/build/README.md
index cab6d2048..37dbf8e17 100644
--- a/bench/build/README.md
+++ b/bench/build/README.md
@@ -49,7 +49,7 @@ Over 21 CI runs since the sync, the controls' change had an RMS of 1.3% on `edit
 
 ## Variants
 
-A variant is a toolchain plus rustflags.
+A variant is a toolchain plus rustflags and cargo config.
 Each is compared against its `base`, run in the same job: the levers on stable against `baseline`, the nightly ones against `nightly`.
 The `control` variants repeat their base, so their change is the run's noise floor: an A/A control.
 Timed runs interleave the variants and rotate which goes first each round, so drift over a long job spreads across all of them.
@@ -63,11 +63,10 @@ Its CPU time adds the daemon's, its peak RSS adds what the daemon holds, and its
 The leaf and hub markers are functions nothing calls: rustc recompiles their crate and every crate that depends on it, while ra-jit, when it builds the edit itself, compiles nothing, so its times there are a lower bound.
 The body edits are functions the program runs, which ra-jit compiles.
 
-ra-jit bugs seen on moq at the pinned rev, not reported upstream:
+ra-jit bugs seen on moq, not reported upstream:
 
-- `cargo ra-jit check` with no build loaded reads every crate of the workspace, takes minutes and GBs, and fails on errors rustc does not report (`unresolved macro moq_clock::test` in moq-net's integration tests).
-- Async body edits in moq-net go to cargo (every `edit-async` run): "`new` is not compiled by ra-jit and rustc's copy is from before the edit: an instance of it does not compile". The daemon then loads the workspace again: on CI such an edit took 55.7 s and 222 CPU-s, against plain cargo's 9.1 s and 12.3 CPU-s ([run](https://github.com/moq-dev/rust2/actions/runs/40285528419)).
-- A fallback logs `Duplicate definition of identifier ... <cc::Build>::cargo_metadata` while compiling aws-lc-sys's build script.
+- Async body edits in moq-net go to cargo (every `edit-async` run): "`parsed_values_given` is not compiled by ra-jit and rustc's copy is from before the edit: an instance of it does not compile", a generic of usage-argv's. The daemon then loads the workspace again: on CI such an edit took 50.6 s and 196 CPU-s, against plain cargo's 10.5 s and 14.5 CPU-s ([run](https://github.com/moq-dev/rust2/actions/runs/42351623273)).
+- At the previous pin (`f36c848`), `cargo ra-jit check` with no build loaded read every crate of the workspace, took minutes and GBs, and failed on errors rustc does not report (`unresolved macro moq_clock::test` in moq-net's integration tests).
 - On a library-only build such as regex, `cargo ra-jit build` returns after `cargo clean` without building anything.
 
 The report shows wall time (trimmed mean, and mean ± standard deviation), CPU time and its change against the base, retired instructions, and peak RSS, all from hyperfine.
@@ -133,6 +132,7 @@ Recommended on 2026-10-25: moq's CI keeps building its tests with LLVM, since 42
 - 19 abort on an x86 SIMD intrinsic it does not implement, `llvm.x86.sse2.pmulhu.w` ([rustc_codegen_cranelift#171](https://github.com/rust-lang/rustc_codegen_cranelift/issues/171)). moq's CI runs on aarch64, whose intrinsics this x86 benchmark does not try.
 
 The `cranelift` variant's `build` numbers are for that abort build too.
+Since moq moved its crypto onto rind, the variant builds rind with LLVM: its `naked_asm!` takes `sym` operands, which Cranelift cannot compile yet ([rustc_codegen_cranelift#1620](https://github.com/rust-lang/rustc_codegen_cranelift/pull/1620)).
 
 Even passing, it would save little where CI spends its time.
 CPU seconds from the [PR run](https://github.com/moq-dev/rust2/actions/runs/40235946635) (4 CPUs; an A/A control on that run stayed within 3%):
diff --git a/bench/build/corpus.toml b/bench/build/corpus.toml
index 9733d358c..8322c47f3 100644
--- a/bench/build/corpus.toml
+++ b/bench/build/corpus.toml
@@ -67,8 +67,8 @@ pure = true
 
 # Each variant is one build configuration. `base` names the variant it is
 # compared against; a variant without one is a base. `rustflags` replaces any
-# host rustflags the corpus configures (none do today). `subcommand` goes between
-# cargo and `build` or `check`. `corpora` and `scenarios` limit a variant to those
+# host rustflags the corpus configures (none do today). `config` holds cargo
+# `--config` values, and `subcommand` goes between cargo and `build` or `check`. `corpora` and `scenarios` limit a variant to those
 # they list, which its base must run too. A variant without `scenarios` runs
 # `check`, `build`, `edit-leaf`, and `edit-hub`; only the levers worth their cost
 # list the body edits and the test scenarios.
@@ -106,11 +106,14 @@ base = "nightly"
 toolchain = "nightly"
 rustflags = "-Z unstable-options --jobs-frontend=8"
 
+# rind, moq's crypto, builds with LLVM: its naked_asm! takes sym operands, which
+# Cranelift cannot compile yet (rust-lang/rustc_codegen_cranelift#1620). A profile
+# picks the backend, since cargo passes RUSTFLAGS after a package's own flags.
 [[variant]]
 name = "cranelift"
 base = "nightly"
 toolchain = "nightly"
-rustflags = "-Z codegen-backend=cranelift"
+config = ["unstable.codegen-backend=true", 'profile.dev.codegen-backend="cranelift"', 'profile.dev.package.rind.codegen-backend="llvm"']
 scenarios = ["check", "build", "edit-leaf", "edit-hub", "test-build", "test-run", "test-edit"]
 
 [[variant]]
diff --git a/bench/build/run.sh b/bench/build/run.sh
index 694e6e8ec..6743360cc 100755
--- a/bench/build/run.sh
+++ b/bench/build/run.sh
@@ -235,7 +235,8 @@ check_graph() { # corpus rule cargo-args...
 }
 
 # Enters a variant's toolchain, flags, and target directory for the cargo calls that
-# follow, and sets `sub` to what goes between cargo and its subcommand.
+# follow, sets `sub` to what goes between cargo and its subcommand, and `rajit` to
+# whether the ra-jit daemon builds.
 use_variant() { # corpus variant
     case $(field variant "$2" .toolchain) in
         stable) PATH=$stable_path ;;
@@ -243,9 +244,10 @@ use_variant() { # corpus variant
         ra-jit) PATH=$rajit_path ;;
         *) die "variant $2 has no valid toolchain" ;;
     esac
+    mapfile -t sub < <(field variant "$2" '(.config // [])[] | "--config=" + .')
     case $(field variant "$2" .subcommand) in
-        '') sub=() ;;
-        ra-jit) sub=(ra-jit) ;;
+        '') rajit=0 ;;
+        ra-jit) rajit=1 && sub+=(ra-jit) ;;
         *) die "variant $2 has no valid subcommand" ;;
     esac
     RUSTFLAGS=$(field variant "$2" .rustflags)
@@ -315,7 +317,7 @@ time_once() { # corpus dir scenario variant prepare cargo-args...
         use_variant "$corpus" "$variant"
         cd "$dir"
         local before after counts measurement summary
-        if ((${#sub[@]})); then
+        if ((rajit)); then
             before=$(rajit_settle "$dir")
             counts=$(rajit_counts "$dir")
         fi
@@ -331,7 +333,7 @@ time_once() { # corpus dir scenario variant prepare cargo-args...
             measurement=$(jq -c --arg summary "$summary" '($summary | split(" ") | map(tonumber)) as [$run, $passed]
                 | . + {tests: {run: $run, failed: ($run - $passed)}}' <<<"$measurement")
         fi
-        if ((${#sub[@]})); then
+        if ((rajit)); then
             after=$(rajit_settle "$dir")
             measurement=$(jq -c --argjson before "$counts" --argjson after "$(rajit_counts "$dir")" \
                 --arg was "$before" --arg now "$after" '
@@ -411,7 +413,7 @@ bench_corpus() { # corpus dir
             cd "$dir"
             # The `||` below turns errexit off in here, so a failed build has to exit itself.
             cargo "${sub[@]}" build --locked --offline "${args[@]}" >"$out/logs/$corpus.$variant.log" 2>&1 || exit
-            ((${#sub[@]} == 0)) || rajit_settle "$dir" >/dev/null
+            ((rajit == 0)) || rajit_settle "$dir" >/dev/null
         ) || { tail -40 "$out/logs/$corpus.$variant.log" >&2 && die "$corpus failed to build with $variant"; }
     done
 
@@ -459,7 +461,7 @@ bench_corpus() { # corpus dir
                     use_variant "$corpus" "$variant"
                     cd "$dir"
                     cargo "${sub[@]}" "${cmd[@]}"
-                    ((${#sub[@]} == 0)) || rajit_settle "$dir" >/dev/null
+                    ((rajit == 0)) || rajit_settle "$dir" >/dev/null
                 )
             done
         fi

From 5015a6edb4e2d69fa710bbb384b4b9b04d8d2aee Mon Sep 17 00:00:00 2001
From: Luke Curley <432854+kixelated@users.noreply.github.com>
Date: Sat, 7 Nov 2026 00:55:50 -0800
Subject: [PATCH 4/5] fix(bench): pass a variant's cargo config after the
 command

Cargo drops a --config given before an external subcommand, so nextest built
the cranelift variant's tests with LLVM. Every cargo command now takes the
config last, and `sub` holds only the subcommand again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 bench/build/run.sh | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/bench/build/run.sh b/bench/build/run.sh
index 6743360cc..9454b4f3f 100755
--- a/bench/build/run.sh
+++ b/bench/build/run.sh
@@ -235,8 +235,9 @@ check_graph() { # corpus rule cargo-args...
 }
 
 # Enters a variant's toolchain, flags, and target directory for the cargo calls that
-# follow, sets `sub` to what goes between cargo and its subcommand, and `rajit` to
-# whether the ra-jit daemon builds.
+# follow, sets `sub` to what goes between cargo and its subcommand, and `cfg` to
+# what follows the command. Cargo does not forward a `--config` before an external
+# subcommand such as nextest, so the variant's config goes last.
 use_variant() { # corpus variant
     case $(field variant "$2" .toolchain) in
         stable) PATH=$stable_path ;;
@@ -244,12 +245,12 @@ use_variant() { # corpus variant
         ra-jit) PATH=$rajit_path ;;
         *) die "variant $2 has no valid toolchain" ;;
     esac
-    mapfile -t sub < <(field variant "$2" '(.config // [])[] | "--config=" + .')
     case $(field variant "$2" .subcommand) in
-        '') rajit=0 ;;
-        ra-jit) rajit=1 && sub+=(ra-jit) ;;
+        '') sub=() ;;
+        ra-jit) sub=(ra-jit) ;;
         *) die "variant $2 has no valid subcommand" ;;
     esac
+    mapfile -t cfg < <(field variant "$2" '(.config // [])[] | "--config=" + .')
     RUSTFLAGS=$(field variant "$2" .rustflags)
     CARGO_TARGET_DIR=$work/target/$1/$2
     export PATH RUSTFLAGS CARGO_TARGET_DIR
@@ -317,13 +318,13 @@ time_once() { # corpus dir scenario variant prepare cargo-args...
         use_variant "$corpus" "$variant"
         cd "$dir"
         local before after counts measurement summary
-        if ((rajit)); then
+        if ((${#sub[@]})); then
             before=$(rajit_settle "$dir")
             counts=$(rajit_counts "$dir")
         fi
         # hyperfine sends only stdout to the log; nextest and cargo report on stderr.
         hyperfine --style none --runs 1 --prepare "$prepare && sync" --export-json "$json" --output "$log" "${failure[@]}" \
-            --shell bash "$(printf '%q ' cargo "${sub[@]}" "$@") 2>&1" ||
+            --shell bash "$(printf '%q ' cargo "${sub[@]}" "$@" "${cfg[@]}") 2>&1" ||
             { tail -40 "$log" >&2 && die "$corpus $scenario failed with $variant"; }
         measurement=$(jq -c '.results[0].measurements[0]' "$json")
         if ((${#failure[@]})); then
@@ -333,7 +334,7 @@ time_once() { # corpus dir scenario variant prepare cargo-args...
             measurement=$(jq -c --arg summary "$summary" '($summary | split(" ") | map(tonumber)) as [$run, $passed]
                 | . + {tests: {run: $run, failed: ($run - $passed)}}' <<<"$measurement")
         fi
-        if ((rajit)); then
+        if ((${#sub[@]})); then
             after=$(rajit_settle "$dir")
             measurement=$(jq -c --argjson before "$counts" --argjson after "$(rajit_counts "$dir")" \
                 --arg was "$before" --arg now "$after" '
@@ -412,8 +413,8 @@ bench_corpus() { # corpus dir
             rm -rf "$CARGO_TARGET_DIR"
             cd "$dir"
             # The `||` below turns errexit off in here, so a failed build has to exit itself.
-            cargo "${sub[@]}" build --locked --offline "${args[@]}" >"$out/logs/$corpus.$variant.log" 2>&1 || exit
-            ((rajit == 0)) || rajit_settle "$dir" >/dev/null
+            cargo "${sub[@]}" build --locked --offline "${args[@]}" "${cfg[@]}" >"$out/logs/$corpus.$variant.log" 2>&1 || exit
+            ((${#sub[@]} == 0)) || rajit_settle "$dir" >/dev/null
         ) || { tail -40 "$out/logs/$corpus.$variant.log" >&2 && die "$corpus failed to build with $variant"; }
     done
 
@@ -460,8 +461,8 @@ bench_corpus() { # corpus dir
                 (
                     use_variant "$corpus" "$variant"
                     cd "$dir"
-                    cargo "${sub[@]}" "${cmd[@]}"
-                    ((rajit == 0)) || rajit_settle "$dir" >/dev/null
+                    cargo "${sub[@]}" "${cmd[@]}" "${cfg[@]}"
+                    ((${#sub[@]} == 0)) || rajit_settle "$dir" >/dev/null
                 )
             done
         fi

From 59c3a2a3c81726808f4bdca42b1399be09ad49e9 Mon Sep 17 00:00:00 2001
From: Luke Curley <432854+kixelated@users.noreply.github.com>
Date: Sat, 7 Nov 2026 02:10:56 -0800
Subject: [PATCH 5/5] quest(m3): count moq's Cranelift test failures at the new
 bench pin

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 quest/m3/cranelift-unwind.md | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/quest/m3/cranelift-unwind.md b/quest/m3/cranelift-unwind.md
index 302ffaea7..0eefeed9c 100644
--- a/quest/m3/cranelift-unwind.md
+++ b/quest/m3/cranelift-unwind.md
@@ -2,16 +2,22 @@
 
 ## Goal
 
-Waits on upstream. 42 of moq's tests fail under the Cranelift backend that
-ships with nightly, so moq's CI cannot build its tests with it:
+Waits on upstream. 58 of moq's 6379 tests fail under the Cranelift backend
+that ships with nightly, so moq's CI cannot build its tests with it:
 
-- It builds every panic as an abort, so a test that catches one fails.
+- It builds every panic as an abort, so the 27 tests that catch one fail.
   Unwinding on Unix is a flag on cg_clif's own build, off by default over its
   compile-time cost
   ([rustc_codegen_cranelift#1567](https://github.com/rust-lang/rustc_codegen_cranelift/issues/1567)).
-- It lacks the x86 intrinsic `llvm.x86.sse2.pmulhu.w`
+- It lacks the x86 intrinsic `llvm.x86.sse2.pmulhu.w`, which 31 hit
   ([rustc_codegen_cranelift#171](https://github.com/rust-lang/rustc_codegen_cranelift/issues/171)).
 
+It also cannot compile rind, moq's crypto, whose `naked_asm!` takes `sym`
+operands
+([rustc_codegen_cranelift#1620](https://github.com/rust-lang/rustc_codegen_cranelift/pull/1620)),
+so a Cranelift build of moq picks LLVM for rind by profile, as the benchmark
+does.
+
 Check the issues, or the [build benchmark](/bench/build/README.md)'s moq
 report after a nightly pin bump: once `test-run` cranelift fails no tests,
 decide again from the test scenarios whether moq's CI builds its tests with