Mob islands: villagers draw their own random under the parallel tick, and ordered waits sleep

A mob's first draw on the ordered level random made every lane wait for all earlier mobs, and in a farm-shaped level all of those first draws were villager brains. With HORIZON_PARALLEL_TICK on, a villager's brain now draws from a private random seeded from its own entity random (serial and grouped alike, so grouped still equals serial). Ordered waits spin, yield, then sleep on a condvar. Adds pm_shaped_bench. Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Merge pull request #15501 from rdbtCVS/t3/mob-turn-hooks-at-build
2026-11-12 18:35:16 -10:00 · 2026-11-13 03:26:46 +00:00 · 2026-11-12 19:45:27 +00:00 · 2026-11-12 19:23:16 +00:00 · 2026-11-12 19:23:16 +00:00 · 2026-11-12 19:23:05 +00:00
545 changed files with 64085 additions and 4244 deletions
@@ -0,0 +1,4 @@
+# `cargo xtask …` runs the repository's task crate, so the commands in docs/perf-platform.md and
+# web/perf/README.md work as written. `cargo run -p xtask -- …` stays equivalent.
+[alias]
+xtask = "run --package xtask --"
@@ -0,0 +1,56 @@
+name: perf-wasm
+# The site consumes this reader bundle from horizon-rust/horizon-site.
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'crates/horizon-perf/**'
+      - 'crates/horizon-perf-format/**'
+      - 'crates/horizon-bench/**'
+      - 'xtask/**'
+      - 'Cargo.lock'
+      - 'Cargo.toml'
+      - '.github/workflows/perf-wasm.yml'
+  pull_request:
+    types: [opened, synchronize, reopened]
+    paths:
+      - 'crates/horizon-perf/**'
+      - 'crates/horizon-perf-format/**'
+      - 'crates/horizon-bench/**'
+      - 'xtask/**'
+      - 'Cargo.lock'
+      - 'Cargo.toml'
+      - '.github/workflows/perf-wasm.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: perf-wasm-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    env:
+      HORIZON_TELEMETRY_URL: "off"
+    steps:
+      - uses: actions/checkout@v7
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: wasm32-unknown-unknown
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: perf-wasm
+      # The agreement test: the C ABI, called natively, must print the bytes the CLI prints.
+      - name: The wasm ABI agrees with the CLI
+        run: cargo test -p horizon-perf --features wasm --test wasm
+      - name: Build the wasm the page loads
+        run: cargo run -p xtask -- perf-wasm
+      - uses: actions/upload-artifact@v4
+        with:
+          name: perf-wasm
+          path: target/perf-wasm
+          if-no-files-found: error
@@ -102,6 +102,7 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 | `horizon-shader-api` | Horizon's own WGSL shader packs ([docs/api/shaders.md](docs/api/shaders.md)): `horizon-shaders.toml`, the `.hshader` package; shared by the game, the launcher and the registry |
 | `horizon-shaders` | Shader packs (the `shaders/` folder format), rebuilt clean-room from a written spec of the format; no wgpu |
 | `horizon-theme` | Design tokens and fonts for the launcher, the game's own menus and the website |
+| `horizon-perf-format` | The `.hzperf` capture contract ([docs/perf-platform.md](docs/perf-platform.md) §3): `proto/horizon/perf/v1/capture.proto`, its generated types, the gzip writer and its thread. No Horizon dependencies; nothing in the game reads a capture |
 | `horizon-telemetry`, `horizon-telemetry-server`, `horizon-bench` | Opt-in data collection, its ingest server, the benchmark report format |
 | `horizon-system` | The machine the game runs on (OS, CPU, memory, drive, power, GPU maker and memory), for the crash report, the renderer's GPU info and telemetry |
 | `horizon-platform` | The platform's public API: what the Horizon layer may use of the engine ([docs/layers.md](docs/layers.md)); re-exports `horizon-system` today |
@@ -213,7 +214,7 @@ state stays separate from the library tests. This compiles gameplay twice for ex
 | Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`, `mobs/cem.rs` + `mobs/cem_anim.rs` (OptiFine/EMF entity models and their animations); `horizon-client-core/src/lang.rs`; crates `horizon-assets`, `horizon-optifine`; G: `packs.rs` |
 | Agent control | L: `control.rs` (socket), `bin/horizon-ctl/`; G: `control.rs`, `agent.rs`, `events.rs`, `ui_control.rs` ([docs/agent-control.md](docs/agent-control.md)) |
 | Mods | crate `horizon-mods`; G: `mods.rs`; L: `mod_content.rs`, `mod_list.rs` |
-| Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs`, `tweaks.rs`, `options.rs` |
+| Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs` + `extras/` (each extra's glue: `mouse_tweaks.rs`, `sorting.rs`, `pvp.rs`, `reconnect.rs`), `options.rs` |

 ## How `Game` is organised

@@ -18,6 +18,15 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618"

+[[package]]
+name = "addr2line"
+version = "0.26.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59317f77929f0e679d39364702289274de2f0f0b22cbf50b2b8cff2169a0b27a"
+dependencies = [
+ "gimli",
+]
+
 [[package]]
 name = "adler2"
 version = "2.0.1"
@@ -129,6 +138,12 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "anyhow"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
+
 [[package]]
 name = "arboard"
 version = "3.7.0"
@@ -264,6 +279,12 @@ version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"

+[[package]]
+name = "beef"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
+
 [[package]]
 name = "bit-set"
 version = "0.10.0"
@@ -559,7 +580,7 @@ checksum = "af491d569909a7e4dee0ad7db7f5341fef5c614d5b8ec8cf765732aba3cff681"
 dependencies = [
 "serde",
 "termcolor",
- "unicode-width",
+ "unicode-width 0.2.2",
 ]

 [[package]]
@@ -1011,6 +1032,12 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"

+[[package]]
+name = "fastrand"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
+
 [[package]]
 name = "fdeflate"
 version = "0.3.7"
@@ -1109,6 +1136,18 @@ dependencies = [
 "percent-encoding",
 ]

+[[package]]
+name = "framehop"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f54fe4785e899d4d6f43793b151c63c5647240fc630b005509d2614a939f693"
+dependencies = [
+ "arrayvec",
+ "cfg-if",
+ "fallible-iterator",
+ "gimli",
+]
+
 [[package]]
 name = "fs4"
 version = "1.1.0"
@@ -1246,6 +1285,15 @@ dependencies = [
 "windows 0.62.2",
 ]

+[[package]]
+name = "gimli"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf7f043f89559805f8c7cacc432749b2fa0d0a0a9ee46ce47164ed5ba7f126c"
+dependencies = [
+ "stable_deref_trait",
+]
+
 [[package]]
 name = "gl_generator"
 version = "0.14.0"
@@ -1426,7 +1474,7 @@ dependencies = [
 name = "horizon-bench"
 version = "0.1.0"
 dependencies = [
- "horizon-telemetry",
+ "horizon-system",
 "serde",
 "serde_json",
 ]
@@ -1482,6 +1530,8 @@ dependencies = [
 "horizon-mods",
 "horizon-narrator",
 "horizon-optifine",
+ "horizon-perf",
+ "horizon-perf-format",
 "horizon-protocol",
 "horizon-server-files",
 "horizon-shader-api",
@@ -1561,6 +1611,8 @@ dependencies = [
 "horizon-mods",
 "horizon-narrator",
 "horizon-optifine",
+ "horizon-perf",
+ "horizon-perf-format",
 "horizon-protocol",
 "horizon-server-files",
 "horizon-shader-api",
@@ -1615,6 +1667,8 @@ dependencies = [
 "horizon-items",
 "horizon-narrator",
 "horizon-optifine",
+ "horizon-perf",
+ "horizon-perf-format",
 "horizon-polytone",
 "horizon-protocol",
 "horizon-shader-api",
@@ -1832,6 +1886,7 @@ dependencies = [
 "horizon-game",
 "horizon-heartbeat",
 "horizon-official-servers",
+ "horizon-perf-share",
 "horizon-platform",
 "log",
 "winresource",
@@ -1856,12 +1911,54 @@ dependencies = [
 "regex",
 ]

+[[package]]
+name = "horizon-perf"
+version = "0.1.0"
+dependencies = [
+ "flate2",
+ "horizon-bench",
+ "horizon-perf-format",
+ "horizon-perf-share",
+ "prost",
+ "regex",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "horizon-perf-format"
+version = "0.1.0"
+dependencies = [
+ "flate2",
+ "prost",
+ "prost-build",
+ "prost-types",
+ "protox",
+]
+
+[[package]]
+name = "horizon-perf-share"
+version = "0.1.0"
+dependencies = [
+ "getrandom 0.3.4",
+ "horizon-addresses",
+ "horizon-platform",
+ "log",
+ "open",
+ "serde",
+ "serde_json",
+ "ureq",
+ "url",
+]
+
 [[package]]
 name = "horizon-platform"
 version = "0.1.0"
 dependencies = [
+ "horizon-bench",
 "horizon-core",
 "horizon-hooks",
+ "horizon-perf-format",
 "horizon-prepare",
 "horizon-protocol",
 "horizon-server-files",
@@ -1946,7 +2043,6 @@ dependencies = [
 "chrono",
 "getrandom 0.3.4",
 "horizon-anticheat",
- "horizon-bench",
 "horizon-chat-filter",
 "horizon-mcp",
 "horizon-platform",
@@ -2030,9 +2126,14 @@ version = "0.1.0"
 name = "horizon-threads"
 version = "0.1.0"
 dependencies = [
+ "addr2line",
+ "framehop",
 "libc",
 "libmimalloc-sys",
+ "memmap2",
 "mimalloc",
+ "object",
+ "rustc-demangle",
 "windows-sys 0.61.2",
 ]

@@ -2042,6 +2143,7 @@ version = "0.1.0"
 dependencies = [
 "flate2",
 "horizon-core",
+ "horizon-threads",
 "libm",
 "log",
 "lz4_flex",
@@ -2283,6 +2385,15 @@ dependencies = [
 "once_cell",
 ]

+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.18"
@@ -2509,6 +2620,72 @@ version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"

+[[package]]
+name = "logos"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff472f899b4ec2d99161c51f60ff7075eeb3097069a36050d8037a6325eb8154"
+dependencies = [
+ "logos-derive 0.15.1",
+]
+
+[[package]]
+name = "logos"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb2c55a318a87600ea870ff8c2012148b44bf18b74fad48d0f835c38c7d07c5f"
+dependencies = [
+ "logos-derive 0.16.1",
+]
+
+[[package]]
+name = "logos-codegen"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "192a3a2b90b0c05b27a0b2c43eecdb7c415e29243acc3f89cc8247a5b693045c"
+dependencies = [
+ "beef",
+ "fnv",
+ "lazy_static",
+ "proc-macro2",
+ "quote",
+ "regex-syntax",
+ "rustc_version",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "logos-codegen"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58b3ffaa284e1350d017a57d04ada118c4583cf260c8fb01e0fe28a2e9cf8970"
+dependencies = [
+ "fnv",
+ "proc-macro2",
+ "quote",
+ "regex-automata",
+ "regex-syntax",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "logos-derive"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "605d9697bcd5ef3a42d38efc51541aa3d6a4a25f7ab6d1ed0da5ac632a26b470"
+dependencies = [
+ "logos-codegen 0.15.1",
+]
+
+[[package]]
+name = "logos-derive"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52d3a9855747c17eaf4383823f135220716ab49bea5fbea7dd42cc9a92f8aa31"
+dependencies = [
+ "logos-codegen 0.16.1",
+]
+
 [[package]]
 name = "lru"
 version = "0.18.5"
@@ -2551,6 +2728,28 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "miette"
+version = "7.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f98efec8807c63c752b5bd61f862c165c115b0a35685bdcfd9238c7aeb592b7"
+dependencies = [
+ "cfg-if",
+ "miette-derive",
+ "unicode-width 0.1.14",
+]
+
+[[package]]
+name = "miette-derive"
+version = "7.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db5b29714e950dbb20d5e6f74f9dcec4edbcc1067bb7f8ed198c097b8c1a818b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "mimalloc"
 version = "0.1.52"
@@ -2604,6 +2803,12 @@ dependencies = [
 "windows-sys 0.61.2",
 ]

+[[package]]
+name = "multimap"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084"
+
 [[package]]
 name = "multiversion_no_op"
 version = "1.0.0"
@@ -3184,6 +3389,15 @@ dependencies = [
 "objc2-foundation 0.2.2",
 ]

+[[package]]
+name = "object"
+version = "0.39.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e5a6c098c7a3b6547378093f5cc30bc54fd361ce711e05293a5cc589562739b"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "oid-registry"
 version = "0.8.1"
@@ -3515,6 +3729,16 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa"

+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "proc-macro-crate"
 version = "3.5.0"
@@ -3539,6 +3763,96 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5"

+[[package]]
+name = "prost"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "528ac67416ff8646872a3c02cad9cc4ee5dc9f9540c9b10771855c95cb2e5ae1"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-build"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03da047801ff44bb6a4d407d4860c05fd70bb81714e6b2f3812603d5b145b042"
+dependencies = [
+ "heck",
+ "itertools",
+ "log",
+ "multimap",
+ "petgraph",
+ "prettyplease",
+ "prost",
+ "prost-types",
+ "regex",
+ "syn 2.0.119",
+ "tempfile",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b570b25f7617e43d59005d0990ccb79e950a423952cea19671b7a876da390adf"
+dependencies = [
+ "anyhow",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "prost-reflect"
+version = "0.16.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01b80ea363c31af2de2b92e3c07ed1156628f7838c4afb4df75ee78a37fedbd1"
+dependencies = [
+ "logos 0.16.1",
+ "miette",
+ "prost",
+ "prost-types",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f94967dc7688f3054c7fac87473ffae4cc4c3904800e2d9f5b857246d8963b0a"
+dependencies = [
+ "prost",
+]
+
+[[package]]
+name = "protox"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f25a07a73c6717f0b9bbbd685918f5df9815f7efba450b83d9c9dea41f0e3a1"
+dependencies = [
+ "bytes",
+ "miette",
+ "prost",
+ "prost-reflect",
+ "prost-types",
+ "protox-parse",
+ "thiserror 2.0.21",
+]
+
+[[package]]
+name = "protox-parse"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "072eee358134396a4643dff81cfff1c255c9fbd3fb296be14bdb6a26f9156366"
+dependencies = [
+ "logos 0.15.1",
+ "miette",
+ "prost-types",
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "quick-error"
 version = "2.0.1"
@@ -3838,6 +4152,12 @@ dependencies = [
 "smallvec",
 ]

+[[package]]
+name = "rustc-demangle"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b74b56ffa8bb2830709a538c2cbcae9aa062db0d2a42563bfb09bdaae44020eb"
+
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"
@@ -4396,6 +4716,18 @@ dependencies = [
 "syn 3.0.6",
 ]

+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "once_cell",
+ "rustix 1.1.5",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "termcolor"
 version = "1.4.1"
@@ -4665,6 +4997,12 @@ version = "1.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"

+[[package]]
+name = "unicode-width"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+
 [[package]]
 name = "unicode-width"
 version = "0.2.2"
@@ -37,6 +37,9 @@ members = [
    "crates/horizon-discord",
    "crates/horizon-official-servers",
    "crates/horizon-bench",
+    "crates/horizon-perf-format",
+    "crates/horizon-perf",
+    "crates/horizon-perf-share",
    "crates/horizon-friends",
    "crates/horizon-relay",
    "crates/horizon-mods",
@@ -62,6 +62,8 @@ The GLSL frontend also resets the common type for each comma-separated declarato
 variable's array specifier does not change later variables.
 It also reads a struct member outside a constant expression through a pointer to the member,
 not out of a loaded copy of the whole struct, so a member an atomic function uses can be read.
+The shared interpolation defaults also compile with `glsl-in` alone, without needing the
+SPIR-V or WGSL frontend to enable them.

 ## DirectX Shader Compiler

@@ -35,6 +35,12 @@ pub const COSMETICS_API: &str = "https://cosmetics.playhorizon.dev";
 /// "I'm playing" ping, benchmark uploads (`HORIZON_TELEMETRY_URL` overrides it).
 pub const TELEMETRY: &str = "https://telemetry.playhorizon.dev";

+/// The performance viewer page a saved capture opens in (`HORIZON_PERF_VIEWER` overrides it).
+pub const PERF_VIEWER: &str = "https://playhorizon.dev/perf";
+
+/// The capture upload API behind Share (`HORIZON_PERF_CAPTURES` overrides it).
+pub const PERF_CAPTURES: &str = "https://playhorizon.dev/api/perf/captures";
+
 /// Public STUN servers for Play with Friends' NAT discovery: two independent operators, so one
 /// outage doesn't break discovery (`HORIZON_STUN_SERVERS` overrides them).
 pub const STUN_SERVERS: &[&str] = &["stun.cloudflare.com:3478", "stun.l.google.com:19302"];
@@ -206,7 +206,7 @@ impl Config {
        Ok(file.anticheat)
    }

-    /// Thresholds can't be negative.
+    /// Thresholds can't be negative, and neither can the timer's milliseconds.
    pub fn check(&self) -> Result<(), String> {
        for &c in Check::ALL {
            let a = self.actions(c);
@@ -220,6 +220,18 @@ impl Config {
                ));
            }
        }
+        // A negative tolerance flags a client on time every tick, and so does a cap below minus the
+        // tolerance (the balance rests at the cap); NaN never flags, or never caps the balance. No
+        // negative number of milliseconds means anything, so all are refused.
+        if [self.timer.tolerance_ms, self.timer.max_lag_ms]
+            .iter()
+            .any(|v| !v.is_finite() || *v < 0.0)
+        {
+            return Err(
+                "anticheat.timer: tolerance_ms and max_lag_ms are numbers of milliseconds from 0 up"
+                    .into(),
+            );
+        }
        let tolerance = self.prediction.tolerance;
        if !tolerance.is_finite() || tolerance <= 0.0 {
            return Err("anticheat.prediction: tolerance is a number of blocks above 0".into());
@@ -361,6 +373,26 @@ mod tests {
        assert!(Config::from_server_toml("[anticheat.timer]\nkick = -1\n").is_err());
    }

+    /// A negative `tolerance_ms` flags a client on time every tick, and so does a `max_lag_ms` below
+    /// `-tolerance_ms` (the balance rests at the cap); a NaN turns the check (or its cap) off without a
+    /// word. Every negative or non-finite value is refused, as a negative threshold is.
+    #[test]
+    fn refuses_timer_settings_that_are_not_milliseconds_from_0_up() {
+        for bad in [
+            "tolerance_ms = -1",
+            "tolerance_ms = nan",
+            "tolerance_ms = inf",
+            "max_lag_ms = -1",
+            "max_lag_ms = nan",
+        ] {
+            let text = format!("[anticheat.timer]\n{bad}\n");
+            let e = Config::from_server_toml(&text).expect_err(bad);
+            assert!(e.starts_with("anticheat.timer:"), "{bad}: {e}");
+        }
+        let edge = "[anticheat.timer]\ntolerance_ms = 0\nmax_lag_ms = 0\n";
+        assert!(Config::from_server_toml(edge).is_ok());
+    }
+
    #[test]
    fn levels_rise_decay_and_act_in_order() {
        let mut c = on();
@@ -45,6 +45,11 @@ mod tests {

    /// `seconds` of server ticks of `server_ms` each, with `per_tick` client ticks handled in each.
    fn run(b: &mut Balance, server_ms: f64, per_tick: f64, seconds: f64) -> usize {
+        run_at(b, 20.0, server_ms, per_tick, seconds)
+    }
+
+    /// [`run`] at the tick rate `rate` (`/tick rate`), which the client's ticks follow.
+    fn run_at(b: &mut Balance, rate: f32, server_ms: f64, per_tick: f64, seconds: f64) -> usize {
        let c = TimerConfig::default();
        let mut owed = 0.0;
        let mut flags = 0;
@@ -53,12 +58,31 @@ mod tests {
            owed += per_tick;
            while owed >= 1.0 {
                owed -= 1.0;
-                flags += usize::from(b.tick_end(20.0, &c).is_some());
+                flags += usize::from(b.tick_end(rate, &c).is_some());
            }
        }
        flags
    }

+    /// At another tick rate a vanilla client ticks at the rate the server sent it, and each of its
+    /// ticks is worth `1000 / rate` ms: never flagged on time, flagged again and again 1.5 times as fast.
+    #[test]
+    fn the_balance_follows_the_tick_rate() {
+        for rate in [10.0_f32, 60.0] {
+            let tick_ms = 1000.0 / f64::from(rate);
+            assert_eq!(
+                run_at(&mut Balance::default(), rate, tick_ms, 1.0, 600.0),
+                0,
+                "on time at {rate}"
+            );
+            // Half a tick ahead every server tick: 75 flags in a minute at 10 a second, 94 at 60.
+            let flags = run_at(&mut Balance::default(), rate, tick_ms, 1.5, 60.0);
+            assert!(flags >= 50, "1.5 times as fast at {rate}: {flags} flags");
+        }
+        // The rate counts: at 10 a second, a client sending 20 ticks a second is twice as fast.
+        assert!(run_at(&mut Balance::default(), 10.0, 100.0, 2.0, 60.0) >= 50);
+    }
+
    #[test]
    fn a_vanilla_client_is_never_flagged() {
        let mut b = Balance::default();
@@ -9,5 +9,7 @@ description = "The benchmark report format (docs/benchmark-report.md), shared by
 [dependencies]
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-# The hardware probes shared with telemetry (cores, clocks, drive, VRAM, power, form).
-horizon-telemetry = { path = "../horizon-telemetry", default-features = false }
+# The hardware probes (cores, clocks, drive, VRAM, power, form); a reader of reports (the wasm
+# build of horizon-perf) needs the types below, never the probes.
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+horizon-system = { path = "../horizon-system" }
@@ -0,0 +1,434 @@
+//! Paired A/B comparison of benchmark blocks (docs/benchmark-report.md, "A/B runs").
+
+use std::collections::BTreeMap;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{round, Frames};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Verdict {
+    TooFewPairs,
+    WithinNoise,
+    Negligible,
+    Slower,
+    Faster,
+}
+
+/// B against A over paired blocks; lower milliseconds are better.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Paired {
+    pub pairs: usize,
+    pub a: f64,
+    pub b: f64,
+    /// Hodges-Lehmann estimate of b - a.
+    pub diff: f64,
+    /// Absent when `a` is zero.
+    pub diff_pct: Option<f64>,
+    /// Exact Wilcoxon signed-rank interval; absent below 6 pairs.
+    pub ci95: Option<[f64; 2]>,
+    pub confidence: Option<f64>,
+    /// Median distance between neighbouring blocks of the same arm.
+    pub noise: Option<f64>,
+    pub verdict: Verdict,
+}
+
+type Getter = fn(&Frames) -> Option<f64>;
+
+fn median(values: &[f64]) -> f64 {
+    let mut v = values.to_vec();
+    v.sort_by(f64::total_cmp);
+    match v.len() {
+        0 => 0.0,
+        n if n % 2 == 1 => v[n / 2],
+        n => (v[n / 2 - 1] + v[n / 2]) / 2.0,
+    }
+}
+
+fn round4(v: f64) -> f64 {
+    (v * 10_000.0).round() / 10_000.0
+}
+
+/// `(a, b)` per pair, `noise` left for the caller.
+pub fn paired(pairs: &[(f64, f64)]) -> Paired {
+    let n = pairs.len();
+    let a = median(&pairs.iter().map(|p| p.0).collect::<Vec<_>>());
+    let b = median(&pairs.iter().map(|p| p.1).collect::<Vec<_>>());
+    let d: Vec<f64> = pairs.iter().map(|p| p.1 - p.0).collect();
+    let mut walsh = Vec::with_capacity(n * (n + 1) / 2);
+    for i in 0..n {
+        for j in i..n {
+            walsh.push((d[i] + d[j]) / 2.0);
+        }
+    }
+    walsh.sort_by(f64::total_cmp);
+    let diff = median(&walsh);
+    let interval = interval(n, &walsh);
+    let verdict = match interval {
+        None => Verdict::TooFewPairs,
+        Some(([lo, hi], _)) if lo <= 0.0 && 0.0 <= hi => Verdict::WithinNoise,
+        Some(_) if diff.abs() < 0.05_f64.max(0.02 * a) => Verdict::Negligible,
+        Some(([lo, _], _)) if lo > 0.0 => Verdict::Slower,
+        Some(_) => Verdict::Faster,
+    };
+    Paired {
+        pairs: n,
+        a: round(a) + 0.0,
+        b: round(b) + 0.0,
+        diff: round(diff) + 0.0,
+        diff_pct: (a != 0.0).then(|| round(100.0 * diff / a) + 0.0),
+        ci95: interval.map(|([lo, hi], _)| [round(lo) + 0.0, round(hi) + 0.0]),
+        confidence: interval.map(|(_, c)| round4(c)),
+        noise: None,
+        verdict,
+    }
+}
+
+/// The widest symmetric interval of the sorted Walsh averages whose tails hold at most 2.5% each, and its confidence.
+fn interval(n: usize, walsh: &[f64]) -> Option<([f64; 2], f64)> {
+    let m = walsh.len();
+    // Null probabilities of T+ (halving is exact in binary, so these are the counts over 2^n).
+    let mut p = vec![0.0f64; m + 1];
+    p[0] = 1.0;
+    for r in 1..=n {
+        for t in (0..=m).rev() {
+            p[t] = (p[t] + if t >= r { p[t - r] } else { 0.0 }) / 2.0;
+        }
+    }
+    let (mut k, mut tail, mut best) = (0, 0.0, 0.0);
+    while k < m {
+        tail += p[k];
+        if tail > 0.025 {
+            break;
+        }
+        k += 1;
+        best = tail;
+    }
+    (k >= 1).then(|| ([walsh[k - 1], walsh[m - k]], 1.0 - 2.0 * best))
+}
+
+/// The result of an A/B run: pairs of blocks in B A A B order, recomputable from the report's `frames`.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ab {
+    pub switch: String,
+    pub a: String,
+    pub b: String,
+    pub pairs: u32,
+    pub block_s: f64,
+    pub warmup_s: f64,
+    /// Block 0 (measured before any switch) lies outside the later B blocks.
+    pub first_block_outside_range: bool,
+    /// By `gpu_p50_ms`, `cpu_p50_ms`, `frame_p50_ms`; a metric missing from any block is left out.
+    pub result: BTreeMap<String, Paired>,
+}
+
+impl Ab {
+    /// Pairs the `ab.a`/`ab.b` entries of `frames` by `repeat` (0, 1, 2...): pair k is blocks 2k and 2k+1.
+    pub fn from_frames(
+        switch: &str,
+        a: &str,
+        b: &str,
+        block_s: f64,
+        warmup_s: f64,
+        frames: &[Frames],
+    ) -> Result<Ab, String> {
+        let mut blocks: Vec<&Frames> = frames
+            .iter()
+            .filter(|f| f.phase == "ab.a" || f.phase == "ab.b")
+            .collect();
+        blocks.sort_by_key(|f| f.repeat);
+        if blocks.is_empty()
+            || !blocks.len().is_multiple_of(2)
+            || blocks
+                .iter()
+                .enumerate()
+                .any(|(i, f)| f.repeat as usize != i)
+        {
+            return Err("A/B blocks must be numbered 0..N with N even".to_owned());
+        }
+        if blocks.chunks(2).any(|p| p[0].phase == p[1].phase) {
+            return Err("each pair needs one ab.a and one ab.b block".to_owned());
+        }
+        let pairs = blocks.len() / 2;
+        let metrics: [(&str, Getter); 3] = [
+            ("gpu_p50_ms", |f| f.gpu_p50_ms),
+            ("cpu_p50_ms", |f| f.cpu_p50_ms),
+            ("frame_p50_ms", |f| Some(f.p50_ms)),
+        ];
+        let mut result = BTreeMap::new();
+        let mut series: BTreeMap<&str, Vec<f64>> = BTreeMap::new();
+        for (name, get) in metrics {
+            let Some(values) = blocks.iter().map(|f| get(f)).collect::<Option<Vec<f64>>>() else {
+                continue;
+            };
+            let by_arm: Vec<(f64, f64)> = blocks
+                .chunks(2)
+                .zip(values.chunks(2))
+                .map(|(p, v)| {
+                    if p[0].phase == "ab.a" {
+                        (v[0], v[1])
+                    } else {
+                        (v[1], v[0])
+                    }
+                })
+                .collect();
+            let mut stat = paired(&by_arm);
+            let gaps: Vec<f64> = (1..values.len().saturating_sub(1))
+                .step_by(2)
+                .filter(|&i| blocks[i].phase == blocks[i + 1].phase)
+                .map(|i| (values[i] - values[i + 1]).abs())
+                .collect();
+            stat.noise = (!gaps.is_empty()).then(|| round(median(&gaps)) + 0.0);
+            result.insert(name.to_owned(), stat);
+            series.insert(name, values);
+        }
+        let first_block_outside_range = series
+            .get("gpu_p50_ms")
+            .or_else(|| series.get("frame_p50_ms"))
+            .is_some_and(|values| {
+                let later: Vec<f64> = (1..values.len())
+                    .filter(|&i| blocks[i].phase == "ab.b")
+                    .map(|i| values[i])
+                    .collect();
+                blocks[0].phase == "ab.b"
+                    && !later.is_empty()
+                    && (values[0] < later.iter().copied().fold(f64::INFINITY, f64::min)
+                        || values[0] > later.iter().copied().fold(f64::NEG_INFINITY, f64::max))
+            });
+        Ok(Ab {
+            switch: switch.to_owned(),
+            a: a.to_owned(),
+            b: b.to_owned(),
+            pairs: pairs as u32,
+            block_s,
+            warmup_s,
+            first_block_outside_range,
+            result,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{App, Kind, Report};
+
+    // Expected values: exact-rational Walsh averages and a brute-force sign enumeration, run once outside this code.
+    fn check(
+        a: &[f64],
+        b: &[f64],
+        diff: f64,
+        ci: Option<[f64; 2]>,
+        conf: Option<f64>,
+        verdict: Verdict,
+    ) {
+        let pairs: Vec<(f64, f64)> = a.iter().copied().zip(b.iter().copied()).collect();
+        let p = paired(&pairs);
+        assert_eq!(
+            (p.pairs, p.diff, p.ci95, p.confidence, p.verdict),
+            (a.len(), diff, ci, conf, verdict),
+            "{b:?}"
+        );
+    }
+
+    #[test]
+    fn the_decided_vectors() {
+        use Verdict::*;
+        let z = |n: usize| vec![0.0; n];
+        let up = |n: usize| (1..=n).map(|v| v as f64).collect::<Vec<_>>();
+        check(&z(8), &up(8), 4.5, Some([2.0, 7.0]), Some(0.9609), Slower);
+        let wobble = [-0.3, 0.2, -0.1, 0.4, -0.2, 0.1, 0.3, -0.4];
+        check(
+            &z(8),
+            &wobble,
+            0.0,
+            Some([-0.3, 0.3]),
+            Some(0.9609),
+            WithinNoise,
+        );
+        check(&z(6), &up(6), 3.5, Some([1.0, 6.0]), Some(0.9688), Slower);
+        check(&z(5), &up(5), 3.0, None, None, TooFewPairs);
+        let a = [3.65, 3.70, 3.62, 3.68, 3.66, 3.71, 3.63, 3.69];
+        let b = [5.63, 5.60, 5.70, 5.58, 5.65, 5.62, 5.66, 5.61];
+        check(&a, &b, 1.96, Some([1.905, 2.03]), Some(0.9609), Slower);
+        let tiny: Vec<f64> = (1..=8).map(|v| 10.0 + v as f64 / 100.0).collect();
+        check(
+            &[10.0; 8],
+            &tiny,
+            0.045,
+            Some([0.02, 0.07]),
+            Some(0.9609),
+            Negligible,
+        );
+        let down: Vec<f64> = up(8).iter().map(|_| 0.0).collect();
+        check(
+            &up(8),
+            &down,
+            -4.5,
+            Some([-7.0, -2.0]),
+            Some(0.9609),
+            Faster,
+        );
+        let mixed = [0.5, -0.2, 0.0, 0.3, 0.9, -0.1, 0.4];
+        check(
+            &z(7),
+            &mixed,
+            0.225,
+            Some([-0.1, 0.65]),
+            Some(0.9531),
+            WithinNoise,
+        );
+        let ten = [0.3, -0.1, 0.8, 0.2, -0.5, 0.6, 0.1, 0.4, 0.7, 0.05];
+        check(
+            &z(10),
+            &ten,
+            0.25,
+            Some([-0.025, 0.55]),
+            Some(0.9512),
+            WithinNoise,
+        );
+    }
+
+    #[test]
+    fn medians_percent_and_empty_input() {
+        let a = [3.65, 3.70, 3.62, 3.68, 3.66, 3.71, 3.63, 3.69];
+        let b = [5.63, 5.60, 5.70, 5.58, 5.65, 5.62, 5.66, 5.61];
+        let p = paired(&a.iter().copied().zip(b).collect::<Vec<_>>());
+        assert_eq!(
+            (p.a, p.b, p.diff_pct, p.noise),
+            (3.67, 5.625, Some(53.406), None)
+        );
+        assert_eq!(
+            paired(&[(0.0, 1.0); 8]).diff_pct,
+            None,
+            "no percent of zero"
+        );
+        assert_eq!(paired(&[]).verdict, Verdict::TooFewPairs);
+    }
+
+    fn block(phase: &str, repeat: u32, frame: f64, cpu: Option<f64>, gpu: Option<f64>) -> Frames {
+        Frames {
+            phase: phase.into(),
+            repeat,
+            frames: 100,
+            seconds: 4.0,
+            avg_fps: 250.0,
+            low_1pct_fps: 100.0,
+            low_01pct_fps: 90.0,
+            p50_ms: frame,
+            p95_ms: frame + 1.0,
+            p99_ms: frame + 2.0,
+            p999_ms: frame + 3.0,
+            max_ms: frame + 4.0,
+            cpu_p50_ms: cpu,
+            gpu_p50_ms: gpu,
+            histogram: vec![0; crate::HISTOGRAM_EDGES_MS.len()],
+        }
+    }
+
+    // B A A B B A A B B A A B, as gpu milliseconds; frame time is gpu + 1.
+    fn twelve(first_b: f64) -> Vec<Frames> {
+        let gpu = [
+            first_b, 3.0, 3.2, 5.0, 5.2, 3.1, 3.1, 5.1, 5.4, 3.4, 3.3, 5.3,
+        ];
+        gpu.iter()
+            .enumerate()
+            .map(|(i, &g)| {
+                block(
+                    if matches!(i % 4, 0 | 3) {
+                        "ab.b"
+                    } else {
+                        "ab.a"
+                    },
+                    i as u32,
+                    g + 1.0,
+                    Some(g / 2.0),
+                    Some(g),
+                )
+            })
+            .collect()
+    }
+
+    fn from(frames: &[Frames]) -> Result<Ab, String> {
+        Ab::from_frames("gpu-culling", "off", "on", 4.0, 2.0, frames)
+    }
+
+    #[test]
+    fn noise_and_the_first_block_flag() {
+        let ab = from(&twelve(6.4)).unwrap();
+        assert!(
+            ab.first_block_outside_range,
+            "6.4 is 1 ms above the other B blocks"
+        );
+        let gpu = &ab.result["gpu_p50_ms"];
+        // Neighbours (1,2) (3,4) (5,6) (7,8) (9,10): 0.2 0.2 0 0.3 0.1.
+        assert_eq!(
+            (gpu.pairs, gpu.a, gpu.b, gpu.noise),
+            (6, 3.15, 5.25, Some(0.2))
+        );
+        assert_eq!(
+            (gpu.ci95, gpu.verdict),
+            (Some([1.8, 3.4]), Verdict::Slower),
+            "every d is positive: min and max Walsh averages"
+        );
+        assert_eq!(ab.result["cpu_p50_ms"].noise, Some(0.1));
+        assert_eq!(
+            (ab.pairs, ab.switch.as_str(), ab.a.as_str(), ab.b.as_str()),
+            (6, "gpu-culling", "off", "on")
+        );
+        assert!(!from(&twelve(5.2)).unwrap().first_block_outside_range);
+    }
+
+    #[test]
+    fn a_metric_missing_from_one_block_is_left_out() {
+        let mut frames = twelve(5.2);
+        frames[7].gpu_p50_ms = None;
+        let ab = from(&frames).unwrap();
+        assert_eq!(
+            ab.result.keys().collect::<Vec<_>>(),
+            ["cpu_p50_ms", "frame_p50_ms"]
+        );
+        let mut frames = twelve(6.4);
+        frames[0].gpu_p50_ms = None;
+        frames[0].p50_ms = 6.0;
+        assert!(
+            !from(&frames).unwrap().first_block_outside_range,
+            "frame time 6.0 is inside 6.0..6.4 of the later B blocks"
+        );
+    }
+
+    #[test]
+    fn blocks_that_do_not_pair_are_refused() {
+        assert!(from(&[]).is_err());
+        assert!(from(&twelve(5.2)[..11]).is_err(), "odd number of blocks");
+        let mut frames = twelve(5.2);
+        frames[1].phase = "ab.b".into();
+        assert!(from(&frames).is_err(), "a pair of two B blocks");
+        let mut frames = twelve(5.2);
+        frames[3].repeat = 9;
+        assert!(from(&frames).is_err(), "a gap in the numbering");
+    }
+
+    #[test]
+    fn a_report_with_ab_round_trips_and_old_ones_still_parse() {
+        let mut r = Report::new(Kind::Game, App::default());
+        let old = r.to_json();
+        assert!(!old.contains("\"ab\""));
+        assert_eq!(Report::parse(&old).unwrap().ab, None);
+        r.frames = twelve(5.2);
+        r.ab = Some(from(&r.frames).unwrap());
+        let json = r.to_json();
+        assert_eq!(Report::parse(&json).unwrap(), r);
+        assert!(
+            json.contains("\"first_block_outside_range\": false")
+                && json.contains("\"verdict\": \"slower\"")
+        );
+        assert_eq!(r.for_upload().ab, r.ab);
+        let mut few = paired(&[(1.0, 2.0); 3]);
+        few.noise = None;
+        assert!(serde_json::to_string(&few)
+            .unwrap()
+            .contains("\"ci95\":null,\"confidence\":null"));
+    }
+}
@@ -2,7 +2,7 @@
 //! come from the program that rendered (the game knows its adapter, the launcher its window).

 #[cfg(any(target_os = "macos", target_os = "linux"))]
-use horizon_telemetry::system::command_output as output;
+use horizon_system::command_output as output;
 use serde::{Deserialize, Serialize};

 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
@@ -62,6 +62,7 @@ pub struct Display {
    pub refresh_hz: Option<u32>,
 }

+#[cfg(not(target_arch = "wasm32"))]
 impl Hardware {
    pub fn detect() -> Hardware {
        let probes = probes();
@@ -69,12 +70,12 @@ impl Hardware {
            os: std::env::consts::OS.to_owned(),
            os_version: os_version(),
            arch: std::env::consts::ARCH.to_owned(),
-            cpu: horizon_telemetry::system::cpu(),
+            cpu: horizon_system::cpu(),
            cpu_threads: std::thread::available_parallelism().ok().map(|n| n.get()),
            cpu_cores: probes.cores,
            cpu_base_mhz: probes.base,
            cpu_boost_mhz: probes.boost,
-            ram_mb: horizon_telemetry::system::ram_bytes().map(|b| b >> 20),
+            ram_mb: horizon_system::ram_bytes().map(|b| b >> 20),
            storage: None,
            form: probes.form,
            gpu: None,
@@ -85,13 +86,14 @@ impl Hardware {
    /// [`Hardware::detect`] with the kind of drive `game_dir` is on.
    pub fn detect_in(game_dir: &std::path::Path) -> Hardware {
        Hardware {
-            storage: horizon_telemetry::system::storage(game_dir).map(str::to_owned),
+            storage: horizon_system::storage(game_dir).map(str::to_owned),
            ..Hardware::detect()
        }
    }
 }

-/// What the telemetry probes read (`horizon_telemetry::system`).
+#[cfg(not(target_arch = "wasm32"))]
+/// What `horizon_system::Machine` reads.
 struct Probes {
    cores: Option<u16>,
    base: Option<u32>,
@@ -99,27 +101,31 @@ struct Probes {
    form: Option<String>,
 }

+#[cfg(not(target_arch = "wasm32"))]
 fn probes() -> Probes {
-    let s = horizon_telemetry::payload::System::detect();
+    let s = horizon_system::Machine::detect();
    let some = |n: u32| (n > 0).then_some(n);
    Probes {
        cores: (s.cores > 0).then_some(s.cores),
        base: some(s.cpu_base_mhz),
        boost: some(s.cpu_boost_mhz),
-        form: (!s.form.is_empty()).then_some(s.form),
+        form: (!s.form.is_empty()).then(|| s.form.to_owned()),
    }
 }

+#[cfg(not(target_arch = "wasm32"))]
 /// `ac` or `battery`; `None` where it can't be read (and on machines without a battery on Linux).
 pub fn power_source() -> Option<&'static str> {
-    horizon_telemetry::system::power()
+    horizon_system::power()
 }

+#[cfg(not(target_arch = "wasm32"))]
 #[cfg(target_os = "macos")]
 fn os_version() -> Option<String> {
    output("sw_vers", &["-productVersion"])
 }

+#[cfg(not(target_arch = "wasm32"))]
 #[cfg(target_os = "linux")]
 fn os_version() -> Option<String> {
    let release = std::fs::read_to_string("/etc/os-release").ok()?;
@@ -132,6 +138,7 @@ fn os_version() -> Option<String> {
    })
 }

+#[cfg(not(target_arch = "wasm32"))]
 #[cfg(target_os = "linux")]
 fn key_value<'a>(text: &'a str, key: &str, sep: char) -> Option<&'a str> {
    text.lines().find_map(|line| {
@@ -140,17 +147,19 @@ fn key_value<'a>(text: &'a str, key: &str, sep: char) -> Option<&'a str> {
    })
 }

+#[cfg(not(target_arch = "wasm32"))]
 #[cfg(target_os = "windows")]
 fn os_version() -> Option<String> {
-    horizon_telemetry::system::windows_version()
+    horizon_system::windows_version()
 }

+#[cfg(not(target_arch = "wasm32"))]
 #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
 fn os_version() -> Option<String> {
    None
 }

-#[cfg(test)]
+#[cfg(all(test, not(target_arch = "wasm32")))]
 mod tests {
    use super::*;

@@ -11,11 +11,15 @@ use std::time::{SystemTime, UNIX_EPOCH};

 use serde::{Deserialize, Serialize};

+pub mod compare;
 mod hardware;

-pub use hardware::{power_source, Display, Gpu, Hardware};
+#[cfg(not(target_arch = "wasm32"))]
+pub use hardware::power_source;
+pub use hardware::{Display, Gpu, Hardware};
 /// The process probes, from the platform (`horizon-system`).
-pub use horizon_telemetry::system::{cpu_seconds, load_average, rss_bytes};
+#[cfg(not(target_arch = "wasm32"))]
+pub use horizon_system::{cpu_seconds, load_average, rss_bytes};

 pub const FORMAT: &str = "horizon-benchmark-report";
 pub const VERSION: u32 = 1;
@@ -236,6 +240,9 @@ pub struct Report {
    pub metrics: BTreeMap<String, Summary>,
    #[serde(default)]
    pub frames: Vec<Frames>,
+    /// Present in A/B runs only.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ab: Option<compare::Ab>,
    /// Local only: a name the person running it chose.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
@@ -246,6 +253,7 @@ pub struct Report {

 impl Report {
    /// An empty report for this machine, created now.
+    #[cfg(not(target_arch = "wasm32"))]
    pub fn new(kind: Kind, app: App) -> Report {
        Self::with_hardware(kind, app, Hardware::detect())
    }
@@ -263,6 +271,7 @@ impl Report {
            conditions: Conditions::default(),
            metrics: BTreeMap::new(),
            frames: Vec::new(),
+            ab: None,
            label: None,
            local: Vec::new(),
        }
@@ -61,6 +61,8 @@ pub enum ClickEvent {
    /// A local file to open with the system handler.
    /// Only allow this in locally constructed messages, never server/LAN text.
    OpenFile(String),
+    /// A `/profiler` line the client's own buttons run; never decoded from a server's text, so only they reach the local profiler.
+    Profiler(String),
 }

 /// A non-character `minecraft:object` embedded in a text component.
@@ -202,7 +204,12 @@ impl Text {
        }
    }
    pub fn styled(s: impl Into<String>, style: Style) -> Self {
-        Self::literal(s).with_style(&style)
+        let mut text = Self::literal(s).with_style(&style);
+        // `inherit` never passes an object on, but a styled span's own style carries it.
+        for span in &mut text.spans {
+            span.style.inline_object.clone_from(&style.inline_object);
+        }
+        text
    }
    pub fn colored(s: impl Into<String>, color: u32) -> Self {
        Self::styled(s, Style::color(color))
@@ -619,6 +626,9 @@ fn style_json(style: &Style) -> Vec<(String, Value)> {
                event
            }
            ClickEvent::OpenFile(path) => json!({ "action": "open_file", "path": path }),
+            ClickEvent::Profiler(command) => {
+                json!({ "action": "run_command", "command": command })
+            }
        };
        out.push(("click_event".to_owned(), event));
    }
@@ -772,6 +782,27 @@ pub fn format_translation(template: &str, args: &[Text]) -> Text {
 mod tests {
    use super::*;
    #[test]
+    fn a_styled_object_span_keeps_its_object_through_append_and_slice() {
+        let object = InlineObject::Atlas {
+            atlas: "minecraft:gui".into(),
+            sprite: "horizon:gui/mark".into(),
+            fallback: "H".into(),
+        };
+        let sprite = Text::styled(
+            "\u{fffc}",
+            Style {
+                inline_object: Some(object.clone()),
+                ..Style::color(WHITE)
+            },
+        );
+        let line = Text::colored("[", DARK_GRAY)
+            .append(sprite)
+            .append(Text::colored("] ", DARK_GRAY));
+        let line = line.slice(0, 3);
+        assert_eq!(line.spans[1].style.inline_object, Some(object));
+        assert_eq!(line.plain(), "[H]");
+    }
+    #[test]
    fn appending_builds_the_same_tree_in_linear_time() {
        // A styled text is wrapped once, so its style doesn't reach what follows; a plain one
        // takes the siblings itself; a copy taken before an append keeps its own tree.
@@ -27,6 +27,8 @@ horizon-mcp = { path = "../horizon-mcp" }
 # The server thread ahead of the workers (MinecraftServer.spin's Thread.setPriority).
 horizon-optifine = { path = "../horizon-optifine" }
 horizon-threads = { path = "../horizon-threads" }
+# The .hzperf capture format and writer (docs/perf-platform.md).
+horizon-perf-format = { path = "../horizon-perf-format" }
 # One pool of helper threads for the server tick's parallel phases (`parallel.rs`): threads made
 # once, not for every phase of every tick.
 rayon = "1.10"
@@ -130,6 +132,8 @@ workspace = true
 horizon-theme = { path = "../horizon-theme" }
 horizon-client-render = { path = "../horizon-client-render", features = ["test-support"] }
 horizon-items = { path = "../horizon-items", features = ["test-support"] }
+# Reads back the captures the server_perf tests write.
+horizon-perf = { path = "../horizon-perf" }
 # Every WGSL shader translated as wgpu's DirectX 12 backend does (gfx.rs tests).
 naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out", "msl-out", "spv-out"] }

@@ -23,6 +23,7 @@ horizon-narrator = { path = "../horizon-narrator" }
 # OptiFine-format pack files: random entity textures (hud.rs), connected textures
 # (connected.rs) and custom item texture rules (cit.rs).
 horizon-optifine = { path = "../horizon-optifine" }
+horizon-perf-format = { path = "../horizon-perf-format" }
 horizon-polytone = { path = "../horizon-polytone" }
 horizon-protocol = { path = "../horizon-protocol" }
 horizon-shader-api = { path = "../horizon-shader-api" }
@@ -74,6 +75,9 @@ wgpu = { version = "30.0.1", default-features = false, features = ["gles"] }
 audio = ["dep:cpal"]
 # Helpers horizon-client's tests build their fixtures with.
 test-support = []
+# The `scene_replay` example's allocator counts allocations (horizon-threads' `alloc-count`).
+alloc-count = ["horizon-threads/alloc-count"]
+
 # horizon-client's `horizon-extras`: asking the device for hardware ray tracing on request
 # (`gfx/ray_query.rs`, `HORIZON_RAY_TRACING=1`). Without it the device is requested as without
 # the variable.
@@ -83,6 +87,7 @@ horizon-extras = []
 workspace = true

 [dev-dependencies]
+horizon-perf = { path = "../horizon-perf" }
 # Tests: a TrueType font to load, and the design system the menus' motion curves match.
 horizon-theme = { path = "../horizon-theme" }
 horizon-items = { path = "../horizon-items", features = ["test-support"] }
@@ -6,13 +6,14 @@
 //! [--mipmaps N] [--lod-distance CHUNKS] [--render-distance CHUNKS] [--size WxH]
 //! [--section-draws flat|indirect] [--section-cull on|off] [--section-sides on|off]
 //! [--gpu-culling on|off] [--root RESOURCES] [--screenshot PNG]
-//! [--world SAVE --leaf-culling MODE] [--memory on]`
+//! [--world SAVE --leaf-culling MODE] [--memory on] [--gpu-detail on|off]`
 //! `--screenshot` saves the first view's last frame, after the timed frames.
 //! `--world` meshes the captured sections again from that save's region files
 //! (blocks, biomes and saved light; `ao`, `biomeBlendRadius` and `cutoutLeaves`
 //! from `./options.txt`) with `--leaf-culling` (default `off`), so a mesher
 //! change can be measured on the captured view. A section whose 3x3 columns are
 //! not all saved keeps its captured mesh.
+//! `--gpu-detail on` adds GPU culling's dispatch times and, on Vulkan, the world passes' counters.
 //! `--memory on` adds the renderer's largest GPU resources and, on macOS, the process's
 //! physical footprint by category (`footprint`), taken after the timed frames.
 use horizon_client_render::{
@@ -24,6 +25,7 @@ use horizon_client_render::{
    gfx::{
        PreparedTextures, Renderer, ScreenshotRequest,
        capture::{self, AtlasCheck, Scene},
+        pack_timing,
        panorama::Faces,
    },
    graphics::LeafCullingMode,
@@ -61,7 +63,10 @@ use winit::{
 // The game's allocator, so that `--memory`'s footprint is the game's: the system heap kept
 // gigabytes of the meshes `--world` frees dirty.
 #[global_allocator]
-static ALLOCATOR: horizon_threads::Allocator = horizon_threads::ALLOCATOR;
+static ALLOCATOR: horizon_threads::GameAllocator = horizon_threads::GAME_ALLOCATOR;
+
+/// Frames drawn with detail on, enough for a few timed frames of each kind.
+const DETAIL_FRAMES: usize = 60;

 #[derive(Default)]
 struct Options {
@@ -84,6 +89,7 @@ struct Options {
    world: Option<PathBuf>,
    leaf_culling: LeafCullingMode,
    memory: bool,
+    gpu_detail: bool,
 }

 fn on_off(value: &str) -> Result<bool, String> {
@@ -136,6 +142,7 @@ fn options() -> Result<Options, String> {
            "--screenshot" => o.screenshot = Some(value.into()),
            "--world" => o.world = Some(value.into()),
            "--memory" => o.memory = on_off(&value)?,
+            "--gpu-detail" => o.gpu_detail = on_off(&value)?,
            "--leaf-culling" => {
                o.leaf_culling = LeafCullingMode::ALL
                    .into_iter()
@@ -400,6 +407,23 @@ fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
                None => notes.push("screenshot: not saved".into()),
            }
        }
+        let mut detail = serde_json::Map::new();
+        if o.gpu_detail {
+            renderer.set_pass_detail(true);
+            for _ in 0..DETAIL_FRAMES {
+                draw(&mut renderer)?;
+            }
+            detail.insert(
+                "gpu_pass_parts_median_ms".into(),
+                pack_timing::parts_json(&renderer.own_pass_parts()),
+            );
+            let unit = renderer.pass_detail_support().and_then(|s| s.fragment_unit);
+            detail.insert(
+                "gpu_counters_median".into(),
+                pack_timing::counters_by_pass_json(&renderer.own_pass_counters(), unit),
+            );
+            renderer.set_pass_detail(false);
+        }
        views.push(json!({
            "yaw_offset": offset,
            "gpu_ms": summary(&gpu),
@@ -417,6 +441,9 @@ fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
            // indices hidden.
            "culled": renderer.culled_sections(),
        }));
+        if let Some(Value::Object(view)) = views.last_mut() {
+            view.extend(detail);
+        }
    }
    let section_draws = if renderer.flat_draws() {
        "flat"
@@ -424,6 +451,11 @@ fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
        "indirect"
    };
    let memory = o.memory.then(|| memory_report(&renderer));
+    let gpu_detail = o
+        .gpu_detail
+        .then(|| renderer.pass_detail_support())
+        .flatten()
+        .map(pack_timing::support_json);
    let report = json!({
        "capture": o.dir.display().to_string(),
        "adapter": renderer.info.name,
@@ -454,6 +486,7 @@ fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
        "notes": notes,
        "views": views,
        "memory": memory,
+        "gpu_detail": gpu_detail,
    });
    println!("{}", serde_json::to_string_pretty(&report)?);
    Ok(())
@@ -1442,6 +1442,8 @@ impl Audio {
        } else {
            Err("no output on a dedicated server".into())
        };
+        // Without `audio` a stream can't exist (`Infallible`), so the `Ok` arm never runs.
+        #[cfg_attr(not(feature = "audio"), allow(unreachable_code))]
        let (stream, live) = match opened {
            Ok(v) => (Some(v), true),
            Err(e) => {
@@ -465,6 +465,9 @@ pub struct Jukebox {
    /// reference exists. Keep this separate from legacy playback adoption.
    pub song_clock_present: bool,
    pub playing: bool,
+    /// A clock a save brought back, not playing yet: `setSongWithoutPlaying`
+    /// keeps the song and its clock without the sound's level event 1010.
+    pub loaded_clock: bool,
 }
 impl Jukebox {
    /// `JukeboxBlockEntity.getTheItem`: the disc it holds.
@@ -210,6 +210,7 @@ mod hdr_icc;
 mod hdr_start;
 mod hdr_stats;
 pub(crate) mod hud_coverage;
+mod in_flight;
 pub use hdr::{Calibration as HdrCalibration, Output as HdrOutput};
 mod hold;
 pub use hold::WorldHold;
@@ -247,9 +248,11 @@ mod pack_post;
 mod pack_shadow;
 mod pack_sky;
 mod pack_textures;
-pub(crate) mod pack_timing;
+pub mod pack_timing;
 pub mod pack_uniforms;
 mod pack_weather;
+mod pass_timing_api;
+use pass_timing_api::{after_culling_pass, pixel_count, world_pass_after_culling};
 mod page_runs;
 pub mod panorama;
 mod readback;
@@ -338,42 +341,6 @@ fn surface_pass<'e>(
        ..Default::default()
    })
 }
-fn world_pass_after_culling<'e>(
-    encoder: &'e mut wgpu::CommandEncoder,
-    view: &wgpu::TextureView,
-    depth: &wgpu::TextureView,
-    keep_depth: bool,
-    timing: Option<&mut pack_timing::PassTiming>,
-    name: &str,
-) -> wgpu::RenderPass<'e> {
-    encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-        label: Some("Horizon world, after culling"),
-        timestamp_writes: timing.and_then(|t| t.writes(name)),
-        color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-            view,
-            resolve_target: None,
-            depth_slice: None,
-            ops: wgpu::Operations {
-                load: wgpu::LoadOp::Load,
-                store: wgpu::StoreOp::Store,
-            },
-        })],
-        depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
-            view: depth,
-            depth_ops: Some(wgpu::Operations {
-                load: wgpu::LoadOp::Load,
-                // A shader pack reads it as depthtex0.
-                store: if keep_depth {
-                    wgpu::StoreOp::Store
-                } else {
-                    wgpu::StoreOp::Discard
-                },
-            }),
-            stencil_ops: None,
-        }),
-        ..Default::default()
-    })
-}
 /// The point a `shaders/` pack's terrain is drawn relative to: the camera with the fraction of
 /// each coordinate rounded to the nearest 1/65536 block. Read back with a probe pack of ours,
 /// Iris 1.11.7's terrain `gl_Vertex` is the block's position minus this, for cameras from 13
@@ -1474,10 +1441,14 @@ pub struct Renderer {
    pack_loading: Option<PackLoading>,
    /// The post passes of one of Horizon's own shader packs; never beside `pack_post`'s.
    native: Option<native_pack::NativePack>,
-    /// Time the shader pack's passes on the GPU (F3, or `HORIZON_SHADER_PACK_TIMING`).
+    /// Time the shader pack's passes on the GPU (F3, or a capture made with `--gpu`).
    pass_timing: bool,
+    /// Times the parts of passes too (`set_pass_detail`).
+    pass_detail: bool,
    /// Least time between timed frames (`set_pass_timing_gap`).
    pass_timing_gap: std::time::Duration,
+    /// Whether the timers keep every timed frame for `take_timed_frames`.
+    keep_timed_frames: bool,
    /// Times Horizon's own passes on the GPU, as `pass_timing` does (`own_pass_times`).
    own_timing: Option<pack_timing::PassTiming>,
    /// The entity vertices Horizon draws itself while a shader pack draws the others.
@@ -5086,8 +5057,10 @@ impl Renderer {
            pack_post: None,
            pack_loading: None,
            native: None,
-            pass_timing: pack_timing::PassTiming::logging(),
+            pass_timing: false,
+            pass_detail: false,
            pass_timing_gap: std::time::Duration::ZERO,
+            keep_timed_frames: false,
            own_timing: None,
            pack_entity_rest: Vec::new(),
            cloud_bindings,
@@ -7449,51 +7422,6 @@ impl Renderer {
                .terrain_inputs(self.pack_terrain_flat),
        )
    }
-    /// Times the shader pack's passes on the GPU while `on` (the F3 overlay is open), or always
-    /// with `HORIZON_SHADER_PACK_TIMING`.
-    pub fn set_pass_timing(&mut self, on: bool) {
-        self.pass_timing = on || pack_timing::PassTiming::logging();
-    }
-    /// Times a frame at most once per `gap` while passes are timed (the F3 overlay needs far fewer
-    /// samples than a measurement). `HORIZON_SHADER_PACK_TIMING` keeps every sample.
-    pub fn set_pass_timing_gap(&mut self, gap: std::time::Duration) {
-        self.pass_timing_gap = if pack_timing::PassTiming::logging() {
-            std::time::Duration::ZERO
-        } else {
-            gap
-        };
-    }
-    /// The running shader pack's timer, of either kind.
-    fn pass_timer<'a>(
-        pack: &'a mut Option<(i32, Option<pack_post::PackPost>)>,
-        native: &'a mut Option<native_pack::NativePack>,
-    ) -> Option<&'a mut Option<pack_timing::PassTiming>> {
-        match (pack, native) {
-            (Some((_, Some(post))), _) => Some(&mut post.timing),
-            (_, Some(native)) => Some(&mut native.timing),
-            _ => None,
-        }
-    }
-    /// Each pass of the running shader pack with its median GPU time in milliseconds, while
-    /// they are timed (`set_pass_timing`).
-    pub fn shader_pass_times(&self) -> Vec<(String, f32)> {
-        let timer = match (&self.pack_post, &self.native) {
-            (Some((_, Some(post))), _) => post.timing.as_ref(),
-            (_, Some(native)) => native.timing.as_ref(),
-            _ => None,
-        };
-        timer
-            .map(pack_timing::PassTiming::medians)
-            .unwrap_or_default()
-    }
-    /// Each of Horizon's own passes with its median GPU time in milliseconds, while they are
-    /// timed (`set_pass_timing`).
-    pub fn own_pass_times(&self) -> Vec<(String, f32)> {
-        self.own_timing
-            .as_ref()
-            .map(pack_timing::PassTiming::medians)
-            .unwrap_or_default()
-    }
    /// The macros this renderer gives shader packs: the GL extensions this device has
    /// (subgroups, when it has them), and the vendor, renderer and mipmap levels
    /// (`Macros::define_renderer`).
@@ -8102,6 +8030,8 @@ impl Renderer {
        }
        if let Some(t) = &mut self.own_timing {
            t.gap = self.pass_timing_gap;
+            t.keep_frames(self.keep_timed_frames);
+            t.set_detail(self.pass_detail);
            t.begin(&self.device, &self.queue);
        }
        if self.animated_textures {
@@ -8521,6 +8451,7 @@ impl Renderer {
                    &mut self.uploads,
                    &mut encoder,
                    &input,
+                    self.own_timing.as_mut(),
                )
            });
            // A frame whose planes leave the test's integers (the camera millions of blocks
@@ -9869,6 +9800,7 @@ impl Renderer {
        }
        if let Some(Some(t)) = Self::pass_timer(&mut self.pack_post, &mut self.native) {
            t.gap = self.pass_timing_gap;
+            t.keep_frames(self.keep_timed_frames);
        }
        let pack_reads_world = pack_post || native_post;
        laps.lap("r_uploads");
@@ -10393,7 +10325,8 @@ impl Renderer {
                    store: wgpu::StoreOp::Store,
                },
            })];
-            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            let world_pixels = pixel_count(world_depth);
+            let first_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("Horizon world"),
                timestamp_writes: self.own_timing.as_mut().and_then(|t| t.writes("World")),
                color_attachments: &attachments,
@@ -10413,9 +10346,16 @@ impl Renderer {
                }),
                ..Default::default()
            });
+            let mut pass = pack_timing::counted(
+                self.own_timing.as_mut(),
+                first_pass,
+                world_pixels,
+                "before translucent",
+            );
            pass.set_bind_group(0, &self.group, &[]);
            pack_frame(&mut pass);
            if frame.title || (sky_visible && (frame.skybox || frame.end_sky)) {
+                pass.stage(self.own_timing.as_mut(), "sky");
                if !frame.title && frame.skybox && !pack_draws_sky && !native_sky_pass {
                    match self
                        .native
@@ -10502,16 +10442,15 @@ impl Renderer {
                        .forget_lifetime();
                    pass.set_bind_group(0, &self.group, &[]);
                    pack_frame(&mut pass);
-                    pass
+                    pack_timing::CountedPass::plain(pass)
                };
            // The occlusion test's pipeline draws into the world's colour alone.
            let plain_pass = |encoder: &mut wgpu::CommandEncoder| {
-                let mut pass =
-                    world_pass_after_culling(encoder, world_view, world_depth, true, None, "")
-                        .forget_lifetime();
+                let mut pass = after_culling_pass(encoder, world_view, world_depth, true, None)
+                    .forget_lifetime();
                pass.set_bind_group(0, &self.group, &[]);
                pack_frame(&mut pass);
-                pass
+                pack_timing::CountedPass::plain(pass)
            };
            if let Some(surface) = &surface {
                drop(pass);
@@ -10565,6 +10504,7 @@ impl Renderer {
                        keep_depth,
                        self.own_timing.as_mut(),
                        "World after visibility buffer",
+                        world_pixels,
                    );
                    pass.set_bind_group(0, &self.group, &[]);
                    pack_frame(&mut pass);
@@ -10597,6 +10537,7 @@ impl Renderer {
                            flat.draw(pass, &flat.calls[calls.clone()], vertices);
                        }
                    };
+                    pass.stage(self.own_timing.as_mut(), "solid terrain");
                    match cull {
                        // As below: phase 1, the test, then phase 2's draws
                        // that the test saw, copied after it.
@@ -10606,6 +10547,8 @@ impl Renderer {
                                drop(pass);
                                pass = plain_pass(&mut encoder);
                            }
+                            pass.split(self.own_timing.as_mut(), "occlusion boxes");
+                            pass.stage(self.own_timing.as_mut(), "occlusion boxes");
                            cull.test(&mut pass);
                            drop(pass);
                            cull.test_pass(&mut encoder, self.own_timing.as_mut());
@@ -10619,10 +10562,12 @@ impl Renderer {
                                    keep_depth,
                                    self.own_timing.as_mut(),
                                    "World after culling",
+                                    world_pixels,
                                ),
                            };
                            pass.set_bind_group(0, &self.group, &[]);
                            pack_frame(&mut pass);
+                            pass.stage(self.own_timing.as_mut(), "solid terrain phase 2");
                            for (pipeline, _, calls) in passes {
                                pass.set_pipeline(pipeline);
                                flat.draw_phase2(&mut pass, calls.clone(), vertices);
@@ -10660,6 +10605,7 @@ impl Renderer {
                    let pulled = material.is_none() && self.flat.is_some();
                    pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
                    pass.set_vertex_buffer(1, self.instances.slice(..));
+                    pass.stage(self.own_timing.as_mut(), "solid terrain");
                    if let Some(group) = warp_group {
                        pass.set_bind_group(2, group, &[]);
                    }
@@ -10684,6 +10630,8 @@ impl Renderer {
                                drop(pass);
                                pass = plain_pass(&mut encoder);
                            }
+                            pass.split(self.own_timing.as_mut(), "occlusion boxes");
+                            pass.stage(self.own_timing.as_mut(), "occlusion boxes");
                            cull.test(&mut pass);
                            drop(pass);
                            cull.test_pass(&mut encoder, self.own_timing.as_mut());
@@ -10696,6 +10644,7 @@ impl Renderer {
                                    keep_depth,
                                    self.own_timing.as_mut(),
                                    "World after culling",
+                                    world_pixels,
                                ),
                            };
                            pass.set_bind_group(0, &self.group, &[]);
@@ -10705,6 +10654,7 @@ impl Renderer {
                                wgpu::IndexFormat::Uint32,
                            );
                            pass.set_vertex_buffer(1, self.instances.slice(..));
+                            pass.stage(self.own_timing.as_mut(), "solid terrain phase 2");
                            for (pipeline, _, draws) in passes {
                                pass.set_pipeline(pipeline);
                                self.draw_sections_from(
@@ -10752,6 +10702,8 @@ impl Renderer {
                                    drop(pass);
                                    pass = plain_pass(&mut encoder);
                                }
+                                pass.split(self.own_timing.as_mut(), "occlusion boxes");
+                                pass.stage(self.own_timing.as_mut(), "occlusion boxes");
                                gpu.test(&mut pass);
                                drop(pass);
                                gpu.compact(&mut encoder, self.own_timing.as_mut());
@@ -10764,6 +10716,7 @@ impl Renderer {
                                        keep_depth,
                                        self.own_timing.as_mut(),
                                        "World after culling",
+                                        world_pixels,
                                    ),
                                };
                                pass.set_bind_group(0, &self.group, &[]);
@@ -10772,6 +10725,7 @@ impl Renderer {
                                    self.indices.slice(..),
                                    wgpu::IndexFormat::Uint32,
                                );
+                                pass.stage(self.own_timing.as_mut(), "solid terrain phase 2");
                                for (pipeline, draws, _) in passes {
                                    pass.set_pipeline(pipeline);
                                    gpu.draw(&mut pass, &self.arena, page_group, 1);
@@ -10798,6 +10752,7 @@ impl Renderer {
                && let Some(d) = &n.displacement
                && let Some(pipeline) = n.material.as_ref().and_then(|m| m.displaced.as_ref())
            {
+                pass.stage(self.own_timing.as_mut(), "displacement");
                pass.set_bind_group(0, &self.group, &[]);
                pack_frame(&mut pass);
                d.draw(&mut pass, &d.view, pipeline);
@@ -10814,6 +10769,7 @@ impl Renderer {
            let hdr_entity_mark =
                warped.map_or(&self.hdr_entity_mark_pipeline, |w| &w.hdr_entity_mark);
            if static_entity_quads > 0 {
+                pass.stage(self.own_timing.as_mut(), "static block entities");
                pass.set_pipeline(
                    warped.map_or(&self.static_entity_pipeline, |w| &w.static_entities),
                );
@@ -10839,6 +10795,7 @@ impl Renderer {
            }
            pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
            if entity_quads > 0 {
+                pass.stage(self.own_timing.as_mut(), "entities");
                pass.set_pipeline(warped.map_or(&self.entity_pipeline, |w| &w.entities));
                pass.set_bind_group(0, &self.entity_group, &[]);
                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -10850,6 +10807,7 @@ impl Renderer {
                pass.set_bind_group(0, &self.group, &[]);
            }
            if text_quads > 0 && !oit_on {
+                pass.stage(self.own_timing.as_mut(), "entity text");
                pass.set_pipeline(warped.map_or(&self.text_polygon_offset_pipeline, |w| &w.text));
                self.bind_world_text(&mut pass, warped.is_none(), false);
                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -10859,6 +10817,7 @@ impl Renderer {
            // FeatureRenderDispatcher.PreparedFrame.executeTranslucent: the shadows
            // come before the translucent items, which then cover them (#7026).
            if shadow_quads > 0 && !oit_on {
+                pass.stage(self.own_timing.as_mut(), "shadows");
                pass.set_pipeline(warped.map_or(&self.shadow_blob_pipeline, |w| &w.entity_shadows));
                pass.set_bind_group(0, &self.entity_group, &[]);
                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -10874,6 +10833,7 @@ impl Renderer {
                pass.set_bind_group(0, &self.group, &[]);
            }
            if translucent_item_quads > 0 && !oit_on {
+                pass.stage(self.own_timing.as_mut(), "translucent items");
                pass.set_pipeline(
                    warped.map_or(&self.translucent_item_pipeline, |w| &w.translucent_items),
                );
@@ -10909,6 +10869,7 @@ impl Renderer {
            .enumerate()
            {
                if count > 0 {
+                    pass.stage(self.own_timing.as_mut(), "terrain models");
                    pass.set_pipeline(&self.terrain_model_pipelines[i]);
                    pass.set_bind_group(
                        0,
@@ -10929,6 +10890,7 @@ impl Renderer {
            // translucent material, before terrain transparency. This material
            // always writes depth and never joins the improved-transparency queues.
            if fluid_quads > 0 {
+                pass.stage(self.own_timing.as_mut(), "fluid block entities");
                pass.set_pipeline(&self.fluid_pipeline);
                pass.set_bind_group(0, &self.fluid_group, &[]);
                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -10941,6 +10903,7 @@ impl Renderer {
            }
            // Cracks multiply the existing light; scalar OIT coverage cannot carry that factor.
            if crumbling_quads > 0 && (!oit_on || hdr_gain) {
+                pass.stage(self.own_timing.as_mut(), "block breaking");
                pass.set_pipeline(&self.crumbling_pipeline);
                pass.set_bind_group(0, &self.entity_group, &[]);
                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -10954,6 +10917,7 @@ impl Renderer {
            // BoatRenderer's water patch (RenderTypes.waterMask): depth only,
            // before translucent terrain, so no water shows inside the boat.
            if water_mask_quads > 0 && !oit_on {
+                pass.stage(self.own_timing.as_mut(), "boat water mask");
                pass.set_pipeline(&self.water_mask_pipeline);
                pass.set_bind_group(0, &self.entity_group, &[]);
                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -10966,6 +10930,7 @@ impl Renderer {
                pass.set_bind_group(0, &self.group, &[]);
            }
            if !frame.lightning.bolts.is_empty() && !oit_on {
+                pass.stage(self.own_timing.as_mut(), "lightning");
                pass.set_pipeline(&self.lightning_pipeline);
                pass.set_bind_group(0, &self.entity_group, &[]);
                self.lightning.draw(&mut pass, &frame.lightning);
@@ -10976,6 +10941,7 @@ impl Renderer {
                pass.set_bind_group(0, &self.group, &[]);
            }
            if swirl_quads > 0 && !oit_on {
+                pass.stage(self.own_timing.as_mut(), "energy swirl");
                pass.set_pipeline(&self.energy_swirl_pipeline);
                pass.set_bind_group(0, &self.entity_group, &[]);
                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -10992,6 +10958,7 @@ impl Renderer {
                pass.set_bind_group(0, &self.group, &[]);
            }
            if additive_quads > 0 && !oit_on {
+                pass.stage(self.own_timing.as_mut(), "additive entities");
                pass.set_bind_group(0, &self.entity_group, &[]);
                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
                let mut first = 0;
@@ -11017,20 +10984,24 @@ impl Renderer {
                pass.set_bind_group(0, &self.group, &[]);
            }
            if outline_edges > 0 && !frame.outline_after_terrain && !pack_draws_outline {
+                pass.stage(self.own_timing.as_mut(), "block outline");
                self.draw_outline(&mut pass, outline_edges as u32, frame.outline_high_contrast);
            }
            // DrawableGizmoPrimitives' opaque group writes depth, the translucent one does not.
            if debug_opaque > 0 {
+                pass.stage(self.own_timing.as_mut(), "debug lines");
                pass.set_pipeline(&self.debug_lines_opaque);
                pass.set_vertex_buffer(0, self.debug_line_buffer.slice(..));
                pass.draw(0..4, 0..debug_opaque);
            }
            if debug_depth > debug_opaque {
+                pass.stage(self.own_timing.as_mut(), "debug lines");
                pass.set_pipeline(&self.debug_lines);
                pass.set_vertex_buffer(0, self.debug_line_buffer.slice(..));
                pass.draw(0..4, debug_opaque..debug_depth);
            }
            if debug_top > 0 {
+                pass.stage(self.own_timing.as_mut(), "debug lines");
                pass.set_pipeline(&self.debug_lines_on_top);
                pass.set_vertex_buffer(0, self.debug_line_buffer.slice(..));
                pass.draw(0..4, debug_depth..debug_depth + debug_top);
@@ -11058,6 +11029,7 @@ impl Renderer {
                    keep_depth,
                    self.own_timing.as_mut(),
                    "World after copy",
+                    world_pixels,
                );
                pass.set_bind_group(0, &self.group, &[]);
                pack_frame(&mut pass);
@@ -11231,9 +11203,11 @@ impl Renderer {
                        true,
                        self.own_timing.as_mut(),
                        "World after OIT",
+                        world_pixels,
                    );
                    pass.set_bind_group(0, &self.group, &[]);
                    pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
+                    pass.stage(self.own_timing.as_mut(), "OIT marks");
                    if cloud_quads > 0 && !pack_draws_clouds {
                        self.mark_clouds(&mut pass, cloud_quads);
                    }
@@ -11266,6 +11240,8 @@ impl Renderer {
                    self.mark_translucent_terrain(&mut pass, flat, solid_draws, translucent_draws);
                }
                Some(flat) => {
+                    pass.split(self.own_timing.as_mut(), "translucent terrain");
+                    pass.stage(self.own_timing.as_mut(), "translucent terrain");
                    pass.set_pipeline(pack_flat.map_or(&flat.translucent, |p| &p.1));
                    flat.draw(
                        &mut pass,
@@ -11280,8 +11256,11 @@ impl Renderer {
                        solid_draws,
                        translucent_draws,
                    );
+                    pass.split(self.own_timing.as_mut(), "after translucent");
                }
                None => {
+                    pass.split(self.own_timing.as_mut(), "translucent terrain");
+                    pass.stage(self.own_timing.as_mut(), "translucent terrain");
                    pass.set_pipeline(translucent_pipeline);
                    if let Some(group) = warp_group {
                        pass.set_bind_group(2, group, &[]);
@@ -11304,6 +11283,7 @@ impl Renderer {
                            translucent_draws,
                        );
                    }
+                    pass.split(self.own_timing.as_mut(), "after translucent");
                }
            }
            // LevelRenderer.executeTranslucentAfterTerrain: vanilla's
@@ -11311,6 +11291,7 @@ impl Renderer {
            // the quads write depth, so before it they would hide the glass
            // or water behind them.
            if translucent_particle_quads > 0 && !oit_on {
+                pass.stage(self.own_timing.as_mut(), "translucent particles");
                pass.set_pipeline(warped.map_or(&self.entity_pipeline, |w| &w.entities));
                if let Some(group) = warp_group {
                    pass.set_bind_group(2, group, &[]);
@@ -11339,6 +11320,7 @@ impl Renderer {
            // particles (also after the OIT composite) and before the hand.
            // Its own geometry is independent of block-entity lifetime.
            if world_text_quads + world_text_offset_quads > 0 {
+                pass.stage(self.own_timing.as_mut(), "world text");
                pass.set_bind_group(0, &self.entity_group, &[]);
                pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -11361,9 +11343,11 @@ impl Renderer {
            // LevelRenderer.executeClassicTransparency: translucent targets'
            // outlines follow terrain, so its blending cannot wash them out.
            if outline_edges > 0 && frame.outline_after_terrain && !pack_draws_outline {
+                pass.stage(self.own_timing.as_mut(), "block outline");
                self.draw_outline(&mut pass, outline_edges as u32, frame.outline_high_contrast);
            }
            if translucent_crumbling_quads > 0 && (!oit_on || hdr_gain) {
+                pass.stage(self.own_timing.as_mut(), "block breaking");
                pass.set_pipeline(&self.crumbling_pipeline);
                pass.set_bind_group(0, &self.entity_group, &[]);
                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -11374,6 +11358,7 @@ impl Renderer {
                );
            }
            if cloud_quads > 0 && !pack_draws_clouds && !oit_on {
+                pass.stage(self.own_timing.as_mut(), "clouds");
                pass.set_pipeline(&self.cloud_pipeline);
                pass.set_bind_group(0, &self.entity_group, &[]);
                pass.set_bind_group(1, &self.cloud_group, &[]);
@@ -11385,6 +11370,7 @@ impl Renderer {
            // terrain and clouds, so the water behind the rain is drawn first.
            pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
            if !pack_draws_weather && !oit_on {
+                pass.stage(self.own_timing.as_mut(), "weather");
                let native_weather = self
                    .native
                    .as_ref()
@@ -11396,6 +11382,7 @@ impl Renderer {
            }
            // LevelRenderer: the world border after translucent terrain and weather.
            if let Some(b) = frame.border.as_ref().filter(|_| !frame.title && !oit_on) {
+                pass.stage(self.own_timing.as_mut(), "world border");
                pass.set_pipeline(&self.border_pipeline);
                pass.set_bind_group(0, &self.border_group, &[]);
                pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
@@ -11408,6 +11395,7 @@ impl Renderer {
            }
            // LevelRenderer.executeSeeThrough, after the rest of the world.
            if see_through_quads > 0 {
+                pass.stage(self.own_timing.as_mut(), "see-through");
                pass.set_pipeline(&self.see_through_pipeline);
                self.bind_world_text(&mut pass, true, true);
                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -11420,9 +11408,11 @@ impl Renderer {
            // Native mods' primitives: after the entities and the rest of the world, into its
            // targets (its resolution, reversed depth and TAA), before the hand.
            if world_primitives {
+                pass.stage(self.own_timing.as_mut(), "mod primitives");
                self.world_primitives.draw(&mut pass);
            }
            if hand_in_world {
+                pass.stage(self.own_timing.as_mut(), "hand");
                pass.set_pipeline(&self.depth_reset);
                pass.set_bind_group(0, &self.group, &[]);
                pass.draw(0..3, 0..1);
@@ -12362,130 +12352,6 @@ pub(crate) fn copy_frame(
    );
    buffer
 }
-impl Renderer {
-    /// The frame's readbacks to start right after its submission (on the submit thread when
-    /// the frame goes there): occlusion culling's results (`cull`) and GPU culling's
-    /// statistics. GPU frames leave occlusion culling off, so a frame has one at most.
-    fn after_submit(&mut self) -> Option<submit::AfterSubmit> {
-        let cull = self.cull.as_mut().and_then(|c| c.submitted());
-        let gpu = self.gpu_culling.as_mut().and_then(|g| g.submitted());
-        match (cull, gpu) {
-            (Some(c), Some(g)) => Some(Box::new(move || {
-                c();
-                g();
-            })),
-            (Some(c), None) => Some(Box::new(c)),
-            (None, Some(g)) => Some(Box::new(g)),
-            (None, None) => None,
-        }
-    }
-    /// Frame `frame`'s statistics shown, unless a newer frame's are: a CPU frame's as it is
-    /// drawn, a GPU frame's when its counts come back (`GpuCulling::collect`).
-    fn show_stats(&mut self, frame: u64, [sections, draws, calls]: [usize; 3]) {
-        if frame > self.stats_frame {
-            self.stats_frame = frame;
-            (
-                self.drawn_sections,
-                self.section_draws,
-                self.section_draw_calls,
-            ) = (sections, draws, calls);
-        }
-    }
-    /// Frames between the last one drawn and the one whose statistics are shown: 0 after a
-    /// CPU frame, one to three in GPU frames, while their counts are on their way back.
-    pub fn stats_lag(&self) -> u64 {
-        self.frame_serial - self.stats_frame
-    }
-    /// Take in the frame the submit thread submitted: start its readbacks and, offscreen,
-    /// keep at most two frames ahead of the GPU, as a frame submitted in place does.
-    fn land_frame(&mut self) {
-        let Some(offscreen) = self.deferred.take() else {
-            return;
-        };
-        let submission = self.queue.landed();
-        if let Some(timer) = &mut self.gpu_timer {
-            timer.submitted(&self.queue);
-            timer.collect(&self.device, &mut self.gpu_times);
-        }
-        if let Some(Some(timer)) = Self::pass_timer(&mut self.pack_post, &mut self.native) {
-            timer.submitted(&self.queue);
-        }
-        if offscreen && let Some(submission) = submission {
-            self.in_flight.push_back(submission);
-            if !self.paced_elsewhere {
-                self.wait_frames();
-            }
-        }
-    }
-    /// No swapchain paces offscreen frames: keep two on the GPU at most.
-    pub fn wait_in_flight(&mut self) {
-        self.land_frame();
-        self.wait_frames();
-    }
-    /// The frame on the submit thread submitted: a surface reconfigure waits for the
-    /// device and breaks if a frame is submitted while it waits, and the compositor
-    /// copies views after them. (The end of a frame already lands the frames of the
-    /// turn before; this is the turn's own.)
-    pub fn wait_submissions(&mut self) {
-        self.queue.wait();
-    }
-    fn wait_frames(&mut self) {
-        while self.in_flight.len() > 2 {
-            let index = self.in_flight.pop_front();
-            let _ = self.device.poll(wgpu::PollType::Wait {
-                submission_index: index,
-                timeout: Some(std::time::Duration::from_secs(5)),
-            });
-        }
-    }
-    /// Take a screenshot request: queue the frame's copy, or report why the
-    /// frame cannot be read back.
-    fn take_readback(
-        &mut self,
-        request: ScreenshotRequest,
-        encoder: &mut wgpu::CommandEncoder,
-        texture: &wgpu::Texture,
-    ) -> Option<(ScreenshotRequest, wgpu::Buffer)> {
-        // The copy and PNG writer both assume 8-bit pixels; a float surface would make
-        // the row stride too small for the copy and abort in validation.
-        if self.config.format.block_copy_size(None) == Some(4) {
-            let size = [self.config.width, self.config.height];
-            let format = self.config.format.remove_srgb_suffix();
-            // The layered float frame maps the world to SDR, then adds the HUD as drawn.
-            // Other 16-bit frames keep their clipped 8-bit copy.
-            let copy = self
-                .hdr
-                .as_mut()
-                .and_then(|hdr| {
-                    hdr.sdr_screenshot(&self.device, encoder, format, request.size.is_some())
-                })
-                .or_else(|| {
-                    (texture.format() != format && texture.format() == self.output.frame.format)
-                        .then(|| {
-                            self.readback
-                                .unorm_copy(&self.device, encoder, texture, format)
-                        })
-                });
-            let texture = copy.as_ref().unwrap_or(texture);
-            Some((request, copy_frame(&self.device, encoder, texture, size)))
-        } else {
-            let error = format!(
-                "screenshots need a 32-bit surface format, not {:?}",
-                self.config.format
-            );
-            if request.background {
-                self.saved_screenshots.push(screenshot_save::Saved {
-                    path: request.path,
-                    result: Err(error),
-                    hdr: None,
-                });
-            } else {
-                self.screenshot_result = Some(Err(error));
-            }
-            None
-        }
-    }
-}
 /// `screenshots/2026-10-28_12.00.00.png` -> `screenshots/2026-10-28_12.00.00-hdr.png`.
 fn hdr_screenshot_path(path: &std::path::Path) -> PathBuf {
    let stem = path.file_stem().unwrap_or_default().to_string_lossy();
@@ -12591,56 +12457,8 @@ fn block_entities_within_reach<'a>(
        })
        .flatten()
 }
-/// Camera-relative clip planes (`Frustum`).
-#[derive(Clone, Copy, Debug)]
-pub struct Frustum {
-    planes: [Vec4; 6],
-}
-impl Frustum {
-    /// Whether the camera-relative box `min..max` is at least partly inside.
-    pub fn intersects(&self, min: Vec3, max: Vec3) -> bool {
-        !self.planes.iter().any(|p| {
-            let sign = p.truncate().cmpge(Vec3::ZERO);
-            let v = Vec3::select(sign, max, min);
-            p.truncate().dot(v) + p.w < 0.0
-        })
-    }
-    /// Whether a camera-relative sphere is at least partly inside. Frustum
-    /// planes are normalized, so each test needs only one dot product and a
-    /// radius comparison.
-    pub fn intersects_sphere(&self, center: Vec3, radius: f32) -> bool {
-        if !center.is_finite() || !radius.is_finite() || radius < 0.0 {
-            return true;
-        }
-        !self
-            .planes
-            .iter()
-            .any(|plane| plane.truncate().dot(center) + plane.w < -radius)
-    }
-    /// Depth clip planes alone: X/Y projection jitter cannot change this test.
-    /// Retaining side-of-screen geometry makes this safe before TAA selects a phase.
-    pub fn intersects_depth(&self, min: Vec3, max: Vec3) -> bool {
-        if !min.is_finite() || !max.is_finite() || !min.cmple(max).all() {
-            return true;
-        }
-        !self.planes[4..].iter().any(|p| {
-            let sign = p.truncate().cmpge(Vec3::ZERO);
-            let v = Vec3::select(sign, max, min);
-            p.truncate().dot(v) + p.w < 0.0
-        })
-    }
-    /// Whether the camera-relative box `min..max` is entirely inside. Then
-    /// `intersects` accepts every box within it: each plane's distance only
-    /// grows from this box's nearest corner to the inner box's farthest, and
-    /// rounding keeps that order.
-    pub fn contains(&self, min: Vec3, max: Vec3) -> bool {
-        self.planes.iter().all(|p| {
-            let sign = p.truncate().cmpge(Vec3::ZERO);
-            let v = Vec3::select(sign, min, max);
-            p.truncate().dot(v) + p.w >= 0.0
-        })
-    }
-}
+mod view_frustum;
+pub use view_frustum::Frustum;
 /// Vanilla's `Projection`: reversed depth (near maps to 1, far to 0, tests
 /// are GREATER_THAN_OR_EQUAL), which keeps far faces a hair apart, like
 /// fire_side's 0.01 pixel in front of its block, from z-fighting.
@@ -71,7 +71,7 @@ use super::{
    Frustum, SectionKey,
    arena::{Arena, try_create},
    occlusion::Reach,
-    pack_timing::PassTiming,
+    pack_timing::{PassTiming, compute_parts},
    resident,
    submit::Queue,
    upload::Uploads,
@@ -374,6 +374,21 @@ pub(super) enum Prepared {
    OutOfMemory,
 }

+/// A part of a compute pass: `pipeline` over `[x, y]` workgroups, nothing when `x` is 0.
+fn step<'a>(
+    group: &'a wgpu::BindGroup,
+    pipeline: &'a wgpu::ComputePipeline,
+    [x, y]: [u32; 2],
+) -> impl FnMut(&mut wgpu::ComputePass<'_>) + 'a {
+    move |pass| {
+        if x > 0 {
+            pass.set_bind_group(0, group, &[]);
+            pass.set_pipeline(pipeline);
+            pass.dispatch_workgroups(x, y, 1);
+        }
+    }
+}
+
 /// The frame's `tables` before the regions, into `words`, and the parameters
 /// the frustum test and facing read with them; `None` when the CPU draws the
 /// frame (`Prepared::Cpu`): a sum of a plane's terms could leave i32
@@ -1190,12 +1205,13 @@ impl GpuCulling {
        uploads: &mut Uploads,
        encoder: &mut wgpu::CommandEncoder,
        input: &FrameInputs<'_>,
+        timing: Option<&mut PassTiming>,
    ) -> Prepared {
        self.pages.clear();
        self.ids = 0;
        self.n_updates = 0;
        self.occluding = false;
-        self.prepare_buffers(device, queue, uploads, encoder, input)
+        self.prepare_buffers(device, queue, uploads, encoder, input, timing)
            .unwrap_or(Prepared::OutOfMemory)
    }

@@ -1206,6 +1222,7 @@ impl GpuCulling {
        uploads: &mut Uploads,
        encoder: &mut wgpu::CommandEncoder,
        input: &FrameInputs<'_>,
+        mut timing: Option<&mut PassTiming>,
    ) -> Option<Prepared> {
        // Every buffer grows before anything is written. One made anew drops
        // the bind group at once, and a new section table needs every record:
@@ -1287,6 +1304,9 @@ impl GpuCulling {
                occl = OCCLUDE | if probe { PROBE } else { 0 };
            }
        }
+        let uploading = timing
+            .as_mut()
+            .and_then(|t| t.encoder_begin(encoder, "GPU culling uploads"));
        if self.records.all_dirty {
            // The whole table, after it grew or more records changed than
            // updates take (GPU culling switched on in a loaded world, a
@@ -1352,6 +1372,9 @@ impl GpuCulling {
        // are written before they are read.
        let cleared = if self.occluding { tests_at } else { phase1_end };
        encoder.clear_buffer(&self.counts.buffer, 0, Some(cleared * 4));
+        if let Some(t) = timing {
+            t.encoder_end(encoder, uploading);
+        }
        if self.group.is_none() {
            self.group = Some(self.bind(device));
            if let Some(test) = &mut self.test {
@@ -1403,23 +1426,24 @@ impl GpuCulling {
        let Some(group) = self.group.as_ref().filter(|_| self.ids > 0) else {
            return;
        };
-        let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
-            label: Some("GPU culling"),
-            timestamp_writes: timing.and_then(|t| t.compute_writes("GPU culling")),
-        });
-        pass.set_bind_group(0, group, &[]);
        let [apply, cull, scan, scatter] = &self.pipelines;
-        if self.n_updates > 0 {
-            pass.set_pipeline(apply);
-            pass.dispatch_workgroups(self.n_updates.div_ceil(WORKGROUP), 1, 1);
-        }
        let blocks = self.ids.div_ceil(WORKGROUP);
-        pass.set_pipeline(cull);
-        pass.dispatch_workgroups(blocks.min(ROW), blocks.div_ceil(ROW), 1);
-        pass.set_pipeline(scan);
-        pass.dispatch_workgroups(self.pass_pages, 1, 1);
-        pass.set_pipeline(scatter);
-        pass.dispatch_workgroups(blocks.min(ROW), blocks.div_ceil(ROW), 1);
+        let rows = [blocks.min(ROW), blocks.div_ceil(ROW)];
+        let updates = [self.n_updates.div_ceil(WORKGROUP), 1];
+        let (mut apply, mut cull) = (step(group, apply, updates), step(group, cull, rows));
+        let pages = [self.pass_pages, 1];
+        let (mut scan, mut scatter) = (step(group, scan, pages), step(group, scatter, rows));
+        compute_parts(
+            encoder,
+            timing,
+            "GPU culling",
+            &mut [
+                ("apply", &mut apply),
+                ("cull", &mut cull),
+                ("scan", &mut scan),
+                ("scatter", &mut scatter),
+            ],
+        );
    }

    /// The kept sections' solid draws, a count draw per page, with the quad
@@ -1494,19 +1518,22 @@ impl GpuCulling {
        if !self.occluding {
            return;
        }
-        let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
-            label: Some("GPU culling phase 2"),
-            timestamp_writes: timing.and_then(|t| t.compute_writes("GPU culling phase 2")),
-        });
-        pass.set_bind_group(0, group, &[]);
        let [count2, scan2, scatter2] = &test.phase2;
        let blocks = self.ids.div_ceil(WORKGROUP);
-        pass.set_pipeline(count2);
-        pass.dispatch_workgroups(blocks.min(ROW), blocks.div_ceil(ROW), 1);
-        pass.set_pipeline(scan2);
-        pass.dispatch_workgroups(self.pass_pages, 1, 1);
-        pass.set_pipeline(scatter2);
-        pass.dispatch_workgroups(blocks.min(ROW), blocks.div_ceil(ROW), 1);
+        let rows = [blocks.min(ROW), blocks.div_ceil(ROW)];
+        let pages = [self.pass_pages, 1];
+        let (mut count, mut scatter) = (step(group, count2, rows), step(group, scatter2, rows));
+        let mut scan = step(group, scan2, pages);
+        compute_parts(
+            encoder,
+            timing,
+            "GPU culling phase 2",
+            &mut [
+                ("count2", &mut count),
+                ("scan2", &mut scan),
+                ("scatter2", &mut scatter),
+            ],
+        );
    }

    /// After the frame's world passes (phase 2's counts too), in the same
@@ -2720,6 +2747,11 @@ mod tests {
        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
        let needed =
            wgpu::Features::MULTI_DRAW_INDIRECT_COUNT | wgpu::Features::INDIRECT_FIRST_INSTANCE;
+        let timing = adapter.features()
+            & (wgpu::Features::TIMESTAMP_QUERY
+                | wgpu::Features::TIMESTAMP_QUERY_INSIDE_PASSES
+                | wgpu::Features::TIMESTAMP_QUERY_INSIDE_ENCODERS
+                | wgpu::Features::SHADER_EARLY_DEPTH_TEST);
        if !adapter.features().contains(needed)
            || super::super::flat::is_broken_intel_vulkan(&adapter.get_info())
        {
@@ -2727,7 +2759,7 @@ mod tests {
        }
        eprintln!("GPU culling on {} ({name})", adapter.get_info().name);
        pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
-            required_features: needed,
+            required_features: needed | timing,
            ..Default::default()
        }))
        .ok()
@@ -2834,6 +2866,11 @@ mod tests {
        // was drawn.
        let (mut eyed, mut hidden, mut several) = (0, 0, 0);
        let (mut edge, mut edge_drawn) = (None, false);
+        // Timed in detail as the renderer does: the commands, and so the draws, stay the same.
+        let mut timing = PassTiming::new(device, queue);
+        if let Some(t) = &mut timing {
+            t.set_detail(true);
+        }
        for case in 0..25 {
            let radius = [2, 5, 9][case % 3];
            let at_edge = case == 24;
@@ -2981,6 +3018,9 @@ mod tests {
                edge = Some(id);
            }
            let whole = gpu.records.all_dirty;
+            if let Some(t) = &mut timing {
+                t.begin(device, queue);
+            }
            let mut encoder = device.create_command_encoder(&Default::default());
            let input = FrameInputs {
                camera,
@@ -3000,11 +3040,18 @@ mod tests {
                    camera: camera + DVec3::Y * 2.0e7,
                    ..input
                };
-                let prepared = gpu.prepare(device, queue, &mut uploads, &mut encoder, &up);
+                let prepared = gpu.prepare(device, queue, &mut uploads, &mut encoder, &up, None);
                assert_eq!(prepared, Prepared::Cpu, "case 7");
                assert!(gpu.records.all_dirty || !gpu.records.dirty.is_empty());
            }
-            let prepared = gpu.prepare(device, queue, &mut uploads, &mut encoder, &input);
+            let prepared = gpu.prepare(
+                device,
+                queue,
+                &mut uploads,
+                &mut encoder,
+                &input,
+                timing.as_mut(),
+            );
            assert_eq!(prepared, Prepared::Gpu, "case {case}");
            match case {
                4 => assert!(
@@ -3060,12 +3107,15 @@ mod tests {
                    culled += 1;
                }
            }
-            gpu.dispatch(&mut encoder, None);
+            gpu.dispatch(&mut encoder, timing.as_mut());
            // Its statistics come back with a CPU part of the case's own.
            let cpu = [case * 7, case * 3, case];
            gpu.copy_stats(&mut encoder, case as u64, cpu);
            uploads.finish(&encoder);
            queue.submit([encoder.finish()]);
+            if let Some(t) = &mut timing {
+                t.submitted(queue);
+            }
            gpu.submitted().expect("a readback free")();
            let pages = u64::from(gpu.pass_pages);
            let counts = read(device, queue, &gpu.counts.buffer, (STATS + pages) * 4);
@@ -3124,6 +3174,18 @@ mod tests {
            "of {eyed} from an eye, {hidden} with a bucket left out, {several} in three runs"
        );
        assert!(edge_drawn, "the bucket at the section's edge");
+        if let Some(t) = &timing {
+            let parts = t.part_medians();
+            let names = |pass: &str| {
+                let parts = parts.iter().find(|p| p.0 == pass)?;
+                Some(parts.1.iter().map(|p| p.0.as_str()).collect::<Vec<_>>())
+            };
+            assert_eq!(
+                names("GPU culling"),
+                Some(vec!["apply", "cull", "scan", "scatter"]),
+                "{parts:?}"
+            );
+        }
        assert!(culled > 2_000, "{culled} within the distance left out");
        assert!(faded * 10 > compared, "{faded} fading of {compared} drawn");
        assert!(
@@ -3136,6 +3198,113 @@ mod tests {
        );
    }

+    /// Detail times both phases and the uploads and leaves counts and draws as an untimed frame's.
+    #[test]
+    fn detail_times_both_phases_and_leaves_the_draws_alone() {
+        on_each_device(|device, queue| {
+            let mut rng = Rng(0x1F83_D9AB_FB41_BD6B);
+            let (frustum, _) = view(&mut rng);
+            let records: Vec<Record> = (0..400)
+                .map(|i| {
+                    let key = (rng.range(-6, 6), rng.range(0, 23), rng.range(-6, 6));
+                    Record::new(
+                        key,
+                        i % 3,
+                        u64::from(i) * 1024,
+                        1 + rng.below(500),
+                        UNBOUNDED,
+                    )
+                })
+                .collect();
+            let mut timing = PassTiming::new(device, queue);
+            let early = device
+                .features()
+                .contains(wgpu::Features::SHADER_EARLY_DEPTH_TEST);
+            let Some(t) = timing.as_mut().filter(|_| early) else {
+                eprintln!("no timestamps or early depth test: skipped");
+                return;
+            };
+            t.set_detail(true);
+            let run = |timing: &mut Option<PassTiming>| {
+                let mut gpu = GpuCulling::new(device, Some(wgpu::TextureFormat::Rgba8Unorm))
+                    .expect("the pass");
+                let mut uploads = Uploads::new(device);
+                for r in &records {
+                    gpu.records.insert(*r);
+                }
+                let mut out = Vec::new();
+                for frame in 0..12 {
+                    if let Some(t) = timing {
+                        t.begin(device, queue);
+                    }
+                    let mut encoder = device.create_command_encoder(&Default::default());
+                    let input = FrameInputs {
+                        camera: DVec3::new(0.5, 70.0, 0.5),
+                        min_y: -64,
+                        sections: 24,
+                        radius: 5,
+                        frustum: &frustum,
+                        reach: None,
+                        eye: None,
+                        view_proj: Mat4::IDENTITY,
+                        occlude: true,
+                    };
+                    let prepared = gpu.prepare(
+                        device,
+                        queue,
+                        &mut uploads,
+                        &mut encoder,
+                        &input,
+                        timing.as_mut(),
+                    );
+                    assert_eq!(prepared, Prepared::Gpu, "frame {frame}");
+                    assert!(gpu.occluding(), "frame {frame}: phase 2 runs");
+                    gpu.dispatch(&mut encoder, timing.as_mut());
+                    gpu.compact(&mut encoder, timing.as_mut());
+                    uploads.finish(&encoder);
+                    queue.submit([encoder.finish()]);
+                    if let Some(t) = timing {
+                        t.submitted(queue);
+                    }
+                    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+                    let pages = u64::from(gpu.pass_pages);
+                    out.push((
+                        read(device, queue, &gpu.counts.buffer, (STATS + 2 * pages) * 4),
+                        read(device, queue, &gpu.draws.buffer, gpu.draws.bytes),
+                    ));
+                }
+                out
+            };
+            let timed = run(&mut timing);
+            let plain = run(&mut None);
+            assert_eq!(timed, plain, "detail changes what is drawn");
+            let t = timing.as_ref().expect("the timer");
+            let parts = t.part_medians();
+            let names = |pass: &str| {
+                let parts = parts.iter().find(|p| p.0 == pass)?;
+                Some(parts.1.iter().map(|p| p.0.as_str()).collect::<Vec<_>>())
+            };
+            assert_eq!(
+                names("GPU culling"),
+                Some(vec!["apply", "cull", "scan", "scatter"]),
+                "{parts:?}"
+            );
+            assert_eq!(
+                names("GPU culling phase 2"),
+                Some(vec!["count2", "scan2", "scatter2"]),
+                "{parts:?}"
+            );
+            // The uploads are a pass of their own, never a part of one.
+            assert_eq!(names("GPU culling uploads"), None, "{parts:?}");
+            let passes = t.medians();
+            assert_eq!(
+                passes.iter().any(|p| p.0 == "GPU culling uploads"),
+                t.detail_support().encoder_stamps,
+                "{passes:?}"
+            );
+        });
+    }
+
    /// The statistics come back with their frame, in place and from the submit
    /// thread, submitted as gfx.rs submits frames (`submit_later`, or in place
    /// with its `after` handed back): three frames on their way fill the ring, a
@@ -3377,7 +3546,7 @@ struct Quad {
                view_proj: Mat4::IDENTITY,
                occlude: false,
            };
-            let prepared = gpu.prepare(device, queue, &mut uploads, &mut encoder, &input);
+            let prepared = gpu.prepare(device, queue, &mut uploads, &mut encoder, &input, None);
            assert_eq!(prepared, Prepared::Gpu, "frame {frame}");
            let mut params = tables(&input, &mut words).expect("the planes fit");
            params.pages = gpu.pass_pages;
@@ -0,0 +1,132 @@
+//! Frames in flight: the readbacks a submission starts, landing frames the submit thread
+//! submitted, keeping offscreen frames at most two ahead of the GPU, and a screenshot's copy.
+
+use super::{Renderer, ScreenshotRequest, copy_frame, screenshot_save, submit};
+
+impl Renderer {
+    /// The frame's readbacks to start right after its submission (on the submit thread when
+    /// the frame goes there): occlusion culling's results (`cull`) and GPU culling's
+    /// statistics. GPU frames leave occlusion culling off, so a frame has one at most.
+    pub(super) fn after_submit(&mut self) -> Option<submit::AfterSubmit> {
+        let cull = self.cull.as_mut().and_then(|c| c.submitted());
+        let gpu = self.gpu_culling.as_mut().and_then(|g| g.submitted());
+        match (cull, gpu) {
+            (Some(c), Some(g)) => Some(Box::new(move || {
+                c();
+                g();
+            })),
+            (Some(c), None) => Some(Box::new(c)),
+            (None, Some(g)) => Some(Box::new(g)),
+            (None, None) => None,
+        }
+    }
+    /// Frame `frame`'s statistics shown, unless a newer frame's are: a CPU frame's as it is
+    /// drawn, a GPU frame's when its counts come back (`GpuCulling::collect`).
+    pub(super) fn show_stats(&mut self, frame: u64, [sections, draws, calls]: [usize; 3]) {
+        if frame > self.stats_frame {
+            self.stats_frame = frame;
+            (
+                self.drawn_sections,
+                self.section_draws,
+                self.section_draw_calls,
+            ) = (sections, draws, calls);
+        }
+    }
+    /// Frames between the last one drawn and the one whose statistics are shown: 0 after a
+    /// CPU frame, one to three in GPU frames, while their counts are on their way back.
+    pub fn stats_lag(&self) -> u64 {
+        self.frame_serial - self.stats_frame
+    }
+    /// Take in the frame the submit thread submitted: start its readbacks and, offscreen,
+    /// keep at most two frames ahead of the GPU, as a frame submitted in place does.
+    pub(super) fn land_frame(&mut self) {
+        let Some(offscreen) = self.deferred.take() else {
+            return;
+        };
+        let submission = self.queue.landed();
+        if let Some(timer) = &mut self.gpu_timer {
+            timer.submitted(&self.queue);
+            timer.collect(&self.device, &mut self.gpu_times);
+        }
+        if let Some(Some(timer)) = Self::pass_timer(&mut self.pack_post, &mut self.native) {
+            timer.submitted(&self.queue);
+        }
+        if let Some(timer) = &mut self.own_timing {
+            timer.submitted(&self.queue);
+        }
+        if offscreen && let Some(submission) = submission {
+            self.in_flight.push_back(submission);
+            if !self.paced_elsewhere {
+                self.wait_frames();
+            }
+        }
+    }
+    /// No swapchain paces offscreen frames: keep two on the GPU at most.
+    pub fn wait_in_flight(&mut self) {
+        self.land_frame();
+        self.wait_frames();
+    }
+    /// The frame on the submit thread submitted: a surface reconfigure waits for the
+    /// device and breaks if a frame is submitted while it waits, and the compositor
+    /// copies views after them. (The end of a frame already lands the frames of the
+    /// turn before; this is the turn's own.)
+    pub fn wait_submissions(&mut self) {
+        self.queue.wait();
+    }
+    pub(super) fn wait_frames(&mut self) {
+        while self.in_flight.len() > 2 {
+            let index = self.in_flight.pop_front();
+            let _ = self.device.poll(wgpu::PollType::Wait {
+                submission_index: index,
+                timeout: Some(std::time::Duration::from_secs(5)),
+            });
+        }
+    }
+    /// Take a screenshot request: queue the frame's copy, or report why the
+    /// frame cannot be read back.
+    pub(super) fn take_readback(
+        &mut self,
+        request: ScreenshotRequest,
+        encoder: &mut wgpu::CommandEncoder,
+        texture: &wgpu::Texture,
+    ) -> Option<(ScreenshotRequest, wgpu::Buffer)> {
+        // The copy and PNG writer both assume 8-bit pixels; a float surface would make
+        // the row stride too small for the copy and abort in validation.
+        if self.config.format.block_copy_size(None) == Some(4) {
+            let size = [self.config.width, self.config.height];
+            let format = self.config.format.remove_srgb_suffix();
+            // The layered float frame maps the world to SDR, then adds the HUD as drawn.
+            // Other 16-bit frames keep their clipped 8-bit copy.
+            let copy = self
+                .hdr
+                .as_mut()
+                .and_then(|hdr| {
+                    hdr.sdr_screenshot(&self.device, encoder, format, request.size.is_some())
+                })
+                .or_else(|| {
+                    (texture.format() != format && texture.format() == self.output.frame.format)
+                        .then(|| {
+                            self.readback
+                                .unorm_copy(&self.device, encoder, texture, format)
+                        })
+                });
+            let texture = copy.as_ref().unwrap_or(texture);
+            Some((request, copy_frame(&self.device, encoder, texture, size)))
+        } else {
+            let error = format!(
+                "screenshots need a 32-bit surface format, not {:?}",
+                self.config.format
+            );
+            if request.background {
+                self.saved_screenshots.push(screenshot_save::Saved {
+                    path: request.path,
+                    result: Err(error),
+                    hdr: None,
+                });
+            } else {
+                self.screenshot_result = Some(Err(error));
+            }
+            None
+        }
+    }
+}
@@ -696,13 +696,16 @@ impl Oit {
            ),
        ] {
            {
-                let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                let pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                    label: Some(label),
                    timestamp_writes: timing.as_deref_mut().and_then(|t| t.writes(label)),
                    color_attachments: &first,
                    depth_stencil_attachment: read_only(terrain_depth),
                    ..Default::default()
                });
+                let pixels = super::pixel_count(terrain_depth);
+                let mut pass =
+                    super::pack_timing::counted(timing.as_deref_mut(), pass, pixels, label);
                pass.set_bind_group(GROUP, group, &[]);
                draw(&mut pass, stage);
            }
@@ -0,0 +1,169 @@
+//! The world pass after culling, and the renderer's GPU pass timing switches and readings.
+use super::{Renderer, native_pack, pack_post, pack_timing};
+
+pub(super) fn world_pass_after_culling<'e>(
+    encoder: &'e mut wgpu::CommandEncoder,
+    view: &wgpu::TextureView,
+    depth: &wgpu::TextureView,
+    keep_depth: bool,
+    mut timing: Option<&mut pack_timing::PassTiming>,
+    name: &str,
+    pixels: u64,
+) -> pack_timing::CountedPass<'e> {
+    let pass = after_culling_pass(
+        encoder,
+        view,
+        depth,
+        keep_depth,
+        timing.as_deref_mut().and_then(|t| t.writes(name)),
+    );
+    pack_timing::counted(timing, pass, pixels, "before translucent")
+}
+/// The pixels of a depth attachment, for `fragments_per_pixel`.
+pub(super) fn pixel_count(depth: &wgpu::TextureView) -> u64 {
+    let texture = depth.texture();
+    u64::from(texture.width()) * u64::from(texture.height())
+}
+pub(super) fn after_culling_pass<'e>(
+    encoder: &'e mut wgpu::CommandEncoder,
+    view: &wgpu::TextureView,
+    depth: &wgpu::TextureView,
+    keep_depth: bool,
+    timestamp_writes: Option<wgpu::RenderPassTimestampWrites<'_>>,
+) -> wgpu::RenderPass<'e> {
+    encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+        label: Some("Horizon world, after culling"),
+        timestamp_writes,
+        color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+            view,
+            resolve_target: None,
+            depth_slice: None,
+            ops: wgpu::Operations {
+                load: wgpu::LoadOp::Load,
+                store: wgpu::StoreOp::Store,
+            },
+        })],
+        depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+            view: depth,
+            depth_ops: Some(wgpu::Operations {
+                load: wgpu::LoadOp::Load,
+                // A shader pack reads it as depthtex0.
+                store: if keep_depth {
+                    wgpu::StoreOp::Store
+                } else {
+                    wgpu::StoreOp::Discard
+                },
+            }),
+            stencil_ops: None,
+        }),
+        ..Default::default()
+    })
+}
+
+impl Renderer {
+    /// Times the shader pack's passes on the GPU while `on` (the F3 overlay is open or a capture records them).
+    pub fn set_pass_timing(&mut self, on: bool) {
+        self.pass_timing = on;
+    }
+    /// Times the parts of Horizon's own passes while `on`.
+    pub fn set_pass_detail(&mut self, on: bool) {
+        self.pass_detail = on;
+    }
+    /// Times a frame at most once per `gap` while passes are timed (the F3 overlay needs far fewer
+    /// samples than a measurement).
+    pub fn set_pass_timing_gap(&mut self, gap: std::time::Duration) {
+        self.pass_timing_gap = gap;
+    }
+    /// Keeps each timed frame's pass times for `take_timed_frames` while `on` (a capture records them).
+    pub fn set_keep_timed_frames(&mut self, on: bool) {
+        self.keep_timed_frames = on;
+    }
+    /// The frames both timers timed since the last call, without waiting on the GPU.
+    pub fn take_timed_frames(&mut self) -> pack_timing::TimedFrames {
+        let own = self
+            .own_timing
+            .as_mut()
+            .map(pack_timing::PassTiming::take_frames)
+            .unwrap_or_default();
+        let pack = match Self::pass_timer(&mut self.pack_post, &mut self.native) {
+            Some(Some(t)) => t.take_frames(),
+            _ => Vec::new(),
+        };
+        pack_timing::TimedFrames { own, pack }
+    }
+    /// The running shader pack's timer, of either kind.
+    pub(super) fn pass_timer<'a>(
+        pack: &'a mut Option<(i32, Option<pack_post::PackPost>)>,
+        native: &'a mut Option<native_pack::NativePack>,
+    ) -> Option<&'a mut Option<pack_timing::PassTiming>> {
+        match (pack, native) {
+            (Some((_, Some(post))), _) => Some(&mut post.timing),
+            (_, Some(native)) => Some(&mut native.timing),
+            _ => None,
+        }
+    }
+    /// Each pass of the running shader pack with its median GPU time in milliseconds, while
+    /// they are timed (`set_pass_timing`).
+    pub fn shader_pass_times(&self) -> Vec<(String, f32)> {
+        let timer = match (&self.pack_post, &self.native) {
+            (Some((_, Some(post))), _) => post.timing.as_ref(),
+            (_, Some(native)) => native.timing.as_ref(),
+            _ => None,
+        };
+        timer
+            .map(pack_timing::PassTiming::medians)
+            .unwrap_or_default()
+    }
+    /// Each of Horizon's own passes with its median GPU time in milliseconds, while they are
+    /// timed (`set_pass_timing`).
+    pub fn own_pass_times(&self) -> Vec<(String, f32)> {
+        self.own_timing
+            .as_ref()
+            .map(pack_timing::PassTiming::medians)
+            .unwrap_or_default()
+    }
+    /// Each of Horizon's own passes with its parts' median GPU times in milliseconds.
+    pub fn own_pass_parts(&self) -> Vec<(String, Vec<(String, f32)>)> {
+        self.own_timing
+            .as_ref()
+            .map(pack_timing::PassTiming::part_medians)
+            .unwrap_or_default()
+    }
+    /// Each counted pass's counters (medians), while detail is on and the device has them.
+    pub fn own_pass_counters(&self) -> Vec<(String, pack_timing::PassCounters)> {
+        self.own_timing
+            .as_ref()
+            .map(pack_timing::PassTiming::counter_medians)
+            .unwrap_or_default()
+    }
+    /// Both timers' readings and this adapter, for a capture; `None` when neither has timed a pass.
+    pub fn gpu_readout(&self) -> Option<pack_timing::GpuReadout> {
+        let own = self
+            .own_timing
+            .as_ref()
+            .map(pack_timing::PassTiming::readings)
+            .filter(|r| !r.is_empty());
+        let pack = match (&self.pack_post, &self.native) {
+            (Some((_, Some(post))), _) => post.timing.as_ref(),
+            (_, Some(native)) => native.timing.as_ref(),
+            _ => None,
+        }
+        .map(pack_timing::PassTiming::readings)
+        .filter(|r| !r.is_empty());
+        (own.is_some() || pack.is_some()).then(|| pack_timing::GpuReadout {
+            adapter: self.info.clone(),
+            own,
+            pack,
+        })
+    }
+    /// Whether dispatch parts and counters are being asked for (`set_pass_detail`).
+    pub fn pass_detail(&self) -> bool {
+        self.pass_detail
+    }
+    /// What detail timing can show on this device; `None` without pass timing.
+    pub fn pass_detail_support(&self) -> Option<pack_timing::DetailSupport> {
+        self.own_timing
+            .as_ref()
+            .map(pack_timing::PassTiming::detail_support)
+    }
+}
@@ -2,8 +2,8 @@
 //! an adapter that can't present to the window gives way to another of its backend
 //! (#13493).
 use super::{
-    Renderer, check_layers, cull, describe_adapter, is_software, oit, startup_step, surface_format,
-    timing,
+    Renderer, check_layers, cull, describe_adapter, is_software, oit, pack_timing, startup_step,
+    surface_format, timing,
 };
 // Ray tracing on request, which the device needs from its creation (gfx.rs may not grow).
 #[path = "ray_query.rs"]
@@ -135,6 +135,7 @@ pub(super) async fn open_adapter(
    // atomics on images: their buffers and images. Filtering 32-bit float textures: shader
    // packs' RGBA32F buffers, which GL filters and mipmaps. Count draws: GPU culling's (`gpu_culling`).
    let features = timing::GpuTimer::features(adapter)
+        | pack_timing::PassTiming::features(adapter)
        | cull::Cull::features(adapter)
        | oit::features(adapter)
        | ray_query::features(adapter)
@@ -0,0 +1,252 @@
+//! The camera's view frustum, as camera-relative clip planes.
+
+use glam::{Vec3, Vec4};
+
+/// Camera-relative clip planes (`Frustum`).
+#[derive(Clone, Copy, Debug)]
+pub struct Frustum {
+    pub(super) planes: [Vec4; 6],
+}
+impl Frustum {
+    /// Whether the camera-relative box `min..max` is at least partly inside.
+    pub fn intersects(&self, min: Vec3, max: Vec3) -> bool {
+        !self.planes.iter().any(|p| {
+            let sign = p.truncate().cmpge(Vec3::ZERO);
+            let v = Vec3::select(sign, max, min);
+            p.truncate().dot(v) + p.w < 0.0
+        })
+    }
+    /// Whether a camera-relative sphere is at least partly inside. Frustum
+    /// planes are normalized, so each test needs only one dot product and a
+    /// radius comparison.
+    pub fn intersects_sphere(&self, center: Vec3, radius: f32) -> bool {
+        if !center.is_finite() || !radius.is_finite() || radius < 0.0 {
+            return true;
+        }
+        !self
+            .planes
+            .iter()
+            .any(|plane| plane.truncate().dot(center) + plane.w < -radius)
+    }
+    /// Depth clip planes alone: X/Y projection jitter cannot change this test.
+    /// Retaining side-of-screen geometry makes this safe before TAA selects a phase.
+    pub fn intersects_depth(&self, min: Vec3, max: Vec3) -> bool {
+        if !min.is_finite() || !max.is_finite() || !min.cmple(max).all() {
+            return true;
+        }
+        !self.planes[4..].iter().any(|p| {
+            let sign = p.truncate().cmpge(Vec3::ZERO);
+            let v = Vec3::select(sign, max, min);
+            p.truncate().dot(v) + p.w < 0.0
+        })
+    }
+    /// Whether the camera-relative box `min..max` is entirely inside. Then
+    /// `intersects` accepts every box within it: each plane's distance only
+    /// grows from this box's nearest corner to the inner box's farthest, and
+    /// rounding keeps that order.
+    pub fn contains(&self, min: Vec3, max: Vec3) -> bool {
+        self.planes.iter().all(|p| {
+            let sign = p.truncate().cmpge(Vec3::ZERO);
+            let v = Vec3::select(sign, min, max);
+            p.truncate().dot(v) + p.w >= 0.0
+        })
+    }
+    /// Whether the camera-relative `point` is on or inside every plane (vanilla's
+    /// `Frustum.pointInFrustum`). A point that is not finite is kept: a test that cannot
+    /// tell must not hide the particle.
+    pub fn contains_point(&self, point: Vec3) -> bool {
+        if !point.is_finite() {
+            return true;
+        }
+        self.planes
+            .iter()
+            .all(|plane| plane.truncate().dot(point) + plane.w >= 0.0)
+    }
+    /// The same frustum seen from a camera moved `blocks` back along the view direction
+    /// (vanilla's `Frustum.offset`): the sides open up near the camera and the near plane
+    /// moves behind it, so what sits just behind or beside the camera stays inside.
+    ///
+    /// The view direction is the normal of the depth planes (the two are opposite), signed
+    /// towards where the side planes point. A frustum that has no direction to pull along
+    /// comes back unchanged: a box with no depth planes (the shadow pass's), and a box whose
+    /// sides are parallel to the view direction (an orthographic projection), where the side
+    /// normals cancel and say nothing about which way is forward.
+    pub fn pulled_back(&self, blocks: f32) -> Frustum {
+        let sides: Vec3 = self.planes[..4].iter().map(|p| p.truncate()).sum();
+        let depth = self.planes[4].truncate();
+        let along = depth.dot(sides);
+        // A perspective frustum's four side normals each lean forward, so this is well above 1.
+        if along.abs() < 1.0e-3 {
+            return *self;
+        }
+        let toward_sides = if along > 0.0 { depth } else { -depth };
+        let axis = toward_sides.normalize_or_zero();
+        let mut planes = self.planes;
+        for plane in &mut planes {
+            plane.w += blocks * plane.truncate().dot(axis);
+        }
+        Frustum { planes }
+    }
+    /// The frustum of a camera-relative `view_proj`, for tests outside this module.
+    #[cfg(test)]
+    pub(crate) fn from_view_projection(view_proj: glam::Mat4) -> Frustum {
+        Frustum {
+            planes: super::frustum(view_proj),
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::{Frustum, Vec3};
+    use crate::gfx::world_projection;
+    use glam::Mat4;
+
+    const FOV: f32 = 70.0;
+    const ASPECT: f32 = 16.0 / 9.0;
+    const FAR: f32 = 512.0;
+    const EPS: f32 = 0.01;
+
+    fn looking_down_minus_z() -> Frustum {
+        Frustum::from_view_projection(world_projection(FOV, ASPECT, FAR))
+    }
+
+    fn tangents() -> (f32, f32) {
+        let up = (FOV / 2.0).to_radians().tan();
+        (up * ASPECT, up)
+    }
+
+    /// Each of the six planes of the unmoved frustum, a point just inside and one just outside,
+    /// from the field of view worked out by hand.
+    #[test]
+    fn a_point_is_inside_only_within_all_six_planes() {
+        let view = looking_down_minus_z();
+        let (tan_x, tan_y) = tangents();
+        let depth = 10.0;
+        let inside = [
+            Vec3::new(0.0, 0.0, -depth),
+            Vec3::new(depth * tan_x - EPS, 0.0, -depth),
+            Vec3::new(-(depth * tan_x - EPS), 0.0, -depth),
+            Vec3::new(0.0, depth * tan_y - EPS, -depth),
+            Vec3::new(0.0, -(depth * tan_y - EPS), -depth),
+            Vec3::new(0.0, 0.0, -0.06),
+            Vec3::new(0.0, 0.0, -(FAR - 0.1)),
+        ];
+        let outside = [
+            Vec3::new(depth * tan_x + EPS, 0.0, -depth),
+            Vec3::new(-(depth * tan_x + EPS), 0.0, -depth),
+            Vec3::new(0.0, depth * tan_y + EPS, -depth),
+            Vec3::new(0.0, -(depth * tan_y + EPS), -depth),
+            Vec3::new(0.0, 0.0, -0.04),
+            Vec3::new(0.0, 0.0, -(FAR + 0.1)),
+            Vec3::new(0.0, 0.0, 1.0),
+            Vec3::new(0.0, 0.0, 0.0),
+        ];
+        for p in inside {
+            assert!(view.contains_point(p), "{p} should be inside");
+        }
+        for p in outside {
+            assert!(!view.contains_point(p), "{p} should be outside");
+        }
+        assert!(view.contains_point(Vec3::NAN), "an unknown point is kept");
+    }
+
+    /// Camera 3 blocks back: its apex is at z = 3, so the sides open by 3 * tan, the near
+    /// plane is at z = 3 - 0.05 and the far plane at z = 3 - FAR.
+    #[test]
+    fn pulling_the_camera_back_moves_every_plane() {
+        let (tan_x, tan_y) = tangents();
+        let back = looking_down_minus_z().pulled_back(3.0);
+        let inside = [
+            Vec3::new(0.0, 0.0, 2.9),
+            Vec3::new(3.0 * tan_x - EPS, 0.0, 0.0),
+            Vec3::new(-(3.0 * tan_x - EPS), 0.0, 0.0),
+            Vec3::new(0.0, 3.0 * tan_y - EPS, 0.0),
+            Vec3::new(0.0, -(3.0 * tan_y - EPS), 0.0),
+            Vec3::new(0.0, 0.0, 3.0 - FAR + 0.1),
+        ];
+        let outside = [
+            Vec3::new(0.0, 0.0, 3.0),
+            Vec3::new(3.0 * tan_x + EPS, 0.0, 0.0),
+            Vec3::new(-(3.0 * tan_x + EPS), 0.0, 0.0),
+            Vec3::new(0.0, 3.0 * tan_y + EPS, 0.0),
+            Vec3::new(0.0, -(3.0 * tan_y + EPS), 0.0),
+            Vec3::new(0.0, 0.0, 3.0 - FAR - 0.1),
+        ];
+        for p in inside {
+            assert!(back.contains_point(p), "{p} should be inside");
+        }
+        for p in outside {
+            assert!(!back.contains_point(p), "{p} should be outside");
+        }
+        // The unmoved frustum does not have the point that only the offset one has.
+        assert!(!looking_down_minus_z().contains_point(Vec3::new(0.0, 0.0, 2.9)));
+        // An offset of nothing changes no verdict.
+        let same = looking_down_minus_z();
+        let unmoved = same.pulled_back(0.0);
+        for p in [
+            Vec3::new(1.0, 2.0, -3.0),
+            Vec3::new(0.0, 0.0, 1.0),
+            Vec3::new(40.0, 0.0, -5.0),
+        ] {
+            assert_eq!(same.contains_point(p), unmoved.contains_point(p));
+        }
+    }
+
+    /// The offset follows the camera's own view direction, whatever way it looks.
+    #[test]
+    fn the_offset_is_along_the_view_direction() {
+        for (yaw, pitch) in [(0.3_f32, 0.0_f32), (2.0, -0.5), (-1.2, 0.9), (3.0, 1.2)] {
+            let pose = Mat4::from_rotation_x(pitch) * Mat4::from_rotation_y(yaw);
+            let view = Frustum::from_view_projection(world_projection(FOV, ASPECT, FAR) * pose);
+            let forward = pose.inverse().transform_vector3(-Vec3::Z);
+            let back = view.pulled_back(3.0);
+            assert!(
+                back.contains_point(forward * -2.9),
+                "{yaw} {pitch}: 2.9 behind"
+            );
+            assert!(
+                !back.contains_point(forward * -3.0),
+                "{yaw} {pitch}: 3 behind"
+            );
+            assert!(
+                !view.contains_point(forward * -2.9),
+                "{yaw} {pitch}: unmoved"
+            );
+            assert!(back.contains_point(forward * 20.0) && view.contains_point(forward * 20.0));
+        }
+    }
+
+    /// An orthographic box has no apex to pull back from: its side normals cancel, so there is
+    /// no direction, and the frustum must come back as it was.
+    #[test]
+    fn an_orthographic_frustum_stays_where_it_is() {
+        let ortho =
+            Frustum::from_view_projection(Mat4::orthographic_rh(-8.0, 8.0, -4.5, 4.5, 100.0, 0.05));
+        let moved = ortho.pulled_back(3.0);
+        for p in [
+            Vec3::new(0.0, 0.0, 2.0),
+            Vec3::new(0.0, 0.0, -9.0),
+            Vec3::new(7.9, 4.4, -9.0),
+            Vec3::new(8.1, 0.0, -9.0),
+            Vec3::new(0.0, 0.0, -101.0),
+        ] {
+            assert_eq!(ortho.contains_point(p), moved.contains_point(p), "{p}");
+        }
+    }
+
+    /// The shadow pass's box has no depth planes, so no direction: it must not move.
+    #[test]
+    fn a_frustum_without_depth_planes_stays_where_it_is() {
+        let mut flat = looking_down_minus_z();
+        flat.planes[4] = glam::Vec4::W;
+        flat.planes[5] = glam::Vec4::W;
+        let moved = flat.pulled_back(3.0);
+        for p in [
+            Vec3::new(0.0, 0.0, 2.0),
+            Vec3::new(0.0, 0.0, -9.0),
+            Vec3::new(80.0, 0.0, -9.0),
+        ] {
+            assert_eq!(flat.contains_point(p), moved.contains_point(p));
+        }
+    }
+}
@@ -239,17 +239,17 @@ impl Visbuffer {
        encoder: &'e mut wgpu::CommandEncoder,
        depth: &wgpu::TextureView,
        clear: bool,
-        timing: Option<&mut PassTiming>,
-    ) -> wgpu::RenderPass<'e> {
+        mut timing: Option<&mut PassTiming>,
+    ) -> super::pack_timing::CountedPass<'e> {
        let (ids, _) = self.ids.as_ref().expect("fitted before the world pass");
        let name = if clear {
            "Visibility IDs"
        } else {
            "Visibility IDs after culling"
        };
-        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+        let pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
            label: Some("Horizon visibility buffer"),
-            timestamp_writes: timing.and_then(|t| t.writes(name)),
+            timestamp_writes: timing.as_deref_mut().and_then(|t| t.writes(name)),
            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                view: ids,
                resolve_target: None,
@@ -272,7 +272,8 @@ impl Visbuffer {
                stencil_ops: None,
            }),
            ..Default::default()
-        })
+        });
+        super::pack_timing::counted(timing, pass, super::pixel_count(depth), name)
    }

    /// Phase 1's solid calls into the IDs, as the normal passes draw them: the opaque
@@ -853,7 +853,7 @@ impl H {
    fn label(self, s: &Settings, out: &EffectiveOutput) -> Text {
        let g = &s.horizon;
        match self {
-            H::Preset => labelled("Preset", g.preset.label()),
+            H::Preset => labelled("Horizon Preset", g.preset.label()),
            H::LodDistance => match g.lod_distance {
                0 => labelled("LOD Distance", "Off"),
                n => labelled("LOD Distance", lang::tr("%s chunks", &[&n])),
@@ -1753,6 +1753,14 @@ mod tests {
        ui.set_search("tearing");
        let found = ui.listed(&s, SIZE);
        assert!(found.iter().any(|(_, i)| *i == Item::Vanilla(Opt::Vsync)));
+        // Both presets answer "preset"; Horizon's own, named apart from vanilla's, answers its name.
+        ui.set_search("preset");
+        let found = ui.listed(&s, SIZE);
+        let general = |item| (Page::General, item);
+        assert!(found.contains(&general(Item::Horizon(H::Preset))));
+        assert!(found.contains(&general(Item::Vanilla(Opt::Preset))));
+        ui.set_search("horizon preset");
+        assert_eq!(ui.listed(&s, SIZE), [general(Item::Horizon(H::Preset))]);
        ui.set_search("hdr");
        let [x, y, w, h] = cols.page(Page::ALL.len() - 1);
        press(&mut ui, &mut s, (x + w / 2.0, y + h / 2.0));
@@ -55,7 +55,7 @@ pub struct TextureFlags {
 impl TextureFlags {
    /// The `texture` section of a `.png.mcmeta` file, if it sets either flag.
    pub fn from_mcmeta(json: &str) -> Option<Self> {
-        let meta = crate::packs::first_json(json.as_bytes())?;
+        let meta: serde_json::Value = crate::packs::first_json(json.as_bytes()).ok()?;
        let section = meta.get("texture")?;
        let flag = |key| section.get(key).and_then(serde_json::Value::as_bool) == Some(true);
        let flags = Self {
@@ -388,7 +388,7 @@ fn strip_frame(pixels: &[u8], stride: u32, x: u32, y: u32, w: u32, h: u32) -> Ve
 }
 /// The `animation` section of a texture's `.mcmeta`.
 fn animation_of(mcmeta: Option<&str>) -> Option<AnimationMetadata> {
-    let meta = crate::packs::first_json(mcmeta?.as_bytes())?;
+    let meta: serde_json::Value = crate::packs::first_json(mcmeta?.as_bytes()).ok()?;
    AnimationMetadata::from_json(&meta.get("animation")?.to_string()).ok()
 }
 /// An animated strip's first frame: the region the mcmeta's frame size picks
@@ -1401,9 +1401,9 @@ impl HudAtlas {
            edition.3 = pixels;
        }
        images.push(("horizon/white".into(), 4, 4, vec![255; 64]));
-        // The controller's art, unless a pack brought its own (walked above, as a mod's GUI
-        // textures are).
-        for image in crate::pad_glyph::images() {
+        // The controller's art and Horizon's mark, unless a pack brought its own (walked above, as a
+        // mod's GUI textures are).
+        for image in crate::pad_glyph::images().chain(crate::mark_sprite::image()) {
            if !images.iter().any(|i| i.0 == image.0) {
                images.push(image);
            }
@@ -74,6 +74,7 @@ pub mod level_loading;
 pub mod light;
 pub mod lod;
 pub mod logging;
+pub mod mark_sprite;
 pub mod menu_blur;
 pub mod menu_style;
 pub mod mesher;
@@ -102,6 +103,9 @@ pub mod pad_glyph;
 pub mod paged_maps;
 pub mod par;
 pub mod particles;
+#[cfg(target_os = "linux")]
+pub mod perf_capture;
+pub mod perf_gpu;
 pub mod poi_sections;
 pub mod polytone_post;
 pub mod post_chain;
@@ -0,0 +1,11 @@
+//! Horizon's mark (`docs/media/brand/mark-dark.svg`) on the text grid, for an inline text sprite.
+
+/// The mark's name in the HUD atlas.
+pub const SPRITE: &str = "horizon:gui/mark";
+const PNG: &[u8] = include_bytes!("../../horizon-client/assets/horizon/textures/gui/mark.png");
+
+/// The mark as the HUD atlas takes an image.
+pub fn image() -> std::iter::Once<(String, u32, u32, Vec<u8>)> {
+    let (width, height, rgba) = crate::hud::decode_bytes(PNG).expect("Horizon's mark is PNG");
+    std::iter::once((SPRITE.to_owned(), width, height, rgba))
+}
@@ -1594,9 +1594,9 @@ pub struct OptionsUi {
    radial_pick: shell::Shell<crate::radial_editor::PickScreen>,
    /// Shaders: the shader packs and the picked one's options, on the settings shell.
    shader: shell::Shell<crate::shader_ui::ShaderScreen>,
-    /// The Pack Options page, and the packs' Polytone config entries by pack id (the game
-    /// fills them beside `pack_infos`).
-    pub pack_options: crate::pack_options_ui::PackOptionsUi,
+    /// Pack Options, on the settings shell, and the packs' Polytone config entries by pack id
+    /// (the game fills them beside `pack_infos`).
+    pack_options: shell::Shell<crate::pack_options_ui::PackOptionsScreen>,
    pub pack_configs: std::collections::BTreeMap<String, horizon_polytone::pack::Configs>,
    pub split_profiles: crate::split_profiles::SplitProfiles,
    /// HDR calibration while its page is open.
@@ -3401,10 +3401,6 @@ impl OptionsUi {
            c.draw(batch, atlas, cursor);
            return;
        }
-        if self.page() == Page::PackOptions {
-            self.pack_options.draw(batch, atlas, cursor, self.in_world);
-            return;
-        }
        let waiting = self.waiting();
        let in_world = self.in_world;
        if self.draw_radial_name(batch, atlas, cursor, in_world) {
@@ -3786,20 +3782,6 @@ impl OptionsUi {
            });
            return self.shell_events(s, outputs);
        }
-        if self.page() == Page::PackOptions {
-            let mut events = Vec::new();
-            for action in self
-                .pack_options
-                .click((x, y), size, drag, right || self.shift)
-            {
-                match action {
-                    crate::pack_options_ui::Action::ButtonClick => events.push(Event::ButtonClick),
-                    crate::pack_options_ui::Action::SliderDrag => {}
-                    crate::pack_options_ui::Action::Done => events.extend(self.back(s)),
-                }
-            }
-            return events;
-        }
        if self.page() == Page::Packs {
            let mut events = Vec::new();
            if drag {
@@ -3829,14 +3811,7 @@ impl OptionsUi {
                crate::pack_screen::Action::BrowsePick(i) => {
                    events.push(Event::DownloadPack(i));
                }
-                crate::pack_screen::Action::Options(id) => {
-                    let mut configs = horizon_polytone::pack::Configs::default();
-                    if let Some(own) = self.pack_configs.get(&id) {
-                        configs.merge(own);
-                    }
-                    self.pack_options = crate::pack_options_ui::PackOptionsUi::open(configs);
-                    self.push(Page::PackOptions);
-                }
+                crate::pack_screen::Action::Options(id) => self.open_pack_options(&id),
                crate::pack_screen::Action::None => {}
            }
            return events;
@@ -4074,7 +4049,6 @@ impl OptionsUi {
        // release, even if the pointer has left the widget or its value stayed.
        let slider = self.dragging.take().is_some();
        let shell_slider = self.shell_mut().and_then(|shell| shell.release());
-        self.pack_options.release();
        let calibration_slider = self.calibration.as_mut().is_some_and(|c| c.release());
        let split_drop = self.split_setup.release();
        if slider || shell_slider.is_some() || calibration_slider {
@@ -4168,10 +4142,6 @@ impl OptionsUi {
            self.studio.wheel(amount);
            return Vec::new();
        }
-        if self.page() == Page::PackOptions {
-            self.pack_options.scroll(size, amount);
-            return Vec::new();
-        }
        let plain = self.resource_error.is_none()
            && !(self.pack_screen.is_some() && self.stack.last() == Some(&Page::Packs));
        if !plain {
@@ -4255,10 +4225,6 @@ impl OptionsUi {
            self.studio.wheel(amount);
            return;
        }
-        if self.page() == Page::PackOptions {
-            self.pack_options.scroll(size, amount);
-            return;
-        }
        match &mut self.pack_screen {
            Some(p) if self.stack.last() == Some(&Page::Packs) => {
                p.scroll(cursor.0 as f64, cursor.1 as f64, amount as f64)
@@ -4393,14 +4359,8 @@ impl OptionsUi {
        self.can_change_value = false;
        match page {
            Page::PackOptions => {
-                let ui = std::mem::take(&mut self.pack_options);
-                if ui.changed {
-                    let entries = ui.configs.entries().keys().cloned().collect();
-                    events.push(Event::PackOptions {
-                        entries,
-                        chosen: ui.configs.chosen(),
-                    });
-                }
+                let screen = std::mem::take(&mut self.pack_options.screen);
+                events.extend(screen.finished());
            }
            Page::ShaderOptions | Page::ShaderPacks => {
                if s.shader_options.as_ref().is_some_and(|o| o.changed) {
@@ -4960,6 +4920,34 @@ mod tests {
    /// A renderer whose destination offers nothing and whose display reports nothing.
    const NONE: EffectiveOutput = EffectiveOutput::NONE;

+    #[test]
+    fn pack_options_leave_with_a_change_and_with_nothing_after_its_undo() {
+        use crate::settings_shell::Screen as _;
+        let mut s = Settings::default();
+        let atlas = HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets"));
+        let atlas = atlas.unwrap();
+        let mut ui = OptionsUi::default();
+        let mut configs = horizon_polytone::pack::Configs::default();
+        let birds = serde_json::json!({"default_value": true});
+        configs.add_entry("p:birds".into(), &birds);
+        ui.pack_configs.insert("pack".into(), configs);
+        for undone in [false, true] {
+            ui.open_pack_options("pack");
+            assert!(ui.shell().is_some(), "Pack Options is on the shell");
+            let birds = crate::pack_options_ui::Item::Entry(0);
+            ui.pack_options.screen.press(&mut s, birds, false);
+            if undone {
+                let before = s.clone();
+                ui.pack_options.screen.undo(&mut s, &before);
+            }
+            let events = ui.key(&mut s, &atlas, winit::keyboard::KeyCode::Escape, None);
+            let sent = events
+                .iter()
+                .any(|e| matches!(e, Event::PackOptions { .. }));
+            assert_eq!(sent, !undone, "undone: {undone}");
+        }
+    }
+
    /// The window allows the input method only while `typing` says a search
    /// box has the focus (`Game::text_field_focused`), so a page without one
    /// must not claim the keys: the movement and menu keys keep working there.
@@ -23,6 +23,7 @@ impl OptionsUi {
            Page::ControllerRadialPick => Some(&self.radial_pick),
            page if Self::controller_page(page).is_some() => Some(&self.controller),
            page if Self::shader_page(page).is_some() => Some(&self.shader),
+            Page::PackOptions => Some(&self.pack_options),
            _ => None,
        }
    }
@@ -35,9 +36,20 @@ impl OptionsUi {
            Page::ControllerRadialPick => Some(&mut self.radial_pick),
            page if Self::controller_page(page).is_some() => Some(&mut self.controller),
            page if Self::shader_page(page).is_some() => Some(&mut self.shader),
+            Page::PackOptions => Some(&mut self.pack_options),
            _ => None,
        }
    }
+    /// Pack Options for the pack `id`, from the pack screen: its Polytone config entries.
+    pub(super) fn open_pack_options(&mut self, id: &str) {
+        let mut configs = horizon_polytone::pack::Configs::default();
+        if let Some(own) = self.pack_configs.get(id) {
+            configs.merge(own);
+        }
+        // Opening a shell starts it afresh: the entries go in after.
+        self.push(Page::PackOptions);
+        self.pack_options.screen = crate::pack_options_ui::PackOptionsScreen::open(configs);
+    }
    /// Where the open shell screen asked the focus to open (a radial slot's list, on the slot's
    /// action), for a controller's focus to land there.
    pub fn shell_opened_focus(&self) -> Option<[f32; 4]> {
@@ -53,13 +65,14 @@ impl OptionsUi {
            return;
        }
        // Every shell: the click may have changed the page.
-        let shells: [&mut dyn shell::Hosted; 6] = [
+        let shells: [&mut dyn shell::Hosted; 7] = [
            &mut self.extras,
            &mut self.graphics,
            &mut self.controller,
            &mut self.radial,
            &mut self.radial_pick,
            &mut self.shader,
+            &mut self.pack_options,
        ];
        for shell in shells {
            shell.clicks_step(false);
@@ -1,45 +1,36 @@
-//! The Pack Options page (#11486): the config entries of the selected resource packs' Polytone
-//! `config_entries` (wiki "Polytone Configs"), in the frame of Horizon's settings screens
-//! (`settings_shell`). Numbers are sliders, texts cycle, booleans switch; the entries sit in
-//! their `section`s, named by the packs' own translations. Leaving with Done keeps what changed,
-//! and the packs load again with it.
-use crate::widgets::Action as Declared;
+//! The Pack Options screen (#11486), on the settings shell (`settings_shell`): the config entries
+//! of the selected resource packs' Polytone `config_entries` (wiki "Polytone Configs"). Each
+//! `section` is a page, named by the packs' own translations; numbers are sliders that stop at
+//! the entry's `step`, value lists are choices, booleans switch and free text reads. The first
+//! page starts with the pack-wide presets and Reset all. The shell gives it the keyboard, a
+//! controller's focus, the search, the strip's descriptions and Undo; leaving keeps what differs
+//! from how the screen opened, and the packs load again with it.
 use crate::{
-    graphics_style as style,
-    hud::{HudAtlas, HudBatch},
    lang,
-    settings_shell::{self as shell, Columns, Line, Lines},
-    text::Text,
-    ui,
+    settings::Settings,
+    settings_shell::{self as shell, Group, Output, Row, Sheet, Value},
 };
 use horizon_polytone::pack::{ConfigKind, ConfigValue, Configs};

-/// What a click asks of the options screen.
+/// A row: the pack-wide presets, Reset all, or the entry at an index of `ids`.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Action {
-    ButtonClick,
-    SliderDrag,
-    /// Done: leave, keeping what changed.
-    Done,
+pub(crate) enum Item {
+    Presets,
+    ResetAll,
+    Entry(u16),
 }

-/// The page's state: the entries being edited, how they are listed, and the pointer's hold.
-#[derive(Default)]
-pub struct PackOptionsUi {
-    /// The selected packs' entries and the values being picked.
-    pub configs: Configs,
-    /// Entry ids, by the row index the list uses.
-    ids: Vec<String>,
-    /// The sections in order: the `section` id (none for entries without one) and its rows.
-    sections: Vec<(Option<String>, Vec<u16>)>,
-    scroll: ui::Scroll,
-    dragging: Option<u16>,
-    /// A value changed since the page opened.
-    pub changed: bool,
-}
-
-/// The presets' row (and its section): past every entry's index.
-const PRESETS: u16 = u16::MAX;
+const TITLE: &str = "horizon.pack.options.title";
+/// The first page's group of rows for the whole pack, and every page's group of entries.
+const WHOLE_PACK: &str = "Whole pack";
+const PACK_OPTIONS: &str = "Pack settings";
+const RESET_ALL: &str = "Reset all";
+const RESET_ABOUT: &str = "Puts every option of this pack back to its default.";
+const AT_DEFAULTS: &str = "Every option is at its default already.";
+const PRESETS_ABOUT: &str = "Sets many options at once, as the pack groups them.";
+const PACK_SETTINGS: &str = "Settings made by the pack's author: they change only this pack.";
+/// A pack's tooltips, with the performance line after them, run longer than Horizon's own.
+const NOTE_LINES: usize = 3;

 /// A translation, or `fallback` where no language has the key.
 fn translated(key: &str, fallback: impl FnOnce() -> String) -> String {
@@ -65,9 +56,34 @@ fn readable(path: &str) -> String {
        .unwrap_or_default()
 }

-impl PackOptionsUi {
-    /// The page opens on `configs`, the selected packs' entries with the player's values.
-    pub fn open(configs: Configs) -> Self {
+/// A number as its entry shows it: whole with a whole step, else up to two decimals.
+fn number_text(n: f64, step: f64) -> String {
+    if step >= 1.0 && step.fract() == 0.0 {
+        format!("{n:.0}")
+    } else {
+        let text = format!("{n:.2}");
+        text.trim_end_matches('0').trim_end_matches('.').to_owned()
+    }
+}
+
+/// The screen: the entries being edited, as they were when it opened (for Undo and for whether
+/// leaving changes anything), and how they are paged.
+#[derive(Default)]
+pub(crate) struct PackOptionsScreen {
+    /// The selected packs' entries and the values being picked.
+    pub(crate) configs: Configs,
+    opened: Configs,
+    /// Entry ids, by `Item::Entry`'s index.
+    ids: Vec<String>,
+    /// The sections in order: the `section` id (none for entries without one) and its entries.
+    sections: Vec<(Option<String>, Vec<u16>)>,
+    /// Bumped on every change, for `stamp`: the values are floats, which don't hash.
+    revision: u64,
+}
+
+impl PackOptionsScreen {
+    /// The screen opens on `configs`, the selected packs' entries with the player's values.
+    pub(crate) fn open(configs: Configs) -> Self {
        let mut ids: Vec<(String, Option<String>, i64)> = configs
            .entries()
            .iter()
@@ -96,25 +112,21 @@ impl PackOptionsUi {
            (None, None) => a.0.cmp(&b.0),
        });
        Self {
+            opened: configs.clone(),
            configs,
            ids: ids.into_iter().map(|(id, ..)| id).collect(),
            sections: sections.into_iter().map(|(s, _, rows)| (s, rows)).collect(),
-            ..Self::default()
+            revision: 0,
        }
    }

-    fn layout(&self, w: f32, h: f32) -> (Columns, Vec<Line<u16, u16>>, f32) {
-        let cols = Columns::of(w, h);
-        let mut lines = Lines::new();
-        // The pack-wide presets first, when the entries have some.
-        if !self.configs.presets().is_empty() {
-            lines.titled(PRESETS, vec![PRESETS]);
-        }
-        for (i, (_, rows)) in self.sections.iter().enumerate() {
-            lines.titled(i as u16, rows.clone());
-        }
-        let (lines, content) = lines.finish();
-        (cols, lines, content)
+    /// What leaving sends: the entries and the player's choices, if they differ from how the
+    /// screen opened (an Undo, or a value stepped back, leaves nothing to send).
+    pub(crate) fn finished(&self) -> Option<crate::options_ui::Event> {
+        (self.configs != self.opened).then(|| crate::options_ui::Event::PackOptions {
+            entries: self.configs.entries().keys().cloned().collect(),
+            chosen: self.configs.chosen(),
+        })
    }

    /// The namespace the presets' translations are under: of the first entry with presets.
@@ -166,21 +178,14 @@ impl PackOptionsUi {
            None if back => n - 1,
            None => 0,
        };
-        let before = self.configs.clone();
        self.configs.apply_preset(&presets[next]);
-        if self.configs != before {
-            self.changed = true;
-        }
+        self.revision += 1;
    }

-    /// A section's heading: `config.<namespace>.section.<id>`, by its first entry's namespace.
-    fn section_name(&self, section: u16) -> String {
-        if section == PRESETS {
-            let key = format!("{}.presets", self.presets_namespace());
-            return translated(&key, || lang::get("horizon.pack.options.presets"));
-        }
-        let Some((id, rows)) = self.sections.get(usize::from(section)) else {
-            return String::new();
+    /// A section's page name: `config.<namespace>.section.<id>`, by its first entry's namespace.
+    fn section_name(&self, section: usize) -> String {
+        let Some((id, rows)) = self.sections.get(section) else {
+            return lang::get("horizon.pack.options.general");
        };
        let Some(id) = id else {
            return lang::get("horizon.pack.options.general");
@@ -192,367 +197,218 @@ impl PackOptionsUi {
        translated(&format!("config.{namespace}.section.{id}"), || readable(id))
    }

-    /// An entry's name (`config.<namespace>.<name>`) and its value's label.
-    fn parts(&self, row: u16) -> (String, Option<String>) {
-        if row == PRESETS {
-            let label = self.preset_label(self.current_preset().as_deref());
-            return (self.section_name(PRESETS), Some(label));
-        }
-        let Some(id) = self.ids.get(usize::from(row)) else {
-            return (String::new(), None);
-        };
-        let (namespace, path) = split(id);
-        let name = translated(&format!("config.{namespace}.{path}"), || readable(path));
-        let entry = &self.configs.entries()[id];
-        let value = match self.configs.get(id) {
-            Some(ConfigValue::Number(n)) => {
-                let step = match entry.kind {
-                    ConfigKind::Number { step, .. } => step,
-                    _ => 1.0,
-                };
-                let text = if step >= 1.0 && step.fract() == 0.0 {
-                    format!("{n:.0}")
-                } else {
-                    format!("{n:.2}")
-                        .trim_end_matches('0')
-                        .trim_end_matches('.')
-                        .to_owned()
-                };
-                Some(text)
-            }
-            Some(ConfigValue::Text(t)) => Some(t.clone()),
-            Some(ConfigValue::Bool(_)) | None => None,
-        };
-        let value = value.map(|v| match &entry.value_translation {
-            Some(key) if lang::has(key) => lang::tr(key, &[&v]),
-            _ => v,
-        });
-        (name, value)
-    }
-
-    /// The tooltip (`config.<namespace>.<name>.tooltip`) and the performance hint.
-    fn description(&self, row: u16) -> String {
-        let Some(id) = self.ids.get(usize::from(row)) else {
-            return String::new();
-        };
+    /// The tooltip (`config.<namespace>.<name>.tooltip`) and the performance line after it.
+    fn description(&self, id: &str) -> String {
        let (namespace, path) = split(id);
        let key = format!("config.{namespace}.{path}.tooltip");
-        let mut text = if lang::has(&key) {
+        let tooltip = if lang::has(&key) {
            lang::get(&key)
        } else {
            String::new()
        };
-        if let Some(impact) = &self.configs.entries()[id].performance_impact {
-            let level = lang::get(&format!("horizon.pack.options.impact.{impact}"));
-            let line = lang::tr("horizon.pack.options.impact", &[&level]);
-            text = if text.is_empty() {
-                line
-            } else {
-                format!("{text} {line}")
-            };
-        }
-        text
-    }
-
-    /// A slider's place (0 to 1) for a number entry.
-    fn slider(&self, row: u16) -> Option<f32> {
-        let id = self.ids.get(usize::from(row))?;
-        let ConfigKind::Number { min, max, .. } = self.configs.entries()[id].kind else {
-            return None;
-        };
-        let Some(ConfigValue::Number(n)) = self.configs.get(id) else {
-            return None;
-        };
-        Some(if max > min {
-            ((n - min) / (max - min)) as f32
-        } else {
-            0.0
-        })
-    }
-
-    fn switch(&self, row: u16) -> Option<bool> {
-        match self.configs.get(self.ids.get(usize::from(row))?)? {
-            ConfigValue::Bool(b) => Some(*b),
-            _ => None,
+        let impact = self.configs.entries()[id]
+            .performance_impact
+            .as_ref()
+            .map(|impact| {
+                let level = lang::get(&format!("horizon.pack.options.impact.{impact}"));
+                lang::tr("horizon.pack.options.impact", &[&level])
+            });
+        match impact {
+            Some(line) if tooltip.is_empty() => line,
+            Some(line) => format!("{tooltip} {line}"),
+            None => tooltip,
        }
    }

-    pub fn draw(
-        &mut self,
-        batch: &mut HudBatch,
-        atlas: &HudAtlas,
-        cursor: (f32, f32),
-        in_world: bool,
-    ) {
-        let (w, h) = (batch.width, batch.height);
-        let (cols, lines, content) = self.layout(w, h);
-        self.scroll.clamp(cols.top, cols.bottom, content);
-        shell::backdrop(batch, atlas, in_world);
-        shell::mark(
-            batch,
-            atlas,
-            &cols,
-            &lang::get("horizon.pack.options.title"),
-        );
-        shell::plate(
-            batch,
-            atlas,
-            &cols,
-            &lang::get("horizon.pack.options.title"),
-        );
-        let over_list = cursor.1 >= cols.top && cursor.1 < cols.bottom;
-        let mut described = None;
-        shell::list(
-            batch,
-            atlas,
-            &cols,
-            &lines,
-            self.scroll.amount,
-            |section| self.section_name(section),
-            |batch, row: u16, y| {
-                let [rx, ry, rw, rh] = cols.row(y);
-                let hover = over_list && ui::hovered(cursor, rx, ry, rw, rh);
-                if hover || self.dragging == Some(row) {
-                    described = Some(row);
+    /// Entry `i`'s row: a switch, a slider in its steps, a choice, or text to read.
+    fn entry_row(&self, i: u16) -> Option<Row<Item>> {
+        let id = self.ids.get(usize::from(i))?;
+        let (namespace, path) = split(id);
+        let name = translated(&format!("config.{namespace}.{path}"), || readable(path));
+        let entry = &self.configs.entries()[id];
+        let shown = |text: String| match &entry.value_translation {
+            Some(key) if lang::has(key) => lang::tr(key, &[&text]),
+            _ => text,
+        };
+        let value = match (&entry.kind, self.configs.get(id)?) {
+            (_, ConfigValue::Bool(on)) => Value::Switch(*on),
+            (&ConfigKind::Number { min, max, step }, &ConfigValue::Number(n)) => {
+                let span = max - min;
+                let stops = if step > 0.0 {
+                    (span / step).round()
+                } else {
+                    0.0
+                };
+                Value::Slider {
+                    position: if span > 0.0 {
+                        ((n - min) / span) as f32
+                    } else {
+                        0.0
+                    },
+                    steps: (stops >= 1.0).then_some(stops as u32),
+                    text: shown(number_text(n, step)),
                }
-                let (name, value) = self.parts(row);
-                let label = match &value {
-                    Some(v) => format!("{name}: {v}"),
-                    None => name.clone(),
-                };
-                let view = shell::RowView {
-                    label: &label,
-                    name: &name,
-                    value: value.as_deref(),
-                    switch: self.switch(row),
-                    slider: self.slider(row),
-                    live: true,
-                    hover,
-                    focused: false,
-                    held: self.dragging == Some(row),
-                    key: None,
-                };
-                shell::row(batch, atlas, &cols, y, &view);
-            },
-        );
-        shell::scroller(batch, atlas, &cols, content, self.scroll.amount);
-        // The strip: the pointed-at entry's tooltip.
-        let [x, y, ..] = cols.dock;
-        style::panel(batch, atlas, cols.dock);
-        if let Some(row) = described {
-            let name = Text::literal(self.parts(row).0);
-            batch.text_styled(atlas, &name, x + 12.0, y + 8.0, style::WHITE, true);
-            shell::dock_note(batch, atlas, &cols, self.description(row), style::GREY);
-        }
-        let mut foot = vec![(cols.button(0), "gui.done", Some(Declared::Done))];
-        if self
-            .configs
-            .chosen()
-            .iter()
-            .any(|(id, _)| self.ids.contains(id))
-        {
-            foot.push((cols.button(1), "controls.reset", None));
-        }
-        for (rect, key, declared) in foot {
-            if let Some(declared) = declared {
-                crate::widgets::declare_action(declared, rect, true);
            }
-            let label = Text::literal(lang::get(key));
-            shell::foot_button(batch, atlas, rect, &label, cursor, (false, true));
-        }
+            (ConfigKind::Text { allowed }, ConfigValue::Text(t)) if !allowed.is_empty() => {
+                Value::Choice(shown(t.clone()))
+            }
+            (_, value) => Value::Read(shown(match value {
+                ConfigValue::Number(n) => number_text(*n, 1.0),
+                ConfigValue::Text(t) => t.clone(),
+                ConfigValue::Bool(b) => b.to_string(),
+            })),
+        };
+        Some(Row::new(Item::Entry(i), name, value).about(self.description(id)))
    }

-    /// A press (or a drag with `drag`) at `(x, y)`; `back` turns a cycle backwards.
-    pub fn click(
-        &mut self,
-        (x, y): (f32, f32),
-        (w, h): (f32, f32),
-        drag: bool,
-        back: bool,
-    ) -> Vec<Action> {
-        let (cols, lines, content) = self.layout(w, h);
-        let at = |[rx, ry, rw, rh]: [f32; 4]| ui::hovered((x, y), rx, ry, rw, rh);
-        if drag {
-            if self.scroll.held() {
-                self.scroll.drag(y, cols.top, cols.bottom, content);
-            } else if let Some(row) = self.dragging {
-                self.set_slider(row, cols.slider_at(x));
-                return vec![Action::SliderDrag];
-            }
-            return Vec::new();
+    /// The rows for the whole pack: its presets, when it has some, and Reset all.
+    fn whole_pack(&self) -> Group<Item> {
+        let mut rows = Vec::new();
+        if !self.configs.presets().is_empty() {
+            let key = format!("{}.presets", self.presets_namespace());
+            let name = translated(&key, || lang::get("horizon.pack.options.presets"));
+            let label = self.preset_label(self.current_preset().as_deref());
+            rows.push(
+                Row::new(Item::Presets, name, Value::Choice(label)).about(lang::get(PRESETS_ABOUT)),
+            );
        }
-        if cols.scrolls()
-            && self
-                .scroll
-                .press((x, y), cols.bar_x(), cols.top, cols.bottom, content)
-        {
-            return Vec::new();
+        let at_defaults = self.configs.chosen().is_empty();
+        let reset = Row::new(Item::ResetAll, lang::get(RESET_ALL), Value::Press)
+            .about(lang::get(RESET_ABOUT))
+            .blocked(at_defaults.then(|| lang::get(AT_DEFAULTS)));
+        rows.push(reset);
+        Group {
+            name: WHOLE_PACK,
+            rows,
        }
-        if at(cols.button(0)) {
-            return vec![Action::ButtonClick, Action::Done];
-        }
-        if at(cols.button(1)) {
-            self.reset();
-            return vec![Action::ButtonClick];
-        }
-        if y < cols.top || y >= cols.bottom {
-            return Vec::new();
-        }
-        let Some(row) = lines.iter().find_map(|line| {
-            let row = line.setting?;
-            at(cols.row(cols.top + line.y - self.scroll.amount)).then_some(row)
-        }) else {
-            return Vec::new();
-        };
-        if row == PRESETS {
-            self.cycle_preset(back);
-            return vec![Action::ButtonClick];
-        }
-        let Some(id) = self.ids.get(usize::from(row)).cloned() else {
-            return Vec::new();
-        };
-        let entry = self.configs.entries()[&id].clone();
-        match (&entry.kind, self.configs.get(&id).cloned()) {
-            (ConfigKind::Number { .. }, _) => {
-                self.dragging = Some(row);
-                self.set_slider(row, cols.slider_at(x));
-                return vec![Action::SliderDrag];
-            }
-            (ConfigKind::Bool, Some(ConfigValue::Bool(b))) => {
-                self.set(&id, ConfigValue::Bool(!b));
-            }
-            (ConfigKind::Text { allowed }, Some(ConfigValue::Text(t))) if !allowed.is_empty() => {
-                let i = allowed.iter().position(|a| *a == t).unwrap_or(0);
-                let n = allowed.len();
-                let next = if back { (i + n - 1) % n } else { (i + 1) % n };
-                self.set(&id, ConfigValue::Text(allowed[next].clone()));
-            }
-            _ => return Vec::new(),
-        }
-        vec![Action::ButtonClick]
    }

    fn set(&mut self, id: &str, value: ConfigValue) {
-        let before = self.configs.get(id).cloned();
        self.configs.set(id, value);
-        if self.configs.get(id).cloned() != before {
-            self.changed = true;
-        }
-    }
-
-    /// Number entry `row` at slider place `at` (0 to 1).
-    fn set_slider(&mut self, row: u16, at: f32) {
-        let Some(id) = self.ids.get(usize::from(row)).cloned() else {
-            return;
-        };
-        if let ConfigKind::Number { min, max, .. } = self.configs.entries()[&id].kind {
-            self.set(&id, ConfigValue::Number(min + f64::from(at) * (max - min)));
-        }
+        self.revision += 1;
    }

    /// Every entry back to its default.
    fn reset(&mut self) {
-        let defaults: Vec<_> = self
-            .configs
-            .entries()
-            .iter()
+        let defaults: Vec<_> = (self.configs.entries().iter())
            .map(|(id, e)| (id.clone(), e.default.clone()))
            .collect();
        for (id, value) in defaults {
            self.set(&id, value);
        }
    }
+}

-    /// The pointer lets go.
-    pub fn release(&mut self) {
-        self.scroll.release();
-        self.dragging = None;
+impl shell::Screen for PackOptionsScreen {
+    type Page = u16;
+    type Row = Item;
+    fn title(&self) -> &'static str {
+        TITLE
    }
-
-    /// The mouse wheel scrolls the list.
-    pub fn scroll(&mut self, (w, h): (f32, f32), amount: f32) {
-        let (cols, _, content) = self.layout(w, h);
-        self.scroll
-            .wheel(amount, 18.0, cols.top, cols.bottom, content);
+    fn note_lines(&self) -> usize {
+        NOTE_LINES
+    }
+    /// The rows read only the screen's own entries, which change through it alone.
+    fn stamp(&self, _s: &Settings) -> u64 {
+        self.revision
+    }
+    /// A page per section; the first starts with the rows for the whole pack.
+    fn sheets(&self, _s: &Settings) -> Vec<Sheet<u16, Item>> {
+        let about = lang::get(PACK_SETTINGS);
+        let mut sheets = Vec::new();
+        for (i, (_, entries)) in self.sections.iter().enumerate() {
+            let rows = entries.iter().filter_map(|&e| self.entry_row(e)).collect();
+            let mut groups = vec![Group {
+                name: PACK_OPTIONS,
+                rows,
+            }];
+            if i == 0 {
+                groups.insert(0, self.whole_pack());
+            }
+            sheets.push(Sheet::new(
+                i as u16,
+                self.section_name(i),
+                about.clone(),
+                groups,
+            ));
+        }
+        if sheets.is_empty() {
+            let groups = vec![self.whole_pack()];
+            sheets.push(Sheet::new(0, self.section_name(0), about, groups));
+        }
+        sheets
+    }
+    /// A switch flips, a choice and the presets step (back with Shift, or Left), Reset all
+    /// resets.
+    fn press(&mut self, _s: &mut Settings, item: Item, back: bool) -> Vec<Output> {
+        let i = match item {
+            Item::Presets => {
+                self.cycle_preset(back);
+                return Vec::new();
+            }
+            Item::ResetAll => {
+                self.reset();
+                return Vec::new();
+            }
+            Item::Entry(i) => i,
+        };
+        let Some(id) = self.ids.get(usize::from(i)).cloned() else {
+            return Vec::new();
+        };
+        let kind = self.configs.entries()[&id].kind.clone();
+        match (kind, self.configs.get(&id).cloned()) {
+            (_, Some(ConfigValue::Bool(on))) => self.set(&id, ConfigValue::Bool(!on)),
+            (ConfigKind::Text { allowed }, Some(ConfigValue::Text(t))) if !allowed.is_empty() => {
+                let at = allowed.iter().position(|a| *a == t).unwrap_or(0);
+                let n = allowed.len();
+                let next = if back { (at + n - 1) % n } else { (at + 1) % n };
+                self.set(&id, ConfigValue::Text(allowed[next].clone()));
+            }
+            _ => {}
+        }
+        Vec::new()
+    }
+    /// A slider moves its entry to the step nearest it (`Configs::set` snaps it).
+    fn slide(&mut self, _s: &mut Settings, item: Item, position: f32) {
+        let Item::Entry(i) = item else { return };
+        let Some(id) = self.ids.get(usize::from(i)).cloned() else {
+            return;
+        };
+        if let ConfigKind::Number { min, max, .. } = self.configs.entries()[&id].kind {
+            let value = min + f64::from(position.clamp(0.0, 1.0)) * (max - min);
+            self.set(&id, ConfigValue::Number(value));
+        }
+    }
+    /// With the "Scroll wheel changes settings" extra, the wheel steps a choice and the presets.
+    fn wheel_step(&mut self, s: &mut Settings, item: Item, back: bool) -> Option<Vec<Output>> {
+        let steps = match item {
+            Item::Presets => true,
+            Item::Entry(i) => self
+                .entry_row(i)
+                .is_some_and(|row| matches!(row.value, Value::Choice(_))),
+            Item::ResetAll => false,
+        };
+        if !steps {
+            return None;
+        }
+        let mut outputs = vec![Output::Event(crate::options_ui::Event::ButtonClick)];
+        outputs.extend(self.press(s, item, back));
+        Some(outputs)
+    }
+    fn undoes(&self) -> bool {
+        true
+    }
+    /// The entries as the screen opened with them.
+    fn undo(&mut self, _s: &mut Settings, _before: &Settings) -> Vec<Output> {
+        self.configs = self.opened.clone();
+        self.revision += 1;
+        Vec::new()
+    }
+    /// Undo shows exactly while an entry differs from how the screen opened.
+    fn differs(&self, _s: &Settings, _before: &Settings) -> Option<bool> {
+        Some(self.configs != self.opened)
    }
 }

 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn configs() -> Configs {
-        let mut c = Configs::default();
-        c.add_entry(
-            "p:fog".into(),
-            &serde_json::json!({"default_value": 0.5, "section": "sky", "section_order": 2}),
-        );
-        c.add_entry("p:rain".into(), &serde_json::json!({"default_value": "drops", "allowed_values": ["drops", "streaks"], "section": "weather", "section_order": 1}));
-        c.add_entry(
-            "p:birds".into(),
-            &serde_json::json!({"default_value": true}),
-        );
-        c
-    }
-
-    #[test]
-    fn sections_sort_by_their_order_and_the_unsectioned_last() {
-        let ui = PackOptionsUi::open(configs());
-        let order: Vec<_> = ui.sections.iter().map(|(s, _)| s.as_deref()).collect();
-        assert_eq!(order, [Some("weather"), Some("sky"), None]);
-    }
-
-    #[test]
-    fn rows_switch_cycle_and_slide() {
-        let mut ui = PackOptionsUi::open(configs());
-        let size = (480.0, 270.0);
-        let (cols, lines, _) = ui.layout(size.0, size.1);
-        let ids = ui.ids.clone();
-        let point = |id: &str| {
-            let row = ids.iter().position(|i| i == id).unwrap() as u16;
-            let line = lines.iter().find(|l| l.setting == Some(row)).unwrap();
-            let [x, y, w, h] = cols.row(cols.top + line.y);
-            (x + w - 4.0, y + h / 2.0)
-        };
-        let (birds, rain) = (point("p:birds"), point("p:rain"));
-        ui.click(birds, size, false, false);
-        assert_eq!(ui.configs.get("p:birds"), Some(&ConfigValue::Bool(false)));
-        ui.click(rain, size, false, false);
-        assert_eq!(
-            ui.configs.get("p:rain"),
-            Some(&ConfigValue::Text("streaks".into()))
-        );
-        // The slider's far right end is its maximum.
-        let fog = point("p:fog");
-        let (tx, tw) = cols.track();
-        ui.click((tx + tw, fog.1), size, false, false);
-        ui.release();
-        assert_eq!(ui.configs.get("p:fog"), Some(&ConfigValue::Number(1.0)));
-        assert!(ui.changed);
-        assert_eq!(ui.configs.chosen().len(), 3);
-        ui.reset();
-        assert!(ui.configs.chosen().is_empty());
-    }
-
-    #[test]
-    fn the_presets_row_cycles_the_pack_wide_presets_and_shows_custom_otherwise() {
-        let mut c = Configs::default();
-        let entry = |default: f64, fast: f64, pretty: f64| serde_json::json!({"default_value": default, "presets": {"fast": fast, "pretty": pretty}});
-        c.add_entry("p:fog".into(), &entry(0.5, 0.0, 1.0));
-        c.add_entry("p:dust".into(), &entry(0.5, 0.0, 0.8));
-        let mut ui = PackOptionsUi::open(c);
-        // The defaults are no preset.
-        assert_eq!(ui.current_preset(), None);
-        ui.cycle_preset(false);
-        assert_eq!(ui.current_preset().as_deref(), Some("fast"));
-        assert_eq!(ui.configs.get("p:fog"), Some(&ConfigValue::Number(0.0)));
-        ui.cycle_preset(false);
-        assert_eq!(ui.current_preset().as_deref(), Some("pretty"));
-        ui.cycle_preset(true);
-        assert_eq!(ui.current_preset().as_deref(), Some("fast"));
-        // One value off the preset: custom again.
-        ui.set("p:dust", ConfigValue::Number(0.3));
-        assert_eq!(ui.current_preset(), None);
-        assert!(ui.changed);
-    }
-}
+mod tests;
@@ -0,0 +1,281 @@
+use super::*;
+use crate::options_ui::Event;
+use crate::settings_shell::{Columns, Hosted, Screen as _, Shell, Target};
+use winit::keyboard::KeyCode as K;
+
+const SIZE: (f32, f32) = (854.0, 480.0);
+
+/// Fog (a number) under Sky, rain (a list of values) under Weather, birds (a boolean) in no
+/// section.
+fn configs() -> Configs {
+    let mut c = Configs::default();
+    c.add_entry(
+        "p:fog".into(),
+        &serde_json::json!({"default_value": 0.5, "section": "sky", "section_order": 2}),
+    );
+    c.add_entry("p:rain".into(), &serde_json::json!({"default_value": "drops", "allowed_values": ["drops", "streaks"], "section": "weather", "section_order": 1}));
+    c.add_entry(
+        "p:birds".into(),
+        &serde_json::json!({"default_value": true}),
+    );
+    c
+}
+
+/// Two entries with the pack-wide presets `fast` and `pretty`.
+fn with_presets() -> Configs {
+    let mut c = Configs::default();
+    let entry = |default: f64, fast: f64, pretty: f64| serde_json::json!({"default_value": default, "presets": {"fast": fast, "pretty": pretty}});
+    c.add_entry("p:fog".into(), &entry(0.5, 0.0, 1.0));
+    c.add_entry("p:dust".into(), &entry(0.5, 0.0, 0.8));
+    c
+}
+
+fn shell_of(configs: Configs) -> Shell<PackOptionsScreen> {
+    let mut shell = Shell::default();
+    shell.screen = PackOptionsScreen::open(configs);
+    shell
+}
+
+/// The row of entry `id`, and the page it is on.
+fn entry(shell: &Shell<PackOptionsScreen>, id: &str) -> (u16, Item) {
+    let i = shell.screen.ids.iter().position(|e| e == id).unwrap() as u16;
+    let page = shell.screen.sections.iter().position(|s| s.1.contains(&i));
+    (page.unwrap() as u16, Item::Entry(i))
+}
+
+fn press(shell: &mut Shell<PackOptionsScreen>, s: &mut Settings, item: Item) -> Vec<Output> {
+    let at = shell.point_at(s, SIZE, item);
+    shell.click(s, at, SIZE, false, false, false)
+}
+
+fn value<'a>(shell: &'a Shell<PackOptionsScreen>, id: &str) -> Option<&'a ConfigValue> {
+    shell.screen.configs.get(id)
+}
+
+#[test]
+fn sections_sort_by_their_order_and_the_unsectioned_last() {
+    let screen = PackOptionsScreen::open(configs());
+    let order: Vec<_> = screen.sections.iter().map(|(s, _)| s.as_deref()).collect();
+    assert_eq!(order, [Some("weather"), Some("sky"), None]);
+    // Each section is a page, the first one holding Reset all before its entries.
+    let sheets = screen.sheets(&Settings::default());
+    let names: Vec<_> = sheets.iter().map(|p| p.name.as_str()).collect();
+    assert_eq!(names, ["Weather", "Sky", "horizon.pack.options.general"]);
+    let first: Vec<Vec<Item>> = (sheets[0].groups.iter())
+        .map(|g| g.rows.iter().map(|r| r.id).collect())
+        .collect();
+    let rain = screen.ids.iter().position(|e| e == "p:rain").unwrap() as u16;
+    assert_eq!(first, [vec![Item::ResetAll], vec![Item::Entry(rain)]]);
+}
+
+#[test]
+fn rows_switch_cycle_and_slide() {
+    let mut s = Settings::default();
+    let mut shell = shell_of(configs());
+    let (page, birds) = entry(&shell, "p:birds");
+    shell.show(page);
+    assert_eq!(
+        press(&mut shell, &mut s, birds)[0],
+        Output::Event(Event::ButtonClick)
+    );
+    assert_eq!(value(&shell, "p:birds"), Some(&ConfigValue::Bool(false)));
+    let (page, rain) = entry(&shell, "p:rain");
+    shell.show(page);
+    press(&mut shell, &mut s, rain);
+    let streaks = ConfigValue::Text("streaks".into());
+    assert_eq!(value(&shell, "p:rain"), Some(&streaks));
+    // The slider's far right end is its maximum.
+    let (page, fog) = entry(&shell, "p:fog");
+    shell.show(page);
+    let at = shell.point_at(&s, SIZE, fog);
+    let (track, width) = Columns::of(SIZE.0, SIZE.1).track();
+    shell.click(&mut s, (track + width, at.1), SIZE, false, false, false);
+    shell.release();
+    assert_eq!(value(&shell, "p:fog"), Some(&ConfigValue::Number(1.0)));
+    assert_eq!(shell.screen.configs.chosen().len(), 3);
+    // Reset all, on the first page, puts them all back, and is greyed once they are.
+    shell.show(0);
+    press(&mut shell, &mut s, Item::ResetAll);
+    assert!(shell.screen.configs.chosen().is_empty());
+    let sheets = shell.screen.sheets(&s);
+    assert!(!sheets[0].groups[0].rows[0].live);
+}
+
+#[test]
+fn the_presets_row_cycles_the_pack_wide_presets_and_shows_custom_otherwise() {
+    let mut screen = PackOptionsScreen::open(with_presets());
+    // The defaults are no preset.
+    assert_eq!(screen.current_preset(), None);
+    screen.cycle_preset(false);
+    assert_eq!(screen.current_preset().as_deref(), Some("fast"));
+    assert_eq!(screen.configs.get("p:fog"), Some(&ConfigValue::Number(0.0)));
+    screen.cycle_preset(false);
+    assert_eq!(screen.current_preset().as_deref(), Some("pretty"));
+    screen.cycle_preset(true);
+    assert_eq!(screen.current_preset().as_deref(), Some("fast"));
+    // One value off the preset: custom again.
+    screen.set("p:dust", ConfigValue::Number(0.3));
+    assert_eq!(screen.current_preset(), None);
+    let presets = &screen.sheets(&Settings::default())[0].groups[0].rows[0];
+    assert_eq!(presets.id, Item::Presets);
+    let custom = lang::get("horizon.pack.options.presets.custom");
+    assert_eq!(presets.value, Value::Choice(custom));
+}
+
+#[test]
+fn left_and_right_step_the_presets() {
+    let mut s = Settings::default();
+    let mut shell = shell_of(with_presets());
+    shell.set_focus(Some(Target::Row(Item::Presets)));
+    shell.key(&mut s, K::ArrowRight, None, false, SIZE);
+    assert_eq!(shell.screen.current_preset().as_deref(), Some("fast"));
+    shell.key(&mut s, K::ArrowRight, None, false, SIZE);
+    assert_eq!(shell.screen.current_preset().as_deref(), Some("pretty"));
+    shell.key(&mut s, K::ArrowLeft, None, false, SIZE);
+    assert_eq!(shell.screen.current_preset().as_deref(), Some("fast"));
+    assert_eq!(shell.focused_row(), Some(Item::Presets));
+}
+
+#[test]
+fn sliders_stop_at_the_entrys_step() {
+    let mut c = Configs::default();
+    let json = serde_json::json!({"default_value": 4.0, "min": 0.0, "max": 10.0, "step": 2.0});
+    c.add_entry("p:clouds".into(), &json);
+    let mut s = Settings::default();
+    let mut shell = shell_of(c);
+    let row = &shell.screen.sheets(&s)[0].groups[1].rows[0];
+    let stops = Value::Slider {
+        position: 0.4,
+        steps: Some(5),
+        text: "4".into(),
+    };
+    assert_eq!(row.value, stops);
+    // A press a little past the middle of the track lands on the step nearest it.
+    let at = shell.point_at(&s, SIZE, Item::Entry(0));
+    let (track, width) = Columns::of(SIZE.0, SIZE.1).track();
+    shell.click(
+        &mut s,
+        (track + width * 0.55, at.1),
+        SIZE,
+        false,
+        false,
+        false,
+    );
+    shell.release();
+    assert_eq!(value(&shell, "p:clouds"), Some(&ConfigValue::Number(6.0)));
+    // Held by the press, Right goes one step on and Left one back.
+    shell.set_focus(Some(Target::Row(Item::Entry(0))));
+    shell.key(&mut s, K::ArrowRight, None, false, SIZE);
+    assert_eq!(value(&shell, "p:clouds"), Some(&ConfigValue::Number(8.0)));
+    shell.key(&mut s, K::ArrowLeft, None, false, SIZE);
+    shell.key(&mut s, K::ArrowLeft, None, false, SIZE);
+    assert_eq!(value(&shell, "p:clouds"), Some(&ConfigValue::Number(4.0)));
+}
+
+/// A language with the pack's own strings: a name, a section and a tooltip.
+struct PackLang;
+impl lang::ResourceSource for PackLang {
+    fn read(&self, path: &str) -> Option<Vec<u8>> {
+        (path == "assets/minecraft/lang/en_us.json").then(|| {
+            let strings = serde_json::json!({
+                "config.minecraft.haze": "Haze",
+                "config.minecraft.haze.tooltip": "Thickens the distant air.",
+                "config.minecraft.section.sky": "Sky and fog",
+            });
+            serde_json::to_vec(&strings).unwrap()
+        })
+    }
+}
+
+fn haze() -> Configs {
+    let mut c = configs();
+    let json =
+        serde_json::json!({"default_value": false, "section": "sky", "performance_impact": "high"});
+    c.add_entry("minecraft:haze".into(), &json);
+    c
+}
+
+#[test]
+fn the_search_finds_an_entry_by_its_tooltip_and_the_strip_has_its_impact() {
+    let language = lang::Language::load(&[&PackLang], "en_us");
+    lang::scoped(language, || {
+        let s = Settings::default();
+        let mut shell = shell_of(haze());
+        let (page, haze) = entry(&shell, "minecraft:haze");
+        shell.set_search("distant air");
+        assert_eq!(shell.listed(&s, SIZE), [(page, haze)]);
+        let sheets = shell.screen.sheets(&s);
+        assert_eq!(sheets[usize::from(page)].name, "Sky and fog");
+        let row = sheets.iter().flat_map(|p| &p.groups).flat_map(|g| &g.rows);
+        let row = row.into_iter().find(|r| r.id == haze).unwrap();
+        assert_eq!(row.name, "Haze");
+        assert_eq!(
+            row.about,
+            "Thickens the distant air. Performance impact: high"
+        );
+    });
+}
+
+#[test]
+fn tab_reaches_every_row_of_every_page() {
+    let mut s = Settings::default();
+    let mut shell = shell_of(haze());
+    let pages = shell.screen.sheets(&s).len() as u16;
+    let mut seen = Vec::new();
+    for page in 0..pages {
+        shell.show(page);
+        shell.set_focus(None);
+        for _ in 0..8 {
+            shell.key(&mut s, K::Tab, None, false, SIZE);
+            if let Some(row) = shell.focused_row()
+                && !seen.contains(&row)
+            {
+                seen.push(row);
+            }
+        }
+    }
+    // Reset all is greyed at the defaults; every entry is reached.
+    let mut entries: Vec<Item> = (0..shell.screen.ids.len() as u16)
+        .map(Item::Entry)
+        .collect();
+    seen.sort_by_key(|item| format!("{item:?}"));
+    entries.sort_by_key(|item| format!("{item:?}"));
+    assert_eq!(seen, entries);
+}
+
+#[test]
+fn undo_puts_the_entries_back_and_then_leaving_sends_nothing() {
+    let mut s = Settings::default();
+    let mut shell = shell_of(configs());
+    let (page, birds) = entry(&shell, "p:birds");
+    shell.show(page);
+    press(&mut shell, &mut s, birds);
+    assert!(shell.foot_at(&s, SIZE).iter().any(|f| f.0 == Target::Undo));
+    assert!(shell.screen.finished().is_some());
+    let undo = shell
+        .foot_at(&s, SIZE)
+        .into_iter()
+        .find(|f| f.0 == Target::Undo);
+    let [x, y, w, h] = undo.unwrap().1;
+    shell.click(
+        &mut s,
+        (x + w / 2.0, y + h / 2.0),
+        SIZE,
+        false,
+        false,
+        false,
+    );
+    assert_eq!(value(&shell, "p:birds"), Some(&ConfigValue::Bool(true)));
+    assert!(!shell.foot_at(&s, SIZE).iter().any(|f| f.0 == Target::Undo));
+    assert_eq!(shell.screen.finished(), None);
+    // Stepped there and back by hand, it sends nothing either.
+    press(&mut shell, &mut s, birds);
+    press(&mut shell, &mut s, birds);
+    assert_eq!(shell.screen.finished(), None);
+    press(&mut shell, &mut s, birds);
+    let Some(Event::PackOptions { entries, chosen }) = shell.screen.finished() else {
+        panic!("a change is sent");
+    };
+    assert_eq!(entries.len(), 3);
+    assert_eq!(chosen.get("p:birds"), Some(&ConfigValue::Bool(false)));
+}
@@ -468,17 +468,20 @@ fn read_meta(source: &Source) -> Option<serde_json::Value> {
 /// file with a comment after the closing brace. Gson reads past a UTF-8 byte order mark;
 /// serde_json rejects it.
 pub(crate) fn parse_meta(bytes: &[u8]) -> Option<serde_json::Value> {
-    first_json(bytes)
+    first_json(bytes).ok()
 }
-
-/// Reads the first JSON value from resource metadata, matching Gson's
-/// `JsonReader` (which ignores a trailing signature or comment). Resource
-/// packs commonly append such text to texture metadata as well as pack.mcmeta.
-pub(crate) fn first_json(bytes: &[u8]) -> Option<serde_json::Value> {
-    serde_json::Deserializer::from_slice(bytes.strip_prefix(b"\xEF\xBB\xBF").unwrap_or(bytes))
+/// The first JSON value of a `.mcmeta` file, as `ResourceMetadata.fromJsonStream` reads it:
+/// Gson's `TypeAdapter.read` stops after the value, so text after it (packs leave `//` notes
+/// there) is never read, and a UTF-8 byte order mark is skipped.
+pub(crate) fn first_json<T: serde::de::DeserializeOwned>(bytes: &[u8]) -> serde_json::Result<T> {
+    let bytes = bytes.strip_prefix(b"\xEF\xBB\xBF").unwrap_or(bytes);
+    match serde_json::Deserializer::from_slice(bytes)
        .into_iter()
-        .next()?
-        .ok()
+        .next()
+    {
+        Some(value) => value,
+        None => Err(serde::de::Error::custom("empty metadata")),
+    }
 }
 /// A pack's Polytone config entries (`assets/<namespace>/polytone/config_entries/<name>.json`,
 /// in the pack's base, not its overlays) at their default values.
@@ -827,13 +830,6 @@ fn build_overlay_uncached(
    }
    // Vanilla sits below every pack, so filters hide its files too.
    let filters: Vec<&Filter> = packs.iter().flat_map(|p| &p.filter).collect();
-    let touched_dirs: BTreeSet<String> = files
-        .keys()
-        .flat_map(|f| {
-            let parts: Vec<&str> = f.split('/').collect();
-            (1..parts.len()).map(move |n| parts[..n].join("/"))
-        })
-        .collect();
    let zips: Vec<Option<Zip>> = packs
        .iter()
        .map(|p| {
@@ -882,6 +878,21 @@ fn build_overlay_uncached(
            merged.insert(name.clone(), bytes);
        }
    }
+    add_sprite_renames(
+        vanilla,
+        &merged,
+        &filters,
+        &mut files,
+        &mut hidden,
+        dependencies,
+    );
+    let touched_dirs: BTreeSet<String> = files
+        .keys()
+        .flat_map(|f| {
+            let parts: Vec<&str> = f.split('/').collect();
+            (1..parts.len()).map(move |n| parts[..n].join("/"))
+        })
+        .collect();
    /// A zip entry to write: its pack, its name in the zip and where it goes.
    type Extract<'a> = (usize, &'a str, PathBuf);
    #[allow(clippy::too_many_arguments)]
@@ -1032,6 +1043,123 @@ fn build_overlay_uncached(
    }
    extracted
 }
+/// `SingleFile` with a `sprite`: the atlas holds the resource's pixels, and the resource's
+/// `.mcmeta`, under the sprite's id. Every other sprite of the blocks and items atlases is its
+/// texture's own id, and the loaders read a model's sprite from `textures/<sprite>.png`, so the
+/// overlay gives a renamed sprite that file. ItemsAdder and Nexo packs name their models'
+/// textures only through these renames (#14485).
+///
+/// A sprite gets its resource's file only when the whole source list, in order, ends on the
+/// rename (`SpriteSourceList.list`: a later source of the same id replaces it), when the other
+/// atlas, which reads the same file, lists it from that resource too or not at all, and when it
+/// has no texture of its own. A texture that is there may be read as itself (another source's
+/// resource, an unstitched or paletted sprite's input), so no alias ever replaces one; such a
+/// sprite draws its own texture, as before aliases.
+fn add_sprite_renames(
+    vanilla: &Path,
+    merged: &BTreeMap<String, Vec<u8>>,
+    filters: &[&Filter],
+    files: &mut BTreeMap<String, (usize, Provided)>,
+    hidden: &mut BTreeSet<String>,
+    dependencies: &mut cache::Dependencies,
+) {
+    use crate::atlas_sources::{
+        SpriteOrigin, SpriteSource, decode, list, list_textures, texture_path,
+    };
+    let png = |id: &str| {
+        texture_path(Path::new(""), id, "textures")
+            .to_string_lossy()
+            .replace('\\', "/")
+    };
+    let atlases: Vec<_> = ["blocks", "items"]
+        .into_iter()
+        .filter_map(|atlas| merged.get(&format!("assets/minecraft/atlases/{atlas}.json")))
+        .filter_map(|bytes| decode(std::str::from_utf8(bytes).ok()?))
+        .collect();
+    let renamed = |source: &SpriteSource| matches!(source, SpriteSource::Single { resource, sprite: Some(sprite) } if sprite != resource);
+    if !atlases.iter().flatten().any(renamed) {
+        return;
+    }
+    // The textures a source can list: the packs' and vanilla's the packs leave visible.
+    let mut textures: Vec<String> = list_textures(vanilla)
+        .into_iter()
+        .filter(|id| {
+            let name = png(id);
+            !hidden.contains(&name) && !filters.iter().any(|f| f.blocks(&name))
+        })
+        .chain(files.keys().filter_map(|name| {
+            let (namespace, rest) = name.strip_prefix("assets/")?.split_once('/')?;
+            let path = rest.strip_prefix("textures/")?.strip_suffix(".png")?;
+            Some(format!("{namespace}:{path}"))
+        }))
+        .collect();
+    textures.sort();
+    textures.dedup();
+    // Each sprite's resource, `None` where an atlas lists it any other way.
+    let mut renames: BTreeMap<String, Option<String>> = BTreeMap::new();
+    for sources in &atlases {
+        for (sprite, origin) in list(sources, &textures) {
+            let from = match origin {
+                SpriteOrigin::File(resource) if resource != sprite => Some(resource),
+                _ => None,
+            };
+            renames
+                .entry(sprite)
+                .and_modify(|seen| {
+                    if *seen != from {
+                        *seen = None;
+                    }
+                })
+                .or_insert(from);
+        }
+    }
+    let renames = renames
+        .into_iter()
+        .filter(|(sprite, _)| textures.binary_search(sprite).is_err())
+        .filter_map(|(sprite, resource)| Some((png(&resource?), png(&sprite))));
+    // Each resource is the file the packs give, never another rename's sprite.
+    let mut found = Vec::new();
+    for (from, to) in renames {
+        // `texture_path` names an id that would leave the root as a file that is never there.
+        if !stays_inside(&from) || !stays_inside(&to) {
+            continue;
+        }
+        let from_meta = format!("{from}.mcmeta");
+        // A pack's texture with its own `.mcmeta`, or vanilla's below every pack.
+        let (file, meta) = match files.get(&from) {
+            Some(file) => (file.clone(), files.get(&from_meta).cloned()),
+            None => {
+                let (path, meta_path) = (vanilla.join(&from), vanilla.join(&from_meta));
+                dependencies.file(&path);
+                dependencies.file(&meta_path);
+                if !path.is_file() || filters.iter().any(|f| f.blocks(&from)) {
+                    continue;
+                }
+                // `createStackMetadataFinder`: a pack's filter hides vanilla's `.mcmeta` too.
+                let meta = files.get(&from_meta).cloned().or_else(|| {
+                    (meta_path.is_file() && !filters.iter().any(|f| f.blocks(&from_meta)))
+                        .then(|| (0, (Some(meta_path), from_meta.clone())))
+                });
+                ((0, (Some(path), from.clone())), meta)
+            }
+        };
+        found.push((to, file, meta));
+    }
+    for (to, file, meta) in found {
+        let to_meta = format!("{to}.mcmeta");
+        files.insert(to, file);
+        match meta {
+            Some(meta) => {
+                hidden.remove(&to_meta);
+                files.insert(to_meta, meta);
+            }
+            None => {
+                files.remove(&to_meta);
+                hidden.insert(to_meta);
+            }
+        }
+    }
+}
 /// The most the zip packs in `packs` may unpack to in one overlay: 16 times their size on disk
 /// (real packs are mostly PNGs and JSON, a few times smaller zipped at most), at least 64 MiB
 /// for a small pack of text, and never past 8 GiB.
@@ -1906,6 +2034,94 @@ mod tests {
        let _ = fs::remove_dir_all(base);
    }
    #[test]
+    fn a_renamed_atlas_sprite_reads_its_resource() {
+        let base =
+            std::env::temp_dir().join(format!("horizon-sprite-rename-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&base);
+        let write = |path: PathBuf, bytes: &[u8]| {
+            fs::create_dir_all(path.parent().unwrap()).unwrap();
+            fs::write(path, bytes).unwrap();
+        };
+        let vanilla = base.join("vanilla");
+        let textures = vanilla.join("assets/minecraft/textures");
+        let animation = b"{\"animation\":{}}";
+        write(textures.join("block/sea_lantern.png"), b"lantern");
+        write(textures.join("block/sea_lantern.png.mcmeta"), animation);
+        write(textures.join("item/stick.png"), b"vanilla stick");
+        write(textures.join("item/stick.png.mcmeta"), animation);
+        let meta = br#"{"pack":{"description":"d","pack_format":97}}"#;
+        let pack = base.join("packs/IA");
+        write(pack.join("pack.mcmeta"), meta);
+        write(pack.join("assets/iageneric/textures/item/box.png"), b"box");
+        // An ItemsAdder pack's items atlas: its models name only the `ia:` sprites.
+        write(
+            pack.join("assets/minecraft/atlases/items.json"),
+            br#"{"sources":[
+                {"type":"single","resource":"iageneric:item/box","sprite":"ia:0"},
+                {"type":"single","resource":"minecraft:block/sea_lantern","sprite":"ia:1199"},
+                {"type":"single","resource":"iageneric:item/box","sprite":"minecraft:item/stick"},
+                {"type":"single","resource":"minecraft:item/stick","sprite":"ia:3"},
+                {"type":"single","resource":"iageneric:item/gone","sprite":"ia:2"},
+                {"type":"single","resource":"iageneric:item/box","sprite":"ia:../../../escape"},
+                {"type":"single","resource":"iageneric:item/box","sprite":"ia:7"},
+                {"type":"single","resource":"iageneric:item/box","sprite":"ia:8"},
+                {"type":"single","resource":"iageneric:item/box","sprite":"ia:9"}
+            ]}"#,
+        );
+        // A pack above it: later sources of three of those sprites, a blocks atlas that
+        // disagrees about another, and a filter hiding vanilla's animation of the stick.
+        let higher = base.join("packs/Top");
+        write(
+            higher.join("pack.mcmeta"),
+            br#"{"pack":{"description":"d","pack_format":97},
+                "filter":{"block":[{"path":"textures/item/stick\\.png\\.mcmeta"}]}}"#,
+        );
+        write(
+            higher.join("assets/minecraft/atlases/items.json"),
+            br#"{"sources":[
+                {"type":"single","resource":"minecraft:block/sea_lantern","sprite":"ia:8"},
+                {"type":"filter","pattern":{"namespace":"ia","path":"7"}}
+            ]}"#,
+        );
+        write(
+            higher.join("assets/minecraft/atlases/blocks.json"),
+            br#"{"sources":[
+                {"type":"single","resource":"minecraft:block/sea_lantern","sprite":"ia:9"}
+            ]}"#,
+        );
+        let packs = discover(&vanilla, &base.join("packs"));
+        let out = base.join("overlay");
+        build_overlay(&vanilla, &packs, &out).unwrap();
+        let read = |rel: &str| fs::read(out.join(rel)).ok();
+        let texture = |id: &str| read(&format!("assets/ia/textures/{id}.png"));
+        assert_eq!(texture("0").as_deref(), Some(&b"box"[..]));
+        assert_eq!(read("assets/ia/textures/0.png.mcmeta"), None);
+        // A vanilla resource comes with its animation.
+        assert_eq!(texture("1199").as_deref(), Some(&b"lantern"[..]));
+        assert_eq!(
+            read("assets/ia/textures/1199.png.mcmeta").as_deref(),
+            Some(&animation[..])
+        );
+        // A texture that is there stays itself: other sources may read it (here as `ia:3`'s
+        // resource; an unstitched or paletted sprite's input alike).
+        assert_eq!(
+            read("assets/minecraft/textures/item/stick.png").as_deref(),
+            Some(&b"vanilla stick"[..])
+        );
+        // ...with its `.mcmeta` only where no filter hides it.
+        assert_eq!(texture("3").as_deref(), Some(&b"vanilla stick"[..]));
+        assert_eq!(read("assets/ia/textures/3.png.mcmeta"), None);
+        // A missing resource adds nothing, and no rename leaves the overlay.
+        assert_eq!(texture("2"), None);
+        assert!(!out.join("escape.png").exists());
+        // The last source of a sprite wins: a filter drops it, a later rename replaces it.
+        assert_eq!(texture("7"), None);
+        assert_eq!(texture("8").as_deref(), Some(&b"lantern"[..]));
+        // The two atlases read one file, and disagree about `ia:9`: it gets neither.
+        assert_eq!(texture("9"), None);
+        let _ = fs::remove_dir_all(base);
+    }
+    #[test]
    fn every_file_of_a_big_stack_comes_from_its_top_pack() {
        use std::io::Write as _;
        let base = std::env::temp_dir().join(format!("horizon-pack-stack-{}", std::process::id()));
@@ -13,7 +13,8 @@ use std::{collections::BTreeSet, fs, io, path::Path, path::PathBuf};
 // Version 5 read every vanilla file to stamp it on Windows.
 // Version 6 stamps vanilla's files by their metadata on Windows too.
 // Version 7 stacks blockstate files (every pack's definition, bottom first).
-const VERSION: u32 = 8;
+// Version 8 left an atlas `single` source's renamed sprite without its texture file (#14485).
+const VERSION: u32 = 9;

 #[derive(Default, Serialize, Deserialize)]
 pub(super) struct Dependencies {
@@ -1402,100 +1402,8 @@ impl ParticleLightCache {
    }
 }

-const PARTICLE_SECTION_CACHE_SIZE: usize = 128;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum SectionFrustumResult {
-    Outside,
-    Intersects,
-    Inside,
-}
-
-#[derive(Clone, Copy)]
-struct CachedSectionFrustum {
-    section: [i32; 3],
-    radius_quarters: i32,
-    result: SectionFrustumResult,
-}
-
-struct ParticleSectionFrustumCache {
-    entries: [Option<CachedSectionFrustum>; PARTICLE_SECTION_CACHE_SIZE],
-}
-
-impl Default for ParticleSectionFrustumCache {
-    fn default() -> Self {
-        Self {
-            entries: [None; PARTICLE_SECTION_CACHE_SIZE],
-        }
-    }
-}
-
-impl ParticleSectionFrustumCache {
-    fn result(
-        &mut self,
-        world: [f64; 3],
-        camera: DVec3,
-        radius: f64,
-        frustum: &crate::gfx::Frustum,
-    ) -> SectionFrustumResult {
-        let Some(section) = world_section(world) else {
-            return SectionFrustumResult::Intersects;
-        };
-        if !radius.is_finite() || radius < 0.0 || radius * 4.0 > f64::from(i32::MAX) {
-            return SectionFrustumResult::Intersects;
-        }
-        let radius_quarters = (radius * 4.0).ceil() as i32;
-        let hash = (section[0] as u32).wrapping_mul(73_856_093)
-            ^ (section[1] as u32).wrapping_mul(19_349_663)
-            ^ (section[2] as u32).wrapping_mul(83_492_791)
-            ^ (radius_quarters as u32).wrapping_mul(2_654_435_761);
-        let slot = hash as usize & (PARTICLE_SECTION_CACHE_SIZE - 1);
-        if let Some(entry) = self.entries[slot]
-            && entry.section == section
-            && entry.radius_quarters == radius_quarters
-        {
-            return entry.result;
-        }
-
-        let pad = f64::from(radius_quarters) * 0.25;
-        let camera = camera.to_array();
-        let min = array::from_fn(|axis| f64::from(section[axis]) * 16.0 - pad - camera[axis]);
-        let max = array::from_fn(|axis| min[axis] + 16.0 + 2.0 * pad);
-        let result = if min.into_iter().chain(max).any(|v| !v.is_finite()) {
-            SectionFrustumResult::Intersects
-        } else {
-            let min = FVec3::from_array(min.map(|v| v as f32));
-            let max = FVec3::from_array(max.map(|v| v as f32));
-            if !min.is_finite() || !max.is_finite() {
-                SectionFrustumResult::Intersects
-            } else if frustum.contains(min, max) {
-                SectionFrustumResult::Inside
-            } else if frustum.intersects(min, max) {
-                SectionFrustumResult::Intersects
-            } else {
-                SectionFrustumResult::Outside
-            }
-        };
-        self.entries[slot] = Some(CachedSectionFrustum {
-            section,
-            radius_quarters,
-            result,
-        });
-        result
-    }
-}
-
-fn world_section(position: [f64; 3]) -> Option<[i32; 3]> {
-    let mut block = [0; 3];
-    for axis in 0..3 {
-        let value = position[axis].floor();
-        if !value.is_finite() || value < f64::from(i32::MIN) || value > f64::from(i32::MAX) {
-            return None;
-        }
-        block[axis] = value as i32;
-    }
-    Some([block[0] >> 4, block[1] >> 4, block[2] >> 4])
-}
+mod view_cull;
+use view_cull::{PARTICLE_FRUSTUM_OFFSET, ParticleSectionFrustumCache, SectionFrustumResult};

 fn below_half_pixel(radius: f64, distance_squared: f64, pixel_focal_length: f32) -> bool {
    let projected_limit = 4.0 * radius * f64::from(pixel_focal_length);
@@ -4703,16 +4611,7 @@ impl ParticleEngine {
        light_at: &dyn Fn([i32; 3]) -> u8,
        out: &mut Vec<Vertex>,
    ) {
-        self.render_inner::<false>(
-            camera,
-            base,
-            partial,
-            0.0,
-            None,
-            &mut |_, _| false,
-            light_at,
-            out,
-        );
+        self.render_in_view(camera, base, partial, None, light_at, out);
    }

    /// Render particles after rejecting view-frustum misses and any particles
@@ -4730,7 +4629,7 @@ impl ParticleEngine {
        out: &mut Vec<Vertex>,
    ) {
        if !culling_enabled {
-            self.render(camera, base, partial, light_at, out);
+            self.render_in_view(camera, base, partial, frustum, light_at, out);
            return;
        }
        self.render_inner::<true>(
@@ -4761,10 +4660,16 @@ impl ParticleEngine {
        additive.clear();
        let mut section_cache =
            (CULL && frustum.is_some()).then(ParticleSectionFrustumCache::default);
+        let view = frustum.map(|f| f.pulled_back(PARTICLE_FRUSTUM_OFFSET));
        for p in &self.particles {
            if p.no_render {
                continue;
            }
+            if let Some(view) = &view
+                && !view_cull::in_view(view, p, camera)
+            {
+                continue;
+            }
            // SparkParticle.extract: twinkling sparks blink after a third of their life.
            if let Behaviour::Spark { twinkle: true, .. } = p.behaviour
                && p.age >= p.lifetime / 3
@@ -5199,6 +5104,115 @@ mod tests {
        assert_eq!(attributes(&disabled), attributes(&regular));
    }

+    /// An engine whose smoke particles stand at `positions`, camera-relative (the camera is at
+    /// the origin looking down -z, like `Mat4::IDENTITY` as a view).
+    fn smoke_at(positions: &[[f64; 3]]) -> ParticleEngine {
+        let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
+        let sprite = "test:smoke".to_owned();
+        engine.atlas.insert(
+            sprite.clone(),
+            (
+                Rect {
+                    u0: 0.0,
+                    v0: 0.0,
+                    u1: 1.0,
+                    v1: 1.0,
+                    w: 16,
+                    h: 16,
+                },
+                false,
+            ),
+        );
+        let mut random = LegacyRandom::new(7);
+        for &at in positions {
+            let mut particle = Particle::moving(&mut random, ParticleType::Smoke, at, [0.0; 3]);
+            particle.sprite = Sprite::Named(sprite.clone());
+            engine.particles.push(particle);
+        }
+        engine
+    }
+
+    fn quad_vertices(engine: &ParticleEngine, view: Option<&crate::gfx::Frustum>) -> usize {
+        let mut out = Vec::new();
+        engine.render_in_view(DVec3::ZERO, Quat::IDENTITY, 0.5, view, &|_| 0xf0, &mut out);
+        out.len()
+    }
+
+    #[test]
+    fn particles_outside_the_pulled_back_frustum_make_no_quads() {
+        use crate::gfx::{Frustum, world_projection};
+        let view = Frustum::from_view_projection(world_projection(70.0, 16.0 / 9.0, 512.0));
+        let kept = [
+            [0.0, 0.0, -5.0],   // straight ahead
+            [0.0, 0.0, 2.5],    // behind the camera, inside the 3 blocks of offset
+            [0.0, 0.0, -300.0], // far, inside the far plane
+        ];
+        let dropped = [
+            [0.0, 0.0, 10.0],   // well behind the camera
+            [0.0, 0.0, 3.5],    // just past the offset
+            [100.0, 0.0, -5.0], // far to the side
+            [0.0, 60.0, -5.0],  // far above
+            [0.0, 0.0, -600.0], // beyond the far plane
+        ];
+        let all: Vec<_> = kept.iter().chain(&dropped).copied().collect();
+        let engine = smoke_at(&all);
+        let only_kept = quad_vertices(&smoke_at(&kept), None);
+        assert!(only_kept > 0);
+        assert_eq!(quad_vertices(&engine, Some(&view)), only_kept);
+        // Without a view every particle is drawn, as before.
+        assert_eq!(
+            quad_vertices(&engine, None),
+            only_kept * all.len() / kept.len()
+        );
+        // `render` is the same as no view.
+        let mut regular = Vec::new();
+        engine.render(DVec3::ZERO, Quat::IDENTITY, 0.5, &|_| 0xf0, &mut regular);
+        assert_eq!(regular.len(), quad_vertices(&engine, None));
+    }
+
+    #[test]
+    fn the_culled_path_applies_the_same_frustum_test() {
+        use crate::gfx::{Frustum, world_projection};
+        let view = Frustum::from_view_projection(world_projection(70.0, 16.0 / 9.0, 512.0));
+        let engine = smoke_at(&[[0.0, 0.0, -5.0], [0.0, 0.0, 10.0]]);
+        let mut out = Vec::new();
+        // The disabled setting still keeps vanilla's always-on test.
+        engine.render_culled(
+            DVec3::ZERO,
+            Quat::IDENTITY,
+            0.5,
+            900.0,
+            false,
+            Some(&view),
+            |_, _| panic!("disabled culling must not query particle visibility"),
+            &|_| 0xf0,
+            &mut out,
+        );
+        assert_eq!(
+            out.len(),
+            quad_vertices(&smoke_at(&[[0.0, 0.0, -5.0]]), None)
+        );
+    }
+
+    #[test]
+    fn a_particle_is_tested_at_its_position_this_tick_not_an_interpolated_one() {
+        use crate::gfx::{Frustum, world_projection};
+        let view = Frustum::from_view_projection(world_projection(70.0, 16.0 / 9.0, 512.0));
+        // The frame is drawn half way (0.5) between `previous` and `position`.
+        // Ahead now, far behind a tick ago (half way: 12.5 behind, outside): kept.
+        let mut coming = smoke_at(&[[0.0, 0.0, -5.0]]);
+        coming.particles[0].previous = [0.0, 0.0, 30.0];
+        assert!(quad_vertices(&coming, None) > 0);
+        assert_eq!(
+            quad_vertices(&coming, Some(&view)),
+            quad_vertices(&coming, None)
+        );
+        // Behind now, ahead a tick ago (half way: 5 ahead, inside): dropped.
+        let mut going = smoke_at(&[[0.0, 0.0, 10.0]]);
+        going.particles[0].previous = [0.0, 0.0, -20.0];
+        assert_eq!(quad_vertices(&going, Some(&view)), 0);
+    }
+
    #[test]
    fn quads_face_the_rotation_they_are_given() {
        let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
@@ -0,0 +1,138 @@
+//! The camera's view frustum for particles: vanilla's always-on point test, and the section
+//! cache behind the opt-in Particle Culling setting.
+
+use super::{Particle, ParticleEngine, Vertex};
+use glam::{DVec3, Quat, Vec3 as FVec3};
+use std::array;
+
+const PARTICLE_SECTION_CACHE_SIZE: usize = 128;
+/// How far back, in blocks, the camera's frustum is pulled for the particle test (vanilla's
+/// `Frustum.offset` in `ParticleEngine.extract`).
+pub(super) const PARTICLE_FRUSTUM_OFFSET: f32 = 3.0;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum SectionFrustumResult {
+    Outside,
+    Intersects,
+    Inside,
+}
+
+#[derive(Clone, Copy)]
+struct CachedSectionFrustum {
+    section: [i32; 3],
+    radius_quarters: i32,
+    result: SectionFrustumResult,
+}
+
+pub(super) struct ParticleSectionFrustumCache {
+    entries: [Option<CachedSectionFrustum>; PARTICLE_SECTION_CACHE_SIZE],
+}
+
+impl Default for ParticleSectionFrustumCache {
+    fn default() -> Self {
+        Self {
+            entries: [None; PARTICLE_SECTION_CACHE_SIZE],
+        }
+    }
+}
+
+impl ParticleSectionFrustumCache {
+    pub(super) fn result(
+        &mut self,
+        world: [f64; 3],
+        camera: DVec3,
+        radius: f64,
+        frustum: &crate::gfx::Frustum,
+    ) -> SectionFrustumResult {
+        let Some(section) = world_section(world) else {
+            return SectionFrustumResult::Intersects;
+        };
+        if !radius.is_finite() || radius < 0.0 || radius * 4.0 > f64::from(i32::MAX) {
+            return SectionFrustumResult::Intersects;
+        }
+        let radius_quarters = (radius * 4.0).ceil() as i32;
+        let hash = (section[0] as u32).wrapping_mul(73_856_093)
+            ^ (section[1] as u32).wrapping_mul(19_349_663)
+            ^ (section[2] as u32).wrapping_mul(83_492_791)
+            ^ (radius_quarters as u32).wrapping_mul(2_654_435_761);
+        let slot = hash as usize & (PARTICLE_SECTION_CACHE_SIZE - 1);
+        if let Some(entry) = self.entries[slot]
+            && entry.section == section
+            && entry.radius_quarters == radius_quarters
+        {
+            return entry.result;
+        }
+
+        let pad = f64::from(radius_quarters) * 0.25;
+        let camera = camera.to_array();
+        let min = array::from_fn(|axis| f64::from(section[axis]) * 16.0 - pad - camera[axis]);
+        let max = array::from_fn(|axis| min[axis] + 16.0 + 2.0 * pad);
+        let result = if min.into_iter().chain(max).any(|v| !v.is_finite()) {
+            SectionFrustumResult::Intersects
+        } else {
+            let min = FVec3::from_array(min.map(|v| v as f32));
+            let max = FVec3::from_array(max.map(|v| v as f32));
+            if !min.is_finite() || !max.is_finite() {
+                SectionFrustumResult::Intersects
+            } else if frustum.contains(min, max) {
+                SectionFrustumResult::Inside
+            } else if frustum.intersects(min, max) {
+                SectionFrustumResult::Intersects
+            } else {
+                SectionFrustumResult::Outside
+            }
+        };
+        self.entries[slot] = Some(CachedSectionFrustum {
+            section,
+            radius_quarters,
+            result,
+        });
+        result
+    }
+}
+
+fn world_section(position: [f64; 3]) -> Option<[i32; 3]> {
+    let mut block = [0; 3];
+    for axis in 0..3 {
+        let value = position[axis].floor();
+        if !value.is_finite() || value < f64::from(i32::MIN) || value > f64::from(i32::MAX) {
+            return None;
+        }
+        block[axis] = value as i32;
+    }
+    Some([block[0] >> 4, block[1] >> 4, block[2] >> 4])
+}
+
+/// Whether `QuadParticleGroup`'s test keeps `particle`: its position this tick (camera-relative, not
+/// interpolated) is on or inside `view`, the camera's frustum pulled back [`PARTICLE_FRUSTUM_OFFSET`] blocks.
+pub(super) fn in_view(view: &crate::gfx::Frustum, particle: &Particle, camera: DVec3) -> bool {
+    let at = DVec3::from_array(particle.position) - camera;
+    view.contains_point(at.as_vec3())
+}
+
+impl ParticleEngine {
+    /// [`Self::render`], keeping only the particles inside `view`, the camera's frustum pulled
+    /// back [`PARTICLE_FRUSTUM_OFFSET`] blocks (vanilla's `ParticleEngine.extract` and
+    /// `QuadParticleGroup`): the test runs whatever the Particle Culling setting says. With
+    /// `None`, every particle is drawn.
+    pub fn render_in_view(
+        &self,
+        camera: DVec3,
+        base: Quat,
+        partial: f32,
+        view: Option<&crate::gfx::Frustum>,
+        light_at: &dyn Fn([i32; 3]) -> u8,
+        out: &mut Vec<Vertex>,
+    ) {
+        self.render_inner::<false>(
+            camera,
+            base,
+            partial,
+            0.0,
+            view,
+            &mut |_, _| false,
+            light_at,
+            out,
+        );
+    }
+}
@@ -0,0 +1,406 @@
+//! A stopped sampler session as the capture's `samples` message (docs/perf-platform.md §3.5).
+use std::collections::HashMap;
+
+use horizon_perf_format::Interner;
+use horizon_perf_format::v1::{
+    BlockUnits, Contexts, Functions, Nodes, Overhead, SampleKind, SampleProfile, SampleSource,
+    SampleUnit, SampledThread, Side, Unit, Weights,
+};
+use horizon_threads::heap_sample::HeapProfile;
+use horizon_threads::profile::{Aggregate, Frame, Profile, State, Symbols, symbolize};
+use horizon_threads::work::{self, Space};
+
+#[cfg(test)]
+mod tests;
+
+const UNKNOWN: &str = "[unknown]";
+
+/// The name `work::set_dim` ids stand for: 1 overworld, 2 the nether, 3 the end.
+fn dimension_name(id: u8) -> Option<&'static str> {
+    match id {
+        1 => Some("overworld"),
+        2 => Some("the_nether"),
+        3 => Some("the_end"),
+        _ => None,
+    }
+}
+
+/// The crate a demangled function name belongs to, or "" when it names none.
+fn crate_of(name: &str) -> &str {
+    if let Some(inner) = name.strip_prefix('[') {
+        let module = inner.split([' ', ']']).next().unwrap_or("");
+        return if module == "unmapped" { "" } else { module };
+    }
+    let name = name.trim_start_matches(['<', '&', '*']);
+    let name = name.strip_prefix("dyn ").unwrap_or(name);
+    match name.split_once("::") {
+        Some((krate, _)) if krate.chars().all(|c| c.is_alphanumeric() || c == '_') => krate,
+        _ => "",
+    }
+}
+
+#[derive(Default)]
+struct FunctionTable {
+    rows: Functions,
+    index: HashMap<(u32, u32), u32>,
+    allocator: Vec<bool>,
+}
+
+impl FunctionTable {
+    fn id(
+        &mut self,
+        strings: &mut Interner,
+        name: &str,
+        file: Option<&str>,
+        line: u32,
+        addr: u64,
+    ) -> u32 {
+        let (name_id, file_id) = (
+            strings.intern(name),
+            file.map_or(0, |file| strings.intern(file)),
+        );
+        if let Some(&row) = self.index.get(&(name_id, file_id)) {
+            return row;
+        }
+        let row = self.rows.name.len() as u32;
+        self.rows.name.push(name_id);
+        self.rows.file.push(file_id);
+        self.rows.line.push(line);
+        self.rows.crate_.push(match crate_of(name) {
+            "" => 0,
+            krate => strings.intern(krate),
+        });
+        self.rows.addr.push(addr);
+        self.allocator.push(allocator_frame(name));
+        self.index.insert((name_id, file_id), row);
+        row
+    }
+}
+
+/// The thread each trie node belongs to; node 0 is the root.
+fn thread_of(agg: &Aggregate) -> Vec<u16> {
+    let mut of = vec![0u16; agg.nodes()];
+    for n in 1..agg.nodes() {
+        of[n] = match agg.frame(n as u32) {
+            Frame::Thread(i) => i,
+            _ => of[agg.parent(n as u32) as usize],
+        };
+    }
+    of
+}
+
+/// The trie nodes some counted sample passes through.
+fn live_nodes(agg: &Aggregate) -> Vec<bool> {
+    let mut live = vec![false; agg.nodes()];
+    for key in agg.counts.keys() {
+        let mut n = key.node as usize;
+        while n != 0 && !live[n] {
+            live[n] = true;
+            n = agg.parent(n as u32) as usize;
+        }
+    }
+    live
+}
+
+#[derive(Default)]
+struct NodeTable {
+    rows: Nodes,
+    index: HashMap<(Option<u32>, u32, u16), u32>,
+}
+
+impl NodeTable {
+    fn id(&mut self, parent: Option<u32>, function: u32, thread: u16) -> u32 {
+        let key = (parent, function, if parent.is_none() { thread } else { 0 });
+        if let Some(&row) = self.index.get(&key) {
+            return row;
+        }
+        let nodes = &mut self.rows;
+        nodes.parent.push(parent.unwrap_or(0));
+        nodes.function.push(function);
+        nodes.thread_root.push(match parent {
+            None => u32::from(thread) + 1,
+            Some(_) => 0,
+        });
+        let row = nodes.parent.len() as u32 - 1;
+        self.index.insert(key, row);
+        row
+    }
+}
+
+fn named(strings: &mut Interner, space: Space, id: u16) -> u32 {
+    match id {
+        0 => 0,
+        id => match work::name(space, id) {
+            Some(name) => strings.intern(name),
+            None => strings.intern(&format!("#{id}")),
+        },
+    }
+}
+
+/// Whether `name` is the allocator's own frame, which a heap sample's stack drops from its leaf end.
+fn allocator_frame(name: &str) -> bool {
+    let name = name.trim_start_matches('<');
+    name.starts_with("horizon_threads::heap_sample::")
+        || name.starts_with("__rust")
+        || name.starts_with("__rg_")
+        || name.starts_with("__rdl_")
+        || name.starts_with("alloc::alloc::")
+        || name.starts_with("alloc::raw_vec::")
+        || name.starts_with("mimalloc::")
+}
+
+/// One aggregate's trie nodes as rows of the shared tables: `last[n]` is the output node of trie node `n`.
+fn add_tree(
+    agg: &Aggregate,
+    threads: &[u16],
+    symbols: &Symbols,
+    functions: &mut FunctionTable,
+    nodes: &mut NodeTable,
+    strings: &mut Interner,
+) -> (Vec<u16>, Vec<Option<u32>>) {
+    let (local, live) = (thread_of(agg), live_nodes(agg));
+    let thread_of: Vec<u16> = local
+        .iter()
+        .map(|&t| threads.get(usize::from(t)).copied().unwrap_or(0))
+        .collect();
+    let mut last: Vec<Option<u32>> = vec![None; agg.nodes()];
+    for n in (1..agg.nodes()).filter(|&n| live[n]) {
+        let inherited = last[agg.parent(n as u32) as usize];
+        last[n] = match agg.frame(n as u32) {
+            Frame::Thread(_) => None,
+            Frame::Wall(_) => inherited,
+            Frame::Addr(addr) => {
+                let offset = symbols.module_offset(addr);
+                let mut at = inherited;
+                for sym in symbols.frames(addr).iter().rev() {
+                    let f = functions.id(strings, &sym.name, sym.file.as_deref(), sym.line, offset);
+                    at = Some(nodes.id(at, f, thread_of[n]));
+                }
+                if at == inherited {
+                    let f = functions.id(strings, UNKNOWN, None, 0, offset);
+                    at = Some(nodes.id(at, f, thread_of[n]));
+                }
+                at
+            }
+        };
+    }
+    (thread_of, last)
+}
+
+fn trie_addrs(agg: &Aggregate) -> impl Iterator<Item = u64> + '_ {
+    let live = live_nodes(agg);
+    (1..agg.nodes())
+        .filter(move |&n| live[n])
+        .filter_map(|n| match agg.frame(n as u32) {
+            Frame::Addr(a) => Some(a),
+            _ => None,
+        })
+}
+
+/// `profile` (and the heap session's `heap`) as a `SampleProfile` of `side`; strings go through `strings`, whose new entries the caller appends first.
+pub fn sample_profile(
+    profile: &Profile,
+    heap: Option<&HeapProfile>,
+    side: Side,
+    unit: Unit,
+    block_name: &dyn Fn(u16) -> Option<String>,
+    strings: &mut Interner,
+) -> SampleProfile {
+    let agg = &profile.agg;
+    let addrs: Vec<u64> = trie_addrs(agg)
+        .chain(heap.into_iter().flat_map(|h| trie_addrs(&h.agg)))
+        .collect();
+    let symbols = symbolize(addrs);
+
+    let mut names: Vec<String> = agg.threads.clone();
+    let cpu_threads: Vec<u16> = (0..agg.threads.len() as u16).collect();
+    let heap_threads: Vec<u16> = heap.map_or_else(Vec::new, |h| {
+        h.agg
+            .threads
+            .iter()
+            .map(|name| match names.iter().position(|n| n == name) {
+                Some(at) => at as u16,
+                None => {
+                    names.push(name.clone());
+                    names.len() as u16 - 1
+                }
+            })
+            .collect()
+    });
+
+    let mut functions = FunctionTable::default();
+    let mut nodes = NodeTable::default();
+    let mut trees = vec![(
+        agg,
+        add_tree(
+            agg,
+            &cpu_threads,
+            &symbols,
+            &mut functions,
+            &mut nodes,
+            strings,
+        ),
+    )];
+    if let Some(h) = heap {
+        let tree = add_tree(
+            &h.agg,
+            &heap_threads,
+            &symbols,
+            &mut functions,
+            &mut nodes,
+            strings,
+        );
+        trees.push((&h.agg, tree));
+    }
+
+    let wall = agg.counts.keys().any(|k| k.state != State::Cpu);
+    let period_ms = 1000.0 / f64::from(profile.config.sampler.hz.max(1));
+    let kind = |source: SampleSource, unit: SampleUnit, period: f64| SampleKind {
+        source: source as i32,
+        unit: unit as i32,
+        period,
+    };
+    let mut kinds = vec![kind(SampleSource::Cpu, SampleUnit::Ms, period_ms)];
+    if wall {
+        kinds.push(kind(SampleSource::Wall, SampleUnit::Ms, period_ms));
+    }
+    if heap.is_some() {
+        kinds.push(kind(SampleSource::Alloc, SampleUnit::Bytes, 1.0));
+        kinds.push(kind(SampleSource::Live, SampleUnit::Bytes, 1.0));
+    }
+    let kind_of = |state: State| -> u32 {
+        let source = match state {
+            State::Cpu => SampleSource::Cpu,
+            State::Running | State::Waiting => SampleSource::Wall,
+            State::Alloc => SampleSource::Alloc,
+            State::Live => SampleSource::Live,
+        };
+        kinds
+            .iter()
+            .position(|k| k.source == source as i32)
+            .unwrap_or(0) as u32
+    };
+
+    let mut contexts = Contexts::default();
+    let mut context_ids: HashMap<[u32; 6], u32> = HashMap::new();
+    let mut weights = Weights::default();
+    let mut unknown_roots: HashMap<u16, u32> = HashMap::new();
+    for (agg, (thread_of, last)) in &trees {
+        let mut counted: Vec<_> = agg.counts.iter().collect();
+        counted.sort_by_key(|(k, _)| {
+            (
+                thread_of[k.node as usize],
+                k.node,
+                k.state as u8,
+                k.slow,
+                k.time_block,
+                (k.span, k.entity, k.block, k.dim, k.chunk),
+            )
+        });
+        for (key, &count) in counted {
+            let thread = thread_of[key.node as usize];
+            let mut node = match last[key.node as usize] {
+                Some(node) => node,
+                None => *unknown_roots.entry(thread).or_insert_with(|| {
+                    let f = functions.id(strings, UNKNOWN, None, 0, 0);
+                    nodes.id(None, f, thread)
+                }),
+            };
+            if matches!(key.state, State::Alloc | State::Live) {
+                while nodes.rows.thread_root[node as usize] == 0
+                    && functions.allocator[nodes.rows.function[node as usize] as usize]
+                {
+                    node = nodes.rows.parent[node as usize];
+                }
+            }
+            let row = [
+                named(strings, Space::Span, key.span),
+                named(strings, Space::Entity, key.entity),
+                match key.block {
+                    0 => 0,
+                    id => match block_name(id) {
+                        Some(name) => strings.intern(&name),
+                        None => strings.intern(&format!("#{id}")),
+                    },
+                },
+                dimension_name(key.dim).map_or(0, |name| strings.intern(name)),
+                key.chunk.0 as u32,
+                key.chunk.1 as u32,
+            ];
+            let context = *context_ids.entry(row).or_insert_with(|| {
+                contexts.span.push(row[0]);
+                contexts.entity.push(row[1]);
+                contexts.block.push(row[2]);
+                contexts.dim.push(row[3]);
+                contexts.chunk_x.push(key.chunk.0);
+                contexts.chunk_z.push(key.chunk.1);
+                contexts.span.len() as u32 - 1
+            });
+            weights.node.push(node);
+            weights.thread.push(u32::from(thread));
+            weights.kind.push(kind_of(key.state));
+            weights.state.push(match key.state {
+                State::Running => 1,
+                State::Waiting => 2,
+                State::Cpu | State::Alloc | State::Live => 0,
+            });
+            weights.slow.push(key.slow);
+            weights.context.push(context);
+            weights.block.push(u32::from(key.time_block));
+            weights.count.push(count);
+        }
+    }
+
+    let blocks = agg.time_blocks();
+    let mut threads = Vec::new();
+    let mut block_units = Vec::new();
+    for (i, name) in names.iter().enumerate() {
+        let ticks = agg.ticks.get(&(i as u16)).filter(|_| i < agg.threads.len());
+        threads.push(SampledThread {
+            name: strings.intern(name),
+            units: ticks.map_or(0, |t| t.count),
+            slow_units: ticks.map_or(0, |t| t.slow),
+            unit: unit as i32,
+        });
+        if i >= agg.threads.len() {
+            continue;
+        }
+        let mut units = agg
+            .block_ticks
+            .get(&(i as u16))
+            .cloned()
+            .unwrap_or_default();
+        units.resize(blocks, 0);
+        block_units.push(BlockUnits {
+            thread: i as u32,
+            units,
+        });
+    }
+
+    SampleProfile {
+        side: side as i32,
+        kinds,
+        threads,
+        block_s: profile.config.block_s,
+        block_units,
+        functions: Some(functions.rows),
+        nodes: Some(nodes.rows),
+        contexts: Some(contexts),
+        weights: Some(weights),
+        slow_over_ms: profile.config.ticks_over_ms as f32,
+    }
+}
+
+/// What the sampler and its writer thread cost during the session.
+pub fn overhead(profile: &Profile, heap: Option<&HeapProfile>) -> Overhead {
+    let wall_ns = profile.elapsed.as_nanos().max(1) as f64;
+    let handler_ns = profile.stats.handler_ns.unwrap_or(0.0) * profile.stats.samples as f64;
+    Overhead {
+        sampler_share_of_thread: (handler_ns / wall_ns) as f32,
+        writer_core_share: (profile.writer_cpu_ns as f64 / wall_ns) as f32,
+        dropped_samples: profile.stats.dropped + profile.agg.lost + heap.map_or(0, |h| h.agg.lost),
+        heap_samples: heap.map_or(0, |h| h.samples),
+        heap_sample_ns: heap.map_or(0, |h| h.sample_ns),
+        ..Overhead::default()
+    }
+}
@@ -0,0 +1,649 @@
+use std::collections::HashMap;
+use std::hint::black_box;
+use std::sync::mpsc;
+use std::thread;
+use std::time::{Duration, SystemTime};
+
+use horizon_perf_format::v1::{
+    Kind as CaptureKind, SampleProfile, Side, Start, Stop, StringEntry, Unit,
+};
+use horizon_perf_format::{CaptureWriter, Field};
+use horizon_threads::profile::{self, Aggregate, Config, Profile};
+use horizon_threads::sampler::{self, Context, Kind, Record, Stats};
+use horizon_threads::unwind::MAX_FRAMES;
+use horizon_threads::work;
+
+use super::*;
+
+#[inline(never)]
+fn alpha() {
+    black_box(1);
+}
+
+#[inline(never)]
+fn beta() {
+    black_box(2);
+}
+
+#[inline(never)]
+fn gamma() {
+    black_box(3);
+}
+
+fn at(f: fn(), offset: usize) -> usize {
+    f as *const () as usize + offset
+}
+
+fn record(kind: Kind, ctx: Context, value: u64, stack: &[usize]) -> Record {
+    let mut frames = [0; MAX_FRAMES];
+    frames[..stack.len()].copy_from_slice(stack);
+    Record {
+        kind,
+        depth: stack.len() as u8,
+        ctx,
+        value,
+        frames,
+    }
+}
+
+fn profile_of(agg: Aggregate, config: Config) -> Profile {
+    Profile {
+        agg,
+        config,
+        stats: Stats::default(),
+        elapsed: Duration::from_secs(10),
+        started: SystemTime::now(),
+        writer_cpu_ns: 0,
+    }
+}
+
+struct Converted {
+    samples: SampleProfile,
+    strings: Vec<StringEntry>,
+}
+
+impl Converted {
+    fn text(&self, id: u32) -> &str {
+        match id {
+            0 => "",
+            id => &self.strings.iter().find(|s| s.id == id).unwrap().text,
+        }
+    }
+
+    fn function(&self, row: u32) -> &str {
+        self.text(self.samples.functions.as_ref().unwrap().name[row as usize])
+    }
+
+    /// Function names from the root down to `node`.
+    fn path(&self, node: u32) -> Vec<&str> {
+        let nodes = self.samples.nodes.as_ref().unwrap();
+        let mut path = vec![self.function(nodes.function[node as usize])];
+        let mut at = node as usize;
+        while nodes.thread_root[at] == 0 {
+            at = nodes.parent[at] as usize;
+            path.push(self.function(nodes.function[at]));
+        }
+        path.reverse();
+        path
+    }
+
+    /// Samples per entity name, optionally only the slow ones.
+    fn by_entity(&self, slow_only: bool) -> HashMap<String, u64> {
+        let (w, c) = (
+            self.samples.weights.as_ref().unwrap(),
+            self.samples.contexts.as_ref().unwrap(),
+        );
+        let mut by = HashMap::new();
+        for i in 0..w.node.len() {
+            if slow_only && !w.slow[i] {
+                continue;
+            }
+            let entity = self.text(c.entity[w.context[i] as usize]).to_owned();
+            *by.entry(entity).or_default() += w.count[i];
+        }
+        by
+    }
+}
+
+fn convert(profile: &Profile) -> Converted {
+    let mut interner = Interner::default();
+    let samples = sample_profile(
+        profile,
+        None,
+        Side::Server,
+        Unit::Tick,
+        &|id| (id == 7).then(|| "minecraft:hopper".to_owned()),
+        &mut interner,
+    );
+    Converted {
+        samples,
+        strings: interner.take_new(Side::Server),
+    }
+}
+
+fn short(name: &str) -> &str {
+    name.rsplit("::").next().unwrap()
+}
+
+#[test]
+fn a_stack_becomes_a_root_to_leaf_chain_with_its_context() {
+    let entity = work::entity_id("test:zombie");
+    let ctx = Context {
+        tick: 1,
+        entity_type: entity,
+        block: 7,
+        dim: 2,
+        chunk: (-3, 9),
+        ..Context::default()
+    };
+    let mut agg = Aggregate::new(50_000_000);
+    for _ in 0..5 {
+        agg.add(
+            "tick",
+            &record(Kind::Cpu, ctx, 0, &[at(alpha, 4), at(gamma, 3)]),
+        );
+    }
+    agg.add("tick", &record(Kind::Tick, ctx, 9_000_000, &[]));
+    agg.finish();
+    let c = convert(&profile_of(agg, Config::default()));
+    let w = c.samples.weights.as_ref().unwrap();
+    assert_eq!(
+        (w.node.len(), w.count[0], w.state[0], w.slow[0]),
+        (1, 5, 0, false)
+    );
+    let path: Vec<_> = c.path(w.node[0]).into_iter().map(short).collect();
+    assert_eq!(path, ["gamma", "alpha"]);
+    let nodes = c.samples.nodes.as_ref().unwrap();
+    assert_eq!(nodes.thread_root, [1, 0]);
+    let ctxs = c.samples.contexts.as_ref().unwrap();
+    let row = w.context[0] as usize;
+    assert_eq!(c.text(ctxs.entity[row]), "test:zombie");
+    assert_eq!(c.text(ctxs.block[row]), "minecraft:hopper");
+    assert_eq!(c.text(ctxs.dim[row]), "the_nether");
+    assert_eq!((ctxs.chunk_x[row], ctxs.chunk_z[row]), (-3, 9));
+    assert_eq!(c.text(c.samples.threads[0].name), "tick");
+    assert_eq!(
+        (c.samples.threads[0].units, c.samples.threads[0].slow_units),
+        (1, 0)
+    );
+}
+
+#[test]
+fn addresses_of_one_function_share_one_row() {
+    let ctx = Context::default();
+    let mut agg = Aggregate::new(50_000_000);
+    for (inner, count) in [(4, 2), (8, 3)] {
+        for _ in 0..count {
+            agg.add(
+                "tick",
+                &record(Kind::Cpu, ctx, 0, &[at(alpha, inner), at(gamma, 3)]),
+            );
+        }
+    }
+    agg.add(
+        "tick",
+        &record(Kind::Cpu, ctx, 0, &[at(beta, 4), at(gamma, 3)]),
+    );
+    agg.finish();
+    let c = convert(&profile_of(agg, Config::default()));
+    let f = c.samples.functions.as_ref().unwrap();
+    let names: Vec<_> = (0..f.name.len() as u32)
+        .map(|row| short(c.function(row)))
+        .collect();
+    let mut sorted = names.clone();
+    sorted.sort_unstable();
+    assert_eq!(sorted, ["alpha", "beta", "gamma"]);
+    let w = c.samples.weights.as_ref().unwrap();
+    let on_alpha: u64 = (0..w.node.len())
+        .filter(|&i| short(c.path(w.node[i]).last().unwrap()) == "alpha")
+        .map(|i| w.count[i])
+        .sum();
+    assert_eq!(on_alpha, 5);
+    let n = c.samples.nodes.as_ref().unwrap();
+    let alphas: Vec<usize> = (0..n.function.len())
+        .filter(|&i| short(c.function(n.function[i])) == "alpha")
+        .collect();
+    assert_eq!(alphas.len(), 1, "one node per (parent, function)");
+    assert_eq!(
+        short(c.function(n.function[n.parent[alphas[0]] as usize])),
+        "gamma"
+    );
+    let weight_on_alpha: u64 = (0..w.node.len())
+        .filter(|&i| w.node[i] as usize == alphas[0])
+        .map(|i| w.count[i])
+        .sum();
+    assert_eq!(weight_on_alpha, 5);
+    let alpha_row = names.iter().position(|n| *n == "alpha").unwrap();
+    assert!(f.addr[alpha_row] > 0, "a module-relative address is kept");
+}
+
+#[test]
+fn time_blocks_and_ticks_per_block_follow_when_they_were_added() {
+    let ctx = |tick| Context {
+        tick,
+        ..Context::default()
+    };
+    let mut agg = Aggregate::new(50_000_000);
+    for (block, tick, samples) in [(0, 1, 2u64), (1, 2, 3), (1, 3, 1), (3, 4, 4)] {
+        agg.set_time_block(block);
+        for _ in 0..samples {
+            agg.add("tick", &record(Kind::Cpu, ctx(tick), 0, &[at(alpha, 1)]));
+        }
+        agg.add("tick", &record(Kind::Tick, ctx(tick), 1_000_000, &[]));
+    }
+    agg.finish();
+    let config = Config {
+        block_s: 2.5,
+        ..Config::default()
+    };
+    let c = convert(&profile_of(agg, config));
+    let w = c.samples.weights.as_ref().unwrap();
+    let mut per_block = [0u64; 4];
+    for i in 0..w.node.len() {
+        per_block[w.block[i] as usize] += w.count[i];
+    }
+    assert_eq!(per_block, [2, 4, 0, 4]);
+    assert_eq!(c.samples.block_s, 2.5);
+    assert_eq!(c.samples.block_units[0].units, [1, 2, 0, 1]);
+    assert_eq!(c.samples.threads[0].units, 4);
+}
+
+#[test]
+fn a_sample_with_no_stack_hangs_off_an_unknown_root() {
+    let mut agg = Aggregate::new(50_000_000);
+    agg.add("tick", &record(Kind::Cpu, Context::default(), 0, &[]));
+    agg.finish();
+    let c = convert(&profile_of(agg, Config::default()));
+    let w = c.samples.weights.as_ref().unwrap();
+    assert_eq!(c.path(w.node[0]), ["[unknown]"]);
+}
+
+#[test]
+fn wall_samples_carry_their_state_and_a_second_kind() {
+    let mut agg = Aggregate::new(50_000_000);
+    let ctx = Context::default();
+    agg.add("tick", &record(Kind::Cpu, ctx, 0, &[at(alpha, 1)]));
+    agg.add("tick", &record(Kind::Wall, ctx, 1, &[at(alpha, 1)]));
+    agg.add("tick", &record(Kind::Wall, ctx, 0, &[at(beta, 1)]));
+    agg.finish();
+    let config = Config {
+        sampler: sampler::Config {
+            hz: 200,
+            ..sampler::Config::default()
+        },
+        ..Config::default()
+    };
+    let c = convert(&profile_of(agg, config));
+    assert_eq!(c.samples.kinds.len(), 2);
+    assert_eq!(c.samples.kinds[0].period, 5.0);
+    let w = c.samples.weights.as_ref().unwrap();
+    let mut seen: Vec<_> = (0..w.node.len())
+        .map(|i| {
+            (
+                short(c.path(w.node[i]).last().unwrap()).to_owned(),
+                w.kind[i],
+                w.state[i],
+            )
+        })
+        .collect();
+    seen.sort();
+    assert_eq!(
+        seen,
+        [
+            ("alpha".into(), 0, 0),
+            ("alpha".into(), 1, 1),
+            ("beta".into(), 1, 2)
+        ]
+    );
+}
+
+#[inline(never)]
+fn spin_fast() {
+    spin(8);
+    black_box(0);
+}
+
+#[inline(never)]
+fn spin_slow() {
+    spin(120);
+    black_box(1);
+}
+
+fn spin(cpu_ms: u64) {
+    let until = sampler::thread_cpu_ns() + cpu_ms * 1_000_000;
+    let mut x = 1u64;
+    while sampler::thread_cpu_ns() < until {
+        for _ in 0..1 << 14 {
+            x = black_box(x.wrapping_mul(6364136223846793005).wrapping_add(1));
+        }
+    }
+    black_box(x);
+}
+
+fn live_config() -> Config {
+    Config {
+        sampler: sampler::Config {
+            hz: 1000,
+            ring_samples: 512,
+            unwind: sampler::Unwind::StackCopy,
+            stack_copy_kib: 16,
+            wall: false,
+        },
+        ticks_over_ms: 50.0,
+        ..Config::default()
+    }
+}
+
+/// Runs `body` on a thread opted in as `name`, profiled for exactly its duration.
+fn profiled(name: &'static str, body: fn()) -> Profile {
+    let (ready, wait) = mpsc::channel();
+    let (go, start) = mpsc::channel::<()>();
+    let worker = thread::spawn(move || {
+        assert!(sampler::sampled_thread(name));
+        ready.send(()).unwrap();
+        start.recv().unwrap();
+        body();
+    });
+    wait.recv().unwrap();
+    let session = profile::start(Config {
+        threads: vec![name.into()],
+        ..live_config()
+    })
+    .expect("start profiling");
+    go.send(()).unwrap();
+    worker.join().unwrap();
+    session.stop().expect("stop profiling")
+}
+
+fn entity_units() {
+    let (a, b) = (work::entity_id("test:a"), work::entity_id("test:b"));
+    for unit in 0..4 {
+        work::tick_start();
+        work::set_entity(if unit < 3 { a } else { b });
+        let started = sampler::thread_cpu_ns();
+        spin(40);
+        work::clear_work();
+        work::tick_end(sampler::thread_cpu_ns() - started);
+    }
+}
+
+#[test]
+fn three_units_of_a_and_one_of_b_split_the_samples_three_to_one() {
+    let c = convert(&profiled("perf-capture-entities", entity_units));
+    let by = c.by_entity(false);
+    let total = (by["test:a"] + by["test:b"]) as f64;
+    let (a, b) = (by["test:a"] as f64 / total, by["test:b"] as f64 / total);
+    assert!((a - 0.75).abs() < 0.1 && (b - 0.25).abs() < 0.1, "{by:?}");
+    assert!(total > 100.0, "{total} samples");
+    assert_eq!(c.samples.threads[0].units, 4);
+}
+
+fn ticks_with_one_slow() {
+    for tick in 0..6 {
+        work::tick_start();
+        let started = sampler::thread_cpu_ns();
+        if tick == 3 {
+            spin_slow();
+        } else {
+            spin_fast();
+        }
+        work::tick_end(sampler::thread_cpu_ns() - started);
+    }
+}
+
+#[test]
+fn only_the_slow_ticks_function_is_in_the_slow_weights() {
+    let c = convert(&profiled("perf-capture-slow", ticks_with_one_slow));
+    let w = c.samples.weights.as_ref().unwrap();
+    let (mut slow, mut fast) = (0, 0);
+    for i in 0..w.node.len() {
+        let names: Vec<_> = c.path(w.node[i]).into_iter().map(short).collect();
+        if w.slow[i] {
+            slow += w.count[i];
+            assert!(
+                names.contains(&"spin_slow") && !names.contains(&"spin_fast"),
+                "{names:?}"
+            );
+        } else {
+            fast += w.count[i];
+            assert!(!names.contains(&"spin_slow"), "{names:?}");
+        }
+    }
+    assert!(slow > 60 && fast > 20, "{slow} slow, {fast} other");
+    assert_eq!(
+        (c.samples.threads[0].units, c.samples.threads[0].slow_units),
+        (6, 1)
+    );
+}
+
+#[test]
+fn overhead_counts_lost_samples_and_the_writers_share_of_a_core() {
+    let mut agg = Aggregate::new(1);
+    agg.lost = 4;
+    let mut profile = profile_of(agg, Config::default());
+    profile.stats.dropped = 3;
+    profile.stats.samples = 1000;
+    profile.stats.handler_ns = Some(2_000.0);
+    profile.writer_cpu_ns = 50_000_000;
+    let o = overhead(&profile, None);
+    assert_eq!(o.dropped_samples, 7);
+    assert!((o.sampler_share_of_thread - 0.0002).abs() < 1e-7);
+    assert!((o.writer_core_share - 0.005).abs() < 1e-6);
+}
+
+#[test]
+fn crates_come_from_the_first_path_segment() {
+    for (name, krate) in [
+        (
+            "horizon_world::level::tick::random_tick_at",
+            "horizon_world",
+        ),
+        (
+            "<horizon_world::X as core::ops::Drop>::drop",
+            "horizon_world",
+        ),
+        ("core::ptr::drop_in_place<alloc::vec::Vec<u8>>", "core"),
+        ("clone3", ""),
+        ("[horizon-server 0x4f2a]", "horizon-server"),
+        ("[unmapped 0x7ffd]", ""),
+    ] {
+        assert_eq!(crate_of(name), krate, "{name}");
+    }
+}
+
+fn ask(
+    file: &std::path::Path,
+    parts: &[&str],
+) -> horizon_perf::wire::Envelope<horizon_perf::query::Row> {
+    let env = horizon_perf::cli::Env {
+        horizon_home: None,
+        poll: Duration::from_millis(2),
+    };
+    let mut args = vec!["query".to_owned()];
+    args.extend(parts.iter().map(|p| (*p).to_owned()));
+    args.push(file.to_string_lossy().into_owned());
+    let mut out = Vec::new();
+    if let Err(e) = horizon_perf::cli::run(&args, &env, &mut out) {
+        panic!("{e:?}");
+    }
+    serde_json::from_slice(&out)
+        .unwrap_or_else(|e| panic!("{e}: {}", String::from_utf8_lossy(&out)))
+}
+
+#[test]
+fn a_converted_profile_written_to_a_file_reads_back_through_the_queries() {
+    let ctx = Context::default();
+    let mut agg = Aggregate::new(50_000_000);
+    for _ in 0..5 {
+        agg.add(
+            "tick",
+            &record(Kind::Cpu, ctx, 0, &[at(alpha, 4), at(gamma, 3)]),
+        );
+    }
+    for _ in 0..2 {
+        agg.add(
+            "tick",
+            &record(Kind::Cpu, ctx, 0, &[at(beta, 4), at(gamma, 3)]),
+        );
+    }
+    for _ in 0..2 {
+        agg.add("tick", &record(Kind::Tick, ctx, 9_000_000, &[]));
+    }
+    for _ in 0..3 {
+        agg.add("worker", &record(Kind::Cpu, ctx, 0, &[at(beta, 4)]));
+    }
+    agg.add("worker", &record(Kind::Tick, ctx, 9_000_000, &[]));
+    agg.finish();
+    let config = Config {
+        sampler: sampler::Config {
+            hz: 100,
+            ..sampler::Config::default()
+        },
+        ..Config::default()
+    };
+    let c = convert(&profile_of(agg, config));
+    let mut fields = vec![Field::Start(Start {
+        side: Side::Server as i32,
+        kind: CaptureKind::Dedicated as i32,
+        ..Default::default()
+    })];
+    fields.extend(c.strings.into_iter().map(Field::String));
+    fields.push(Field::Samples(c.samples));
+    fields.push(Field::Stop(Stop {
+        side: Side::Server as i32,
+        t: 10.0,
+        ..Default::default()
+    }));
+    let dir = std::env::temp_dir().join(format!("horizon-render-perf-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let file = dir.join("real.hzperf");
+    let mut writer = CaptureWriter::new(std::fs::File::create(&file).unwrap()).unwrap();
+    for field in fields {
+        writer.write(field).unwrap();
+    }
+    writer.finish().unwrap();
+
+    // 10 ms samples: alpha has 5 over the tick thread's 2 ticks.
+    let hot = ask(&file, &["hot"]);
+    let alpha = hot.rows().iter().find_map(|r| match r {
+        horizon_perf::query::Row::Hot(h) if h.full.ends_with("alpha") => Some(h),
+        _ => None,
+    });
+    assert_eq!(alpha.map(|h| (h.self_ms, h.samples)), Some((25.0, 5)));
+    let worker = ask(&file, &["split", "t:worker", "--by", "thread"]);
+    let sel = worker.selection.as_ref().unwrap();
+    assert_eq!(
+        (sel.thread.as_deref(), sel.ticks, sel.samples),
+        (Some("worker"), Some(1), Some(3))
+    );
+    let values: Vec<_> = worker
+        .rows()
+        .iter()
+        .map(|r| match r {
+            horizon_perf::query::Row::Split(s) => (s.key.clone(), s.value),
+            other => panic!("{other:?}"),
+        })
+        .collect();
+    assert_eq!(values, [(Some("t:worker".to_owned()), 30.0)]);
+    std::fs::remove_dir_all(&dir).unwrap();
+}
+
+#[test]
+fn heap_samples_share_the_tables_without_the_allocators_own_frames() {
+    let mut cpu = Aggregate::new(50_000_000);
+    cpu.add(
+        "tick",
+        &record(
+            Kind::Cpu,
+            Context::default(),
+            0,
+            &[at(alpha, 4), at(gamma, 3)],
+        ),
+    );
+    cpu.finish();
+    let mut heap = Aggregate::new(0);
+    let inside = HeapProfile::bytes as *const () as usize + 4;
+    let on_tick = heap.thread_index("tick");
+    let key = heap.stack_key(
+        on_tick,
+        profile::State::Alloc,
+        &Context::default(),
+        &[inside, at(beta, 4), at(gamma, 3)],
+    );
+    heap.add_weight(key, 3000);
+    heap.add_weight(
+        profile::Key {
+            state: profile::State::Live,
+            ..key
+        },
+        1000,
+    );
+    let on_worker = heap.thread_index("worker");
+    let key = heap.stack_key(
+        on_worker,
+        profile::State::Live,
+        &Context::default(),
+        &[inside, at(alpha, 4)],
+    );
+    heap.add_weight(key, 500);
+    let heap = HeapProfile {
+        agg: heap,
+        interval: 4096,
+        samples: 3,
+        live_samples: 2,
+        sample_ns: 0,
+        freed: 2000,
+        elapsed: Duration::from_secs(10),
+    };
+    let mut interner = Interner::default();
+    let samples = sample_profile(
+        &profile_of(cpu, Config::default()),
+        Some(&heap),
+        Side::Server,
+        Unit::Tick,
+        &|_| None,
+        &mut interner,
+    );
+    let c = Converted {
+        samples,
+        strings: interner.take_new(Side::Server),
+    };
+    let sources: Vec<_> = c
+        .samples
+        .kinds
+        .iter()
+        .map(|k| (k.source(), k.period))
+        .collect();
+    assert_eq!(
+        sources,
+        [
+            (SampleSource::Cpu, 4.0),
+            (SampleSource::Alloc, 1.0),
+            (SampleSource::Live, 1.0)
+        ]
+    );
+    let names: Vec<_> = c.samples.threads.iter().map(|t| c.text(t.name)).collect();
+    assert_eq!(names, ["tick", "worker"]);
+    let w = c.samples.weights.as_ref().unwrap();
+    let mut rows: Vec<_> = (0..w.node.len())
+        .map(|i| {
+            let path: Vec<_> = c.path(w.node[i]).into_iter().map(short).collect();
+            (w.kind[i], w.thread[i], path.join(">"), w.count[i])
+        })
+        .collect();
+    rows.sort();
+    assert_eq!(
+        rows,
+        [
+            (0, 0, "gamma>alpha".to_owned(), 1),
+            (1, 0, "gamma>beta".to_owned(), 3000),
+            (2, 0, "gamma>beta".to_owned(), 1000),
+            (2, 1, "alpha".to_owned(), 500),
+        ]
+    );
+    let o = overhead(
+        &profile_of(Aggregate::new(0), Config::default()),
+        Some(&heap),
+    );
+    assert_eq!(o.heap_samples, 3);
+}
@@ -0,0 +1,484 @@
+//! The GPU pass timers' readings as the capture's `gpu` messages (docs/perf-platform.md §3.5); apart from `perf_capture`, which only Linux has.
+use horizon_perf_format::Interner;
+use horizon_perf_format::v1::{
+    GpuBackend, GpuCounter, GpuCounts, GpuDevice, GpuFragmentUnit, GpuFrame, GpuFrames, GpuPart,
+    GpuPartCounts, GpuPartsMode, GpuPass, GpuPassSplit, GpuPasses, GpuSource, Side,
+};
+use std::time::Instant;
+
+use crate::gfx::pack_timing::{
+    Counters, FragmentUnit, GpuReadout, PartsMode, PassCounters, Readings, TimedFrame, TimedFrames,
+};
+
+/// Every time one timer's frames gave a pass or a part during a capture.
+#[derive(Default)]
+struct Times {
+    passes: Vec<(String, Vec<f32>)>,
+    parts: Vec<(String, Vec<(String, Vec<f32>)>)>,
+}
+
+fn times_of<'a>(list: &'a mut Vec<(String, Vec<f32>)>, name: &str) -> &'a mut Vec<f32> {
+    let i = match list.iter().position(|e| e.0 == name) {
+        Some(i) => i,
+        None => {
+            list.push((name.to_owned(), Vec::new()));
+            list.len() - 1
+        }
+    };
+    &mut list[i].1
+}
+
+impl Times {
+    fn add(&mut self, frame: &TimedFrame) {
+        for (pass, ms) in &frame.passes {
+            times_of(&mut self.passes, pass).push(*ms);
+        }
+        for (pass, parts) in &frame.parts {
+            let i = match self.parts.iter().position(|e| e.0 == *pass) {
+                Some(i) => i,
+                None => {
+                    self.parts.push((pass.clone(), Vec::new()));
+                    self.parts.len() - 1
+                }
+            };
+            for (part, ms) in parts {
+                times_of(&mut self.parts[i].1, part).push(*ms);
+            }
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        self.passes.is_empty() && self.parts.is_empty()
+    }
+
+    /// `readings` with its times the medians over the whole capture instead of its last frames.
+    fn medians_into(&self, readings: &Readings) -> Readings {
+        let median = |v: &[f32]| {
+            let mut v = v.to_vec();
+            v.sort_by(f32::total_cmp);
+            v[v.len() / 2]
+        };
+        Readings {
+            passes: self
+                .passes
+                .iter()
+                .map(|(name, v)| (name.clone(), median(v)))
+                .collect(),
+            parts: self
+                .parts
+                .iter()
+                .map(|(pass, parts)| {
+                    let parts = parts.iter().map(|(n, v)| (n.clone(), median(v))).collect();
+                    (pass.clone(), parts)
+                })
+                .collect(),
+            ..readings.clone()
+        }
+    }
+}
+
+/// A capture's timed frames on their way into `GpuFrames` blocks, every time kept for the whole capture's medians.
+#[derive(Default)]
+pub struct FrameLog {
+    pending: Vec<GpuFrame>,
+    cpu_frame_ms: Vec<f32>,
+    own: Times,
+    pack: Times,
+}
+
+impl FrameLog {
+    /// The CPU's own ms of one frame the window drew.
+    pub fn cpu_frame(&mut self, ms: f32) {
+        self.cpu_frame_ms.push(ms);
+    }
+
+    /// The frames timed since the last call; `t_of` puts a frame's start on the capture clock.
+    pub fn add(
+        &mut self,
+        frames: &TimedFrames,
+        t_of: impl Fn(Instant) -> f64,
+        strings: &mut Interner,
+    ) {
+        for (source, list, times) in [
+            (GpuSource::Horizon, &frames.own, &mut self.own),
+            (GpuSource::ShaderPack, &frames.pack, &mut self.pack),
+        ] {
+            for frame in list {
+                times.add(frame);
+                self.pending
+                    .push(frame_message(frame, source, t_of(frame.at), strings));
+            }
+        }
+    }
+
+    /// The frames and CPU frame times since the last block; none when there are neither.
+    pub fn take_block(&mut self, side: Side) -> Option<GpuFrames> {
+        if self.pending.is_empty() && self.cpu_frame_ms.is_empty() {
+            return None;
+        }
+        Some(GpuFrames {
+            side: side as i32,
+            frames: std::mem::take(&mut self.pending),
+            cpu_frame_ms: std::mem::take(&mut self.cpu_frame_ms),
+        })
+    }
+}
+
+fn frame_message(
+    frame: &TimedFrame,
+    source: GpuSource,
+    t: f64,
+    strings: &mut Interner,
+) -> GpuFrame {
+    let mut passes: Vec<GpuPass> = frame
+        .passes
+        .iter()
+        .map(|(name, ms)| GpuPass {
+            name: strings.intern(name),
+            ms: Some(*ms),
+            parts: Vec::new(),
+        })
+        .collect();
+    for (pass, parts) in &frame.parts {
+        let parts = parts
+            .iter()
+            .map(|(part, ms)| GpuPart {
+                name: strings.intern(part),
+                ms: *ms,
+            })
+            .collect();
+        let name = strings.intern(pass);
+        match passes.iter_mut().find(|p| p.name == name) {
+            Some(p) => p.parts = parts,
+            None => passes.push(GpuPass {
+                name,
+                ms: None,
+                parts,
+            }),
+        }
+    }
+    GpuFrame {
+        source: source as i32,
+        t,
+        total_ms: frame.total_ms,
+        passes,
+    }
+}
+
+fn backend(backend: wgpu::Backend) -> GpuBackend {
+    match backend {
+        wgpu::Backend::Vulkan => GpuBackend::Vulkan,
+        wgpu::Backend::Metal => GpuBackend::Metal,
+        wgpu::Backend::Dx12 => GpuBackend::Dx12,
+        wgpu::Backend::Gl => GpuBackend::Gl,
+        _ => GpuBackend::Other,
+    }
+}
+
+fn counts(c: Counters) -> GpuCounts {
+    GpuCounts {
+        vertex_shader_invocations: c.vertex_shader_invocations,
+        clipper_invocations: c.clipper_invocations,
+        clipper_primitives_out: c.clipper_primitives_out,
+        fragment_shader_invocations: c.fragment_shader_invocations,
+    }
+}
+
+fn counter(strings: &mut Interner, pass: &str, c: &PassCounters) -> GpuCounter {
+    GpuCounter {
+        pass: strings.intern(pass),
+        total: Some(counts(c.total)),
+        pixels: c.pixels,
+        parts: c
+            .parts
+            .iter()
+            .map(|(name, part)| GpuPartCounts {
+                name: strings.intern(name),
+                counts: Some(counts(*part)),
+            })
+            .collect(),
+    }
+}
+
+fn device(adapter: &wgpu::AdapterInfo, readings: &Readings) -> GpuDevice {
+    let driver = format!("{} {}", adapter.driver, adapter.driver_info);
+    GpuDevice {
+        adapter: adapter.name.clone(),
+        backend: backend(adapter.backend) as i32,
+        driver: driver.trim().to_owned(),
+        parts_mode: match readings.support.parts {
+            PartsMode::InsidePasses => GpuPartsMode::InsidePasses,
+            PartsMode::SeparatePasses => GpuPartsMode::SeparatePasses,
+        } as i32,
+        pass_split: match readings.support.parts {
+            PartsMode::InsidePasses => GpuPassSplit::DrawGroups,
+            PartsMode::SeparatePasses => GpuPassSplit::PassesOnly,
+        } as i32,
+        counters: readings.support.counters,
+        fragment_unit: match readings.support.fragment_unit {
+            None => GpuFragmentUnit::Unspecified,
+            Some(FragmentUnit::Pixel) => GpuFragmentUnit::Pixel,
+            Some(FragmentUnit::Quad) => GpuFragmentUnit::Quad,
+        } as i32,
+    }
+}
+
+fn section(
+    adapter: &wgpu::AdapterInfo,
+    side: Side,
+    source: GpuSource,
+    readings: &Readings,
+    strings: &mut Interner,
+) -> GpuPasses {
+    let mut passes: Vec<GpuPass> = readings
+        .passes
+        .iter()
+        .map(|(name, ms)| GpuPass {
+            name: strings.intern(name),
+            ms: Some(*ms),
+            parts: Vec::new(),
+        })
+        .collect();
+    for (pass, parts) in &readings.parts {
+        let name = strings.intern(pass);
+        let at = passes
+            .iter()
+            .position(|p| p.name == name)
+            .unwrap_or_else(|| {
+                passes.push(GpuPass {
+                    name,
+                    ms: None,
+                    parts: Vec::new(),
+                });
+                passes.len() - 1
+            });
+        passes[at].parts = parts
+            .iter()
+            .map(|(part, ms)| GpuPart {
+                name: strings.intern(part),
+                ms: *ms,
+            })
+            .collect();
+    }
+    GpuPasses {
+        side: side as i32,
+        device: Some(device(adapter, readings)),
+        passes,
+        counters: readings
+            .counters
+            .iter()
+            .map(|(pass, c)| counter(strings, pass, c))
+            .collect(),
+        source: source as i32,
+    }
+}
+
+/// One `GpuPasses` per timer that has timed something, its times the medians of `log` where it has them; the caller appends `strings`' new entries first.
+pub fn gpu_passes(
+    readout: &GpuReadout,
+    log: &FrameLog,
+    side: Side,
+    strings: &mut Interner,
+) -> Vec<GpuPasses> {
+    [
+        (GpuSource::Horizon, &readout.own, &log.own),
+        (GpuSource::ShaderPack, &readout.pack, &log.pack),
+    ]
+    .into_iter()
+    .filter_map(|(source, readings, times)| {
+        let readings = readings.as_ref().filter(|r| !r.is_empty())?;
+        let whole = (!times.is_empty()).then(|| times.medians_into(readings));
+        let readings = whole.as_ref().unwrap_or(readings);
+        Some(section(&readout.adapter, side, source, readings, strings))
+    })
+    .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::gfx::pack_timing::DetailSupport;
+
+    fn adapter() -> wgpu::AdapterInfo {
+        wgpu::AdapterInfo {
+            name: "Test GPU".into(),
+            vendor: 0x10de,
+            device: 1,
+            device_type: wgpu::DeviceType::DiscreteGpu,
+            device_pci_bus_id: String::new(),
+            driver: "NVIDIA".into(),
+            driver_info: "570.1".into(),
+            backend: wgpu::Backend::Vulkan,
+            subgroup_min_size: 0,
+            subgroup_max_size: 0,
+            transient_saves_memory: None,
+            limit_bucket: None,
+        }
+    }
+
+    fn support(unit: Option<FragmentUnit>) -> DetailSupport {
+        DetailSupport {
+            parts: PartsMode::InsidePasses,
+            encoder_stamps: true,
+            counters: true,
+            fragment_unit: unit,
+        }
+    }
+
+    #[test]
+    fn known_medians_parts_and_counters_come_through_with_their_names() {
+        let c = |v, f| Counters {
+            vertex_shader_invocations: v,
+            clipper_invocations: 2_050_000,
+            clipper_primitives_out: 1_200_000,
+            fragment_shader_invocations: f,
+        };
+        let own = Readings {
+            passes: vec![("World".into(), 1.5), ("HUD".into(), 0.25)],
+            parts: vec![("GPU culling".into(), vec![("cull".into(), 0.125)])],
+            counters: vec![(
+                "World".into(),
+                PassCounters {
+                    total: c(4_100_000, 6_300_000),
+                    pixels: 2_073_600,
+                    parts: vec![
+                        ("before translucent".into(), c(3_000_000, 5_100_000)),
+                        ("translucent terrain".into(), c(1_100_000, 1_200_000)),
+                    ],
+                },
+            )],
+            support: support(Some(FragmentUnit::Quad)),
+        };
+        let readout = GpuReadout {
+            adapter: adapter(),
+            own: Some(own),
+            pack: None,
+        };
+        let mut strings = Interner::default();
+        let got = gpu_passes(&readout, &FrameLog::default(), Side::Client, &mut strings);
+        assert_eq!(got.len(), 1);
+        let g = &got[0];
+        assert_eq!((g.side(), g.source()), (Side::Client, GpuSource::Horizon));
+        let d = g.device.as_ref().unwrap();
+        assert_eq!(d.adapter, "Test GPU");
+        assert_eq!(d.backend(), GpuBackend::Vulkan);
+        assert_eq!(d.driver, "NVIDIA 570.1");
+        assert_eq!(d.parts_mode(), GpuPartsMode::InsidePasses);
+        assert!(d.counters);
+        assert_eq!(d.fragment_unit(), GpuFragmentUnit::Quad);
+
+        // World, HUD, then the pass known only through its parts.
+        let entries = strings.take_new(Side::Client);
+        let name = |id: u32| entries.iter().find(|e| e.id == id).unwrap().text.as_str();
+        let named: Vec<_> = g.passes.iter().map(|p| name(p.name)).collect();
+        assert_eq!(named, ["World", "HUD", "GPU culling"]);
+        let shown: Vec<_> = g.passes.iter().map(|p| p.ms).collect();
+        assert_eq!(shown, [Some(1.5), Some(0.25), None]);
+        assert_eq!(name(g.passes[2].parts[0].name), "cull");
+        assert_eq!(g.passes[2].parts[0].ms, 0.125);
+        let counted = &g.counters[0];
+        assert_eq!(counted.pixels, 2_073_600);
+        assert_eq!(
+            counted.total.as_ref().unwrap().fragment_shader_invocations,
+            6_300_000
+        );
+        assert_eq!(counted.parts.len(), 2);
+        assert_eq!(
+            counted.parts[1]
+                .counts
+                .as_ref()
+                .unwrap()
+                .vertex_shader_invocations,
+            1_100_000
+        );
+        // The pass's counters and its time name the same string.
+        assert_eq!(counted.pass, g.passes[0].name);
+    }
+
+    #[test]
+    fn a_timer_that_timed_nothing_adds_no_section() {
+        let idle = Readings {
+            passes: Vec::new(),
+            parts: Vec::new(),
+            counters: Vec::new(),
+            support: support(None),
+        };
+        let pack = Readings {
+            passes: vec![("composite".into(), 0.75)],
+            ..idle.clone()
+        };
+        let readout = GpuReadout {
+            adapter: adapter(),
+            own: Some(idle),
+            pack: Some(pack),
+        };
+        let got = gpu_passes(
+            &readout,
+            &FrameLog::default(),
+            Side::Client,
+            &mut Interner::default(),
+        );
+        assert_eq!(got.len(), 1);
+        assert_eq!(got[0].source(), GpuSource::ShaderPack);
+        assert_eq!(
+            got[0].device.as_ref().unwrap().fragment_unit(),
+            GpuFragmentUnit::Unspecified
+        );
+    }
+
+    #[test]
+    fn the_end_section_takes_the_whole_capture_median_and_each_block_its_frames() {
+        let start = Instant::now();
+        let frame = |i: u32, world: f32| TimedFrame {
+            at: start + std::time::Duration::from_millis(u64::from(i) * 10),
+            total_ms: Some(world + 1.0),
+            passes: vec![("World".into(), world), ("HUD".into(), 0.5)],
+            parts: vec![("World".into(), vec![("sky".into(), world / 4.0)])],
+        };
+        let mut log = FrameLog::default();
+        let mut strings = Interner::default();
+        let worlds = [1.0, 2.0, 3.0, 4.0, 100.0];
+        let frames = TimedFrames {
+            own: worlds
+                .iter()
+                .enumerate()
+                .map(|(i, &w)| frame(i as u32, w))
+                .collect(),
+            pack: Vec::new(),
+        };
+        log.add(
+            &frames,
+            |at| at.duration_since(start).as_secs_f64(),
+            &mut strings,
+        );
+        log.cpu_frame(6.0);
+        let block = log.take_block(Side::Client).expect("a block");
+        assert_eq!(block.frames.len(), 5);
+        assert_eq!(block.cpu_frame_ms, [6.0]);
+        assert!((block.frames[4].t - 0.04).abs() < 1e-9);
+        assert_eq!(block.frames[4].total_ms, Some(101.0));
+        assert_eq!(block.frames[4].passes[0].parts[0].ms, 25.0);
+        assert!(log.take_block(Side::Client).is_none());
+
+        // The timer's own median (9.0) is of its last frames; the capture's is the third of five sorted.
+        let own = Readings {
+            passes: vec![("World".into(), 9.0)],
+            parts: Vec::new(),
+            counters: Vec::new(),
+            support: support(None),
+        };
+        let readout = GpuReadout {
+            adapter: adapter(),
+            own: Some(own),
+            pack: None,
+        };
+        let got = gpu_passes(&readout, &log, Side::Client, &mut strings);
+        let world = &got[0].passes[0];
+        assert_eq!(world.ms, Some(3.0));
+        assert_eq!(world.parts[0].ms, 0.75);
+        assert_eq!(
+            got[0].device.as_ref().unwrap().pass_split(),
+            GpuPassSplit::DrawGroups
+        );
+    }
+}
@@ -222,11 +222,6 @@ impl<P: Copy, S: Copy> Lines<P, S> {
        }
        self.y += style::GROUP_GAP;
    }
-    /// A group of rows under its page's own name (`list`'s `page_name`), for pages named at run
-    /// time, such as a resource pack's config entries (`pack_options_ui`).
-    pub(crate) fn titled(&mut self, page: P, rows: Vec<S>) {
-        self.group(page, "", rows);
-    }
    /// The lines and the content's height.
    pub(crate) fn finish(self) -> (Vec<Line<P, S>>, f32) {
        (self.lines, (self.y - style::GROUP_GAP).max(0.0))
@@ -352,8 +347,7 @@ pub(crate) fn plate(batch: &mut HudBatch, atlas: &HudAtlas, cols: &Columns, head
 }

 /// The list, clipped to its view: each group's panel, then its names and rows on it. `row`
-/// draws a setting at its `y`; `page_name` names a page, and a group without a name of its own
-/// (`Lines::titled`), in the player's language.
+/// draws a setting at its `y`; `page_name` names a page, in the player's language.
 pub(crate) fn list<P: Copy, S: Copy>(
    batch: &mut HudBatch,
    atlas: &HudAtlas,
@@ -386,7 +380,6 @@ pub(crate) fn list<P: Copy, S: Copy>(
        }
        let Some(setting) = line.setting else {
            let (name, color, dy) = match line.group {
-                Some(("", _)) => (page_name(line.page), style::muted(), 3.0),
                Some((name, _)) => (lang::get(name), style::muted(), 3.0),
                None => (page_name(line.page), style::accent(), 4.0),
            };
@@ -952,22 +945,10 @@ pub(crate) fn dock_note(
    }
 }

-/// Done or Undo at the foot of the page list.
+/// Done, Undo or Apply at the foot of the page list, registered for a controller. Its label
+/// leaves `room` at its left for a controller's glyph: a button that declared its job gets one,
+/// as vanilla's do (`ui::action_button`), which a half-width Undo or Apply needs.
 pub(crate) fn foot_button(
-    batch: &mut HudBatch,
-    atlas: &HudAtlas,
-    rect: [f32; 4],
-    label: &Text,
-    cursor: (f32, f32),
-    flags: (bool, bool),
-) {
-    foot_button_with_room(batch, atlas, rect, label, cursor, flags, 0.0);
-}
-
-/// A foot button whose label leaves `room` at its left for a controller's glyph: a button that
-/// declared its job gets one, as vanilla's do (`ui::action_button`), which a half-width Undo or
-/// Apply needs.
-fn foot_button_with_room(
    batch: &mut HudBatch,
    atlas: &HudAtlas,
    rect: [f32; 4],
@@ -2414,7 +2395,7 @@ impl<S: Screen + Default> Hosted for Shell<S> {
                }
                None => 0.0,
            };
-            foot_button_with_room(batch, atlas, rect, &label, cursor, flags, room);
+            foot_button(batch, atlas, rect, &label, cursor, flags, room);
        }
    }
    fn click(
@@ -1,10 +1,4 @@
-//! Named timings within a frame, for finding what makes a frame slow:
-//! `HORIZON_SPIKES=MS` prints the spans of every frame whose CPU time
-//! exceeds MS milliseconds, and of every server tick (dedicated or
-//! integrated) longer than MS. Each span keeps its wall time and the
-//! thread's CPU time inside it, so a span that waited (for a lock, the GPU
-//! or a core on a busy machine) shows apart from one that worked. Costs two
-//! clock reads per span when enabled and a relaxed load otherwise.
+//! Named timings (wall and thread CPU) of a frame or tick, on with `HORIZON_SPIKES` or while a capture records; the slow ones go to the slow ring, not as span lists to the log.
 use std::{
    cell::{Cell, RefCell},
    sync::atomic::{AtomicBool, Ordering},
@@ -58,10 +52,10 @@ pub fn record_here(on: bool) {
 /// Whether this thread records spans: all of them on, or [`record_here`].
 #[inline]
 pub fn recording_here() -> bool {
-    ENABLED.load(Ordering::Relaxed) || HERE.with(Cell::get) || trace::on()
+    ENABLED.load(Ordering::Relaxed) || HERE.with(Cell::get) || timeline::on()
 }
-/// The thread's CPU time when spans are on for every thread (`HORIZON_SPIKES`): only they
-/// print it.
+/// The thread's CPU time when spans are on for every thread (`HORIZON_SPIKES`): spans recorded
+/// by `record_here` alone keep wall time only.
 #[inline]
 fn cpu_if_enabled() -> Option<Duration> {
    if ENABLED.load(Ordering::Relaxed) {
@@ -82,31 +76,41 @@ pub fn time<T>(name: &'static str, f: impl FnOnce() -> T) -> T {
 pub struct Guard {
    open: Option<(&'static str, Instant, Option<Duration>, u8)>,
    _heap: Option<horizon_threads::heap_census::Tag>,
+    /// The sampler's span before this one.
+    outer: u16,
 }
 /// Start a span named `name` that ends when the returned [`Guard`] is dropped.
 #[inline]
 pub fn guard(name: &'static str) -> Guard {
    let _heap = horizon_threads::heap_tag(name);
+    let outer = horizon_threads::work::enter_span(name);
    if !recording_here() {
-        return Guard { open: None, _heap };
+        return Guard {
+            open: None,
+            _heap,
+            outer,
+        };
    }
    let depth = DEPTH.with(|d| d.replace(d.get().saturating_add(1)));
    Guard {
        open: Some((name, Instant::now(), cpu_if_enabled(), depth)),
        _heap,
+        outer,
    }
 }
 impl Drop for Guard {
    fn drop(&mut self) {
+        horizon_threads::work::leave_span(self.outer);
        let Some((name, started, cpu, depth)) = self.open.take() else {
            return;
        };
-        let ms = started.elapsed().as_secs_f32() * 1000.0;
+        let elapsed = started.elapsed();
+        let ms = elapsed.as_secs_f32() * 1000.0;
        let cpu_ms = cpu
            .and_then(|start| Some((thread_cpu()?, start)))
            .map_or(ms, |(end, start)| (end - start).as_secs_f32() * 1000.0);
        DEPTH.with(|d| d.set(depth));
-        trace::span(name, started, ms);
+        timeline::span(name, started, elapsed, depth);
        push(Span {
            name,
            ms,
@@ -115,6 +119,22 @@ impl Drop for Guard {
        });
    }
 }
+/// How many spans this thread holds.
+fn recorded() -> usize {
+    SPANS.with(|s| s.borrow().len())
+}
+/// Moves the spans recorded since `mark` one level in: they ran inside the lap now ending.
+fn nest_since(mark: usize, depth: u8) {
+    SPANS.with(|s| {
+        let mut s = s.borrow_mut();
+        let start = mark.min(s.len());
+        for span in &mut s[start..] {
+            if span.depth >= depth {
+                span.depth = span.depth.saturating_add(1);
+            }
+        }
+    });
+}
 /// Keeps a finished span for the thread's next [`take_raw`].
 fn push(span: Span) {
    SPANS.with(|s| {
@@ -125,22 +145,6 @@ fn push(span: Span) {
        s.push(span);
    });
 }
-/// Attach per-tick counts without interpreting them as durations.
-pub fn counters(counts: &[(&str, u64)]) {
-    if !enabled() {
-        return;
-    }
-    NOTES.with(|n| {
-        n.borrow_mut().push((
-            0.0,
-            counts
-                .iter()
-                .map(|(name, count)| format!("{name}={count}"))
-                .collect::<Vec<_>>()
-                .join(", "),
-        ))
-    });
-}
 /// Notes that one step inside a span took `ms` milliseconds doing `what` (one player's
 /// packets, say), when this thread records spans and the step took at least [`NOTE_MS`]: a
 /// span says where a slow tick went, its notes whose doing it was. Only the slowest few are
@@ -173,34 +177,36 @@ pub fn take_notes() -> Vec<(f32, String)> {
 }
 /// Consecutive steps of one function timed as spans: each [`Laps::lap`] records the time since
 /// the previous one (or since [`laps`]) under its name. Nothing is read while spans are off.
-pub struct Laps(Option<(Instant, Option<Duration>)>);
+pub struct Laps(Option<(Instant, Option<Duration>, usize)>);
 /// Start timing the steps of a function (see [`Laps`]).
 #[inline]
 pub fn laps() -> Laps {
-    Laps(recording_here().then(|| (Instant::now(), cpu_if_enabled())))
+    Laps(recording_here().then(|| (Instant::now(), cpu_if_enabled(), recorded())))
 }
 impl Laps {
    /// Record the step that just ended under `name`, and start the next.
    #[inline]
    pub fn lap(&mut self, name: &'static str) {
-        let Some((started, cpu)) = &mut self.0 else {
+        let Some((started, cpu, mark)) = &mut self.0 else {
            return;
        };
        let now = Instant::now();
        let now_cpu = cpu.and_then(|_| thread_cpu());
-        let ms = (now - *started).as_secs_f32() * 1000.0;
+        let elapsed = now - *started;
+        let ms = elapsed.as_secs_f32() * 1000.0;
        let cpu_ms = now_cpu
            .zip(*cpu)
            .map_or(ms, |(end, start)| (end - start).as_secs_f32() * 1000.0);
        let depth = DEPTH.with(Cell::get);
-        trace::span(name, *started, ms);
+        timeline::span(name, *started, elapsed, depth);
+        nest_since(*mark, depth);
        push(Span {
            name,
            ms,
            cpu_ms,
            depth,
        });
-        (*started, *cpu) = (now, now_cpu);
+        (*started, *cpu, *mark) = (now, now_cpu, recorded());
    }
 }
 /// The CPU time this thread has used, where the platform tells it: a tick
@@ -283,173 +289,176 @@ pub fn merge(spans: &[Span]) -> Vec<Span> {
    sums.sort_by(|a, b| b.ms.total_cmp(&a.ms));
    sums
 }
-/// `name wall` for spans of at least 0.5 ms, with `/cpu` when the thread
-/// worked for less than nine tenths of it: the slow-frame and slow-tick lines.
-pub fn describe(spans: &[Span]) -> String {
-    let list: Vec<String> = spans
-        .iter()
-        .filter(|s| s.ms >= 0.5)
-        .map(|s| {
-            if s.cpu_ms < s.ms * 0.9 {
-                format!("{} {:.1}/{:.1}", s.name, s.ms, s.cpu_ms)
-            } else {
-                format!("{} {:.1}", s.name, s.ms)
-            }
-        })
-        .collect();
-    list.join(", ")
-}
-
-/// The run's timeline: every span ([`time`], [`guard`], [`Laps::lap`]) on every thread, as
-/// Chrome trace events that Perfetto (ui.perfetto.dev) opens as they are. `HORIZON_TRACE=FILE`
-/// writes it from the start; [`start`](trace::start) and [`stop`](trace::stop) write one for a
-/// while (`horizon-trace` on a dedicated server's console, `trace` on the control socket). Spans
-/// show on their threads where they ran, nested by time, so what ran beside what, and what a
-/// thread waited for, can be read off. Off, a span costs one relaxed load more.
-pub mod trace {
+/// The run's timeline: every span on every thread, kept in per-thread buffers until a capture drains them as `timeline` chunks.
+pub mod timeline {
    use std::{
-        cell::Cell,
-        fs::File,
-        io::{BufWriter, Write as _},
-        path::Path,
+        cell::RefCell,
        sync::{
-            Mutex, PoisonError,
+            Arc, Mutex, PoisonError,
            atomic::{AtomicBool, AtomicU32, Ordering},
        },
-        time::Instant,
+        time::{Duration, Instant},
    };

+    /// The most spans a thread holds between two drains; a thread that records more drops them.
+    const THREAD_EVENTS_MAX: usize = 1 << 18;
+
    static ON: AtomicBool = AtomicBool::new(false);
-    static SINK: Mutex<Option<Sink>> = Mutex::new(None);
-    /// Counts the traces started: a thread names itself again in each one.
-    static TRACES: AtomicU32 = AtomicU32::new(0);
-    static NEXT_THREAD: AtomicU32 = AtomicU32::new(1);
-    thread_local! {
-        /// This thread's id in traces (0: none yet).
-        static THREAD: Cell<u32> = const { Cell::new(0) };
-        /// The trace this thread last named itself in.
-        static NAMED_IN: Cell<u32> = const { Cell::new(0) };
-    }
-    /// How often a trace's buffer goes to the file, at most: a run that ends without
-    /// [`stop`] loses no more than this.
-    const FLUSH_EVERY: std::time::Duration = std::time::Duration::from_secs(1);
+    static GENERATION: AtomicU32 = AtomicU32::new(0);
+    static RUN: Mutex<Option<Run>> = Mutex::new(None);

-    struct Sink {
-        file: BufWriter<File>,
+    struct Run {
        origin: Instant,
-        /// Until when it records ([`start`]'s `seconds`).
-        until: Option<Instant>,
-        flushed: Instant,
-        /// Events written: the next one is preceded by a comma.
-        events: u64,
-    }
-    impl Sink {
-        fn event(&mut self, event: std::fmt::Arguments) {
-            let comma = if self.events == 0 { "" } else { ",\n" };
-            let _ = write!(self.file, "{comma}{{\"pid\":1,{event}}}");
-            self.events += 1;
-        }
+        threads: Vec<Arc<Mutex<Thread>>>,
    }

-    /// Whether a trace is being written.
+    struct Thread {
+        name: String,
+        label: String,
+        events: Vec<Event>,
+    }
+
+    /// This thread's buffer in the timeline it last joined.
+    struct Mine {
+        generation: u32,
+        origin: Instant,
+        thread: Arc<Mutex<Thread>>,
+    }
+
+    thread_local! {
+        static MINE: RefCell<Option<Mine>> = const { RefCell::new(None) };
+    }
+
+    /// One finished span.
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    pub struct Event {
+        pub name: &'static str,
+        /// Microseconds from the timeline's start.
+        pub start_us: u64,
+        pub dur_us: u32,
+        /// How many spans it ran inside on its thread.
+        pub depth: u8,
+    }
+
+    /// The spans one thread finished since the last drain, in the order they finished.
+    #[derive(Debug, PartialEq, Eq)]
+    pub struct ThreadEvents {
+        /// The thread's name; threads alive together under one name get `#2`, `#3`... after it.
+        pub thread: String,
+        pub events: Vec<Event>,
+    }
+
+    /// Whether a timeline is being recorded.
    #[inline]
    pub fn on() -> bool {
        ON.load(Ordering::Relaxed)
    }

-    /// Starts a trace written to `path` (replacing a trace being written), for `seconds` or
-    /// until [`stop`].
-    pub fn start(path: &Path, seconds: Option<u32>) -> std::io::Result<()> {
-        let mut file = BufWriter::with_capacity(1 << 18, File::create(path)?);
-        file.write_all(b"[\n")?;
-        let now = Instant::now();
-        let sink = Sink {
-            file,
-            origin: now,
-            until: seconds.map(|s| now + std::time::Duration::from_secs(u64::from(s))),
-            flushed: now,
-            events: 0,
-        };
-        let mut slot = SINK.lock().unwrap_or_else(PoisonError::into_inner);
-        if let Some(old) = slot.take() {
-            close(old);
+    /// Starts recording, timed from `origin`; false when a timeline already runs (the process has one).
+    pub fn start(origin: Instant) -> bool {
+        let mut run = RUN.lock().unwrap_or_else(PoisonError::into_inner);
+        if run.is_some() {
+            return false;
        }
-        *slot = Some(sink);
-        TRACES.fetch_add(1, Ordering::Relaxed);
+        *run = Some(Run {
+            origin,
+            threads: Vec::new(),
+        });
+        GENERATION.fetch_add(1, Ordering::Relaxed);
        ON.store(true, Ordering::Relaxed);
-        Ok(())
+        true
    }

-    /// Starts the trace `HORIZON_TRACE` names, if it names one.
-    pub fn start_from_env() {
-        if let Some(path) = std::env::var_os("HORIZON_TRACE")
-            && let Err(e) = start(Path::new(&path), None)
-        {
-            log::warn!("Horizon: HORIZON_TRACE: {e}");
-        }
+    /// Takes what the threads finished since the last call.
+    pub fn drain() -> Vec<ThreadEvents> {
+        let run = RUN.lock().unwrap_or_else(PoisonError::into_inner);
+        run.as_ref().map_or_else(Vec::new, take_all)
    }

-    /// Ends the trace being written: the file is complete JSON. The events written so far
-    /// and whether one was being written.
-    pub fn stop() -> Option<u64> {
+    /// Stops recording and returns what the threads finished since the last drain.
+    pub fn finish() -> Vec<ThreadEvents> {
        ON.store(false, Ordering::Relaxed);
-        let sink = SINK.lock().unwrap_or_else(PoisonError::into_inner).take()?;
-        let events = sink.events;
-        close(sink);
-        Some(events)
+        let run = RUN.lock().unwrap_or_else(PoisonError::into_inner).take();
+        run.as_ref().map_or_else(Vec::new, take_all)
    }

-    /// Whether the trace being written has run its time ([`start`]'s `seconds`): the caller
-    /// then [`stop`]s it.
-    pub fn due() -> bool {
-        on() && SINK
-            .lock()
-            .unwrap_or_else(PoisonError::into_inner)
-            .as_ref()
-            .and_then(|s| s.until)
-            .is_some_and(|until| Instant::now() >= until)
+    fn take_all(run: &Run) -> Vec<ThreadEvents> {
+        run.threads
+            .iter()
+            .filter_map(|thread| {
+                let mut thread = thread.lock().unwrap_or_else(PoisonError::into_inner);
+                (!thread.events.is_empty()).then(|| ThreadEvents {
+                    thread: thread.label.clone(),
+                    events: std::mem::take(&mut thread.events),
+                })
+            })
+            .collect()
    }

-    fn close(mut sink: Sink) {
-        let _ = sink.file.write_all(b"\n]\n");
-        let _ = sink.file.flush();
+    /// Takes a buffer for this thread: the one of an exited thread of the same name, else a new one.
+    fn join() -> Option<Mine> {
+        let mut slot = RUN.lock().unwrap_or_else(PoisonError::into_inner);
+        let run = slot.as_mut()?;
+        let name = std::thread::current()
+            .name()
+            .unwrap_or("unnamed")
+            .to_owned();
+        let of_name =
+            |t: &Arc<Mutex<Thread>>| t.lock().unwrap_or_else(PoisonError::into_inner).name == name;
+        let thread = match run
+            .threads
+            .iter()
+            .find(|t| Arc::strong_count(t) == 1 && of_name(t))
+        {
+            Some(exited) => Arc::clone(exited),
+            None => {
+                let same = run.threads.iter().filter(|t| of_name(t)).count();
+                let label = if same == 0 {
+                    name.clone()
+                } else {
+                    format!("{name} #{}", same + 1)
+                };
+                let thread = Arc::new(Mutex::new(Thread {
+                    name,
+                    label,
+                    events: Vec::new(),
+                }));
+                run.threads.push(Arc::clone(&thread));
+                thread
+            }
+        };
+        Some(Mine {
+            generation: GENERATION.load(Ordering::Relaxed),
+            origin: run.origin,
+            thread,
+        })
    }

-    /// A span of this thread from `started`, `ms` long.
-    pub(super) fn span(name: &'static str, started: Instant, ms: f32) {
+    /// A span of this thread from `started`, `elapsed` long, inside `depth` others.
+    pub(super) fn span(name: &'static str, started: Instant, elapsed: Duration, depth: u8) {
        if !on() {
            return;
        }
-        let tid = THREAD.with(|t| {
-            if t.get() == 0 {
-                t.set(NEXT_THREAD.fetch_add(1, Ordering::Relaxed));
+        let generation = GENERATION.load(Ordering::Relaxed);
+        let _ = MINE.try_with(|mine| {
+            let mut mine = mine.borrow_mut();
+            if mine.as_ref().is_none_or(|m| m.generation != generation) {
+                *mine = join();
+            }
+            let Some(mine) = mine.as_ref() else {
+                return;
+            };
+            let event = Event {
+                name,
+                start_us: started.saturating_duration_since(mine.origin).as_micros() as u64,
+                dur_us: elapsed.as_micros().min(u128::from(u32::MAX)) as u32,
+                depth,
+            };
+            let mut thread = mine.thread.lock().unwrap_or_else(PoisonError::into_inner);
+            if thread.events.len() < THREAD_EVENTS_MAX {
+                thread.events.push(event);
            }
-            t.get()
        });
-        let trace = TRACES.load(Ordering::Relaxed);
-        let mut slot = SINK.lock().unwrap_or_else(PoisonError::into_inner);
-        let Some(sink) = slot.as_mut() else {
-            return;
-        };
-        if NAMED_IN.with(|n| n.replace(trace)) != trace {
-            let name = std::thread::current()
-                .name()
-                .unwrap_or("unnamed")
-                .replace(['"', '\\'], "_");
-            sink.event(format_args!(
-                r#""ph":"M","name":"thread_name","tid":{tid},"args":{{"name":"{name}"}}"#
-            ));
-        }
-        let ts = started.saturating_duration_since(sink.origin).as_secs_f64() * 1e6;
-        sink.event(format_args!(
-            r#""ph":"X","name":"{name}","tid":{tid},"ts":{ts:.3},"dur":{:.3}"#,
-            f64::from(ms) * 1e3
-        ));
-        let now = Instant::now();
-        if now.duration_since(sink.flushed) >= FLUSH_EVERY {
-            let _ = sink.file.flush();
-            sink.flushed = now;
-        }
    }
 }

@@ -654,6 +663,46 @@ mod tests {
        SWITCH.lock().unwrap_or_else(|e| e.into_inner())
    }

+    /// Samples taken inside a named span carry its id, with spans off, and the span is left after it.
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn samples_inside_a_span_carry_its_id() {
+        use horizon_threads::{sampler, work};
+        use std::time::{Duration, Instant};
+        let worker = std::thread::spawn(|| {
+            assert!(sampler::sampled_thread("spans-id-test"));
+            let config = sampler::Config {
+                hz: 1000,
+                ..Default::default()
+            };
+            let session = sampler::start(config, |n| n == "spans-id-test").unwrap();
+            let busy = |ms| {
+                let until = Instant::now() + Duration::from_millis(ms);
+                while Instant::now() < until {
+                    std::hint::black_box(0);
+                }
+            };
+            super::time("spans_id_test_named", || busy(60));
+            assert_eq!(sampler::span(), 0);
+            busy(60);
+            let mut spans = Vec::new();
+            session.stop(|_, r| spans.push(r.ctx.span));
+            spans
+        });
+        let spans = worker.join().unwrap();
+        let inside = |s: &u16| work::name(work::Space::Span, *s) == Some("spans_id_test_named");
+        let (named, plain) = (
+            spans.iter().filter(|s| inside(s)).count(),
+            spans.iter().filter(|s| **s == 0).count(),
+        );
+        assert!(
+            named > 30 && plain > 30,
+            "{named} named, {plain} outside of {} samples",
+            spans.len()
+        );
+        assert_eq!(named + plain, spans.len(), "no other span id");
+    }
+
    /// A slow tick's notes are its slowest steps, slowest first; short steps and steps on a
    /// thread that records no spans leave none.
    #[test]
@@ -680,8 +729,7 @@ mod tests {
        assert!(super::take_notes().is_empty(), "taking them clears them");
    }

-    /// Spans of one name add up; a span the thread spent mostly waiting
-    /// shows its CPU time after the wall time, short ones are left out.
+    /// Spans of one name add up, the slowest first; a span that waited keeps its small CPU time.
    #[test]
    fn spans_sum_by_name_and_show_waits() {
        super::SPANS.with(|s| {
@@ -723,7 +771,6 @@ mod tests {
            }
        );
        assert_eq!((spans[1].name, spans[1].ms), ("tick", 5.0));
-        assert_eq!(super::describe(&spans), "submit 30.0/0.2, tick 5.0");
        assert!(super::take().is_empty());
    }

@@ -843,6 +890,22 @@ mod tests {
        assert!(spans[0].ms >= 2.0);
    }

+    /// A span that ran during a lap belongs inside that lap, and not inside the next one.
+    #[test]
+    fn a_span_during_a_lap_nests_under_that_lap() {
+        let _switch = spans_switch();
+        let _ = super::take_raw();
+        super::enable(true);
+        let mut laps = super::laps();
+        super::time("inner", || {});
+        laps.lap("first");
+        laps.lap("second");
+        super::enable(false);
+        let spans = super::take_raw();
+        let depths: Vec<_> = spans.iter().map(|s| (s.name, s.depth)).collect();
+        assert_eq!(depths, [("inner", 1), ("first", 0), ("second", 0)]);
+    }
+
    /// The thread's CPU clock moves with work done on it, not with time
    /// spent asleep.
    #[cfg(any(unix, all(windows, target_arch = "x86_64")))]
@@ -865,4 +928,74 @@ mod tests {
        assert!(slept.as_millis() < 25, "{slept:?} while asleep");
        assert!(worked.as_millis() >= 10, "{worked:?} while busy");
    }
+
+    /// Each thread's finished spans reach the timeline with their depth and nesting in time; threads alive together under one name get labels of their own, ones after another share a lane.
+    #[test]
+    fn the_timeline_keeps_each_threads_spans_with_their_depth_and_place_in_time() {
+        use super::timeline;
+        use std::sync::{Arc, Barrier};
+        use std::time::{Duration, Instant};
+        let _switch = spans_switch();
+        assert!(timeline::start(Instant::now()));
+        assert!(
+            !timeline::start(Instant::now()),
+            "the process has one timeline"
+        );
+        let spawn = |name: &str, alive_with: Option<Arc<Barrier>>| {
+            std::thread::Builder::new()
+                .name(name.into())
+                .spawn(move || {
+                    super::time("outer", || {
+                        std::thread::sleep(Duration::from_millis(4));
+                        super::time("inner", || std::thread::sleep(Duration::from_millis(3)));
+                    });
+                    if let Some(barrier) = alive_with {
+                        barrier.wait();
+                    }
+                })
+                .unwrap()
+        };
+        spawn("tl-solo", None).join().unwrap();
+        let together = Arc::new(Barrier::new(2));
+        let twins = [
+            spawn("tl-twin", Some(together.clone())),
+            spawn("tl-twin", Some(together)),
+        ];
+        for twin in twins {
+            twin.join().unwrap();
+        }
+        spawn("tl-seq", None).join().unwrap();
+        spawn("tl-seq", None).join().unwrap();
+        let mut threads = timeline::finish();
+        threads.retain(|t| t.thread.starts_with("tl-"));
+        threads.sort_by(|a, b| a.thread.cmp(&b.thread));
+        let labels: Vec<_> = threads.iter().map(|t| t.thread.as_str()).collect();
+        assert_eq!(labels, ["tl-seq", "tl-solo", "tl-twin", "tl-twin #2"]);
+        for thread in &threads {
+            let runs = if thread.thread == "tl-seq" { 2 } else { 1 };
+            assert_eq!(thread.events.len(), 2 * runs, "{thread:?}");
+            for pair in thread.events.chunks(2) {
+                let [inner, outer] = pair else { unreachable!() };
+                assert_eq!((inner.name, inner.depth), ("inner", 1));
+                assert_eq!((outer.name, outer.depth), ("outer", 0));
+                assert!(
+                    inner.dur_us >= 3_000 && outer.dur_us >= 7_000,
+                    "{inner:?} {outer:?}"
+                );
+                assert!(inner.start_us >= outer.start_us + 4_000);
+                assert!(
+                    inner.start_us + u64::from(inner.dur_us)
+                        <= outer.start_us + u64::from(outer.dur_us)
+                );
+            }
+        }
+        let seq = threads.iter().find(|t| t.thread == "tl-seq").unwrap();
+        assert!(seq.events[2].start_us >= seq.events[1].start_us + u64::from(seq.events[1].dur_us));
+
+        spawn("tl-after", None).join().unwrap();
+        assert!(
+            timeline::drain().is_empty(),
+            "a stopped timeline records nothing"
+        );
+    }
 }
@@ -478,9 +478,9 @@ impl Sprites {
        let metadata = match horizon_core::prepared_files::read_to_string(
            &path.with_extension("png.mcmeta"),
        ) {
-            Ok(text) => Some(serde_json::from_str::<
+            Ok(text) => Some(crate::packs::first_json::<
                BTreeMap<String, Box<serde_json::value::RawValue>>,
-            >(&text)?),
+            >(text.as_bytes())?),
            Err(error) if error.kind() == std::io::ErrorKind::NotFound => None,
            Err(error) => return Err(error.into()),
        };
@@ -589,9 +589,9 @@ impl Sprites {
        let metadata = match horizon_core::prepared_files::read_to_string(
            &path.with_extension("png.mcmeta"),
        ) {
-            Ok(text) => Some(serde_json::from_str::<
+            Ok(text) => Some(crate::packs::first_json::<
                BTreeMap<String, Box<serde_json::value::RawValue>>,
-            >(&text)?),
+            >(text.as_bytes())?),
            Err(error) if error.kind() == std::io::ErrorKind::NotFound => None,
            Err(error) => return Err(error.into()),
        };
@@ -28,37 +28,7 @@ pub const IDLE_RELEASE: std::time::Duration = std::time::Duration::from_secs(5);
 /// Worker CPU time and job counts by kind, for benchmarks
 /// (`examples/gen_light_bench.rs`). Off unless enabled: a relaxed load per
 /// job then.
-pub mod job_stats {
-    use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
-    pub const KINDS: [&str; 7] = [
-        "load", "generate", "decorate", "finish", "light", "mesh", "other",
-    ];
-    static ENABLED: AtomicBool = AtomicBool::new(false);
-    static NANOS: [AtomicU64; 7] = [const { AtomicU64::new(0) }; 7];
-    static COUNT: [AtomicU64; 7] = [const { AtomicU64::new(0) }; 7];
-    pub fn enable(on: bool) {
-        ENABLED.store(on, Ordering::Relaxed);
-    }
-    pub(super) fn enabled() -> bool {
-        ENABLED.load(Ordering::Relaxed)
-    }
-    pub(super) fn add(kind: usize, nanos: u64) {
-        NANOS[kind].fetch_add(nanos, Ordering::Relaxed);
-        COUNT[kind].fetch_add(1, Ordering::Relaxed);
-    }
-    /// (kind, nanoseconds, count) since the last call; resets them.
-    pub fn take() -> Vec<(&'static str, u64, u64)> {
-        (0..KINDS.len())
-            .map(|i| {
-                (
-                    KINDS[i],
-                    NANOS[i].swap(0, Ordering::Relaxed),
-                    COUNT[i].swap(0, Ordering::Relaxed),
-                )
-            })
-            .collect()
-    }
-}
+pub mod job_stats;
 /// A chunk under generation, opaque to the streamer.
 pub type Proto = Box<dyn std::any::Any + Send>;
 /// Chunk generation in vanilla's stages: a neighbour-independent proto chunk
@@ -1070,6 +1040,8 @@ pub struct WorkerContext {
    pub light: Arc<LightTables>,
 }
 mod bounded;
+mod queue_census;
+pub use queue_census::QueueCensus;
 mod forced_cover;
 mod forced_ring;
 mod relight_now;
@@ -1466,7 +1438,7 @@ impl Streaming {
        let entities = std::mem::take(&mut chunk.entities);
        world.entities_pending.insert((chunk.x, chunk.z));
        if !entities.is_empty() {
-            world.loaded_entities.push(((chunk.x, chunk.z), entities));
+            world.queue_entity_nbt((chunk.x, chunk.z), entities);
        }
        self.generated_total += 1;
        // A chunk saved with its light needs no light job; its unlit
@@ -1683,6 +1655,7 @@ impl Streaming {
        &mut self,
        world: &mut World,
    ) -> (Vec<((i32, i32, i32), SectionMesh)>, Vec<Arc<Chunk>>) {
+        let mut hz_laps = crate::spans::laps();
        let mut uploads = Vec::new();
        if self.paused {
            return (uploads, Vec::new());
@@ -1708,6 +1681,7 @@ impl Streaming {
        self.scan_age = if sweep { 0 } else { self.scan_age + 1 };
        self.requeue();
        self.relight_edits(world);
+        hz_laps.lap("st_relight_edits");
        let deferred = std::mem::take(&mut self.deferred);
        let received = self.shared.done.take();
        // Meshes made stale meanwhile, freed with the uploaded ones (`free`).
@@ -1757,6 +1731,7 @@ impl Streaming {
                }
            }
        }
+        hz_laps.lap("st_results");
        self.free(stale);
        let mut removed = Vec::new();
        if sweep {
@@ -1827,6 +1802,7 @@ impl Streaming {
            }
            self.save_checked_out(written);
        }
+        hz_laps.lap("st_sweep");
        let (protos, finishing) = (&self.protos, &self.finishing);
        self.decorated.retain(|k| {
            protos.contains_key(k) || finishing.contains(k) || world.chunks.contains_key(k)
@@ -1858,6 +1834,7 @@ impl Streaming {
                self.submit(Some((x, z)), 0, Job::Finish(proto));
            }
        }
+        hz_laps.lap("st_finalize");
        // Decorate chunks whose 3x3 proto neighbourhood is available, in
        // vanilla's order: decoration is order dependent where write regions
        // overlap (see `DecorationOrder`).
@@ -1983,7 +1960,9 @@ impl Streaming {
                self.submit(Some((x, z)), 1, Job::Decorate(x, z, region, finals));
            }
        }
+        hz_laps.lap("st_decorate");
        self.schedule_generation(world, workers);
+        hz_laps.lap("st_generate");
        // Lighting once all neighbours exist, nearest first and only as
        // much of it as the workers can chew. Vanilla's light engine also
        // hands a bounded queue to its workers and reschedules what did
@@ -2019,6 +1998,7 @@ impl Streaming {
                Job::Light(x, z, region, self.sequence, self.sky_light),
            );
        }
+        hz_laps.lap("st_light");
        // A server draws nothing: its sections are never meshed.
        if !self.mesh {
            world.dirty_sections.clear();
@@ -2059,6 +2039,7 @@ impl Streaming {
                !back
            });
        }
+        hz_laps.lap("st_waiting");
        // Column by column: the checks below hold for all of a column's
        // sections, and columns waiting for light cost one look per frame.
        columns.extend(world.dirty_sections.columns());
@@ -2091,6 +2072,7 @@ impl Streaming {
            }
            candidates.push((self.distance(x, z), x, z, sections));
        }
+        hz_laps.lap("st_candidates");
        // Nearest first, and only as many sections as the workers can chew.
        // Every ready column used to be submitted at once, so at a wide
        // render distance the queue — and `meshing`, and each job's 3x3
@@ -0,0 +1,29 @@
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+pub const KINDS: [&str; 7] = [
+    "load", "generate", "decorate", "finish", "light", "mesh", "other",
+];
+static ENABLED: AtomicBool = AtomicBool::new(false);
+static NANOS: [AtomicU64; 7] = [const { AtomicU64::new(0) }; 7];
+static COUNT: [AtomicU64; 7] = [const { AtomicU64::new(0) }; 7];
+pub fn enable(on: bool) {
+    ENABLED.store(on, Ordering::Relaxed);
+}
+pub(super) fn enabled() -> bool {
+    ENABLED.load(Ordering::Relaxed)
+}
+pub(super) fn add(kind: usize, nanos: u64) {
+    NANOS[kind].fetch_add(nanos, Ordering::Relaxed);
+    COUNT[kind].fetch_add(1, Ordering::Relaxed);
+}
+/// (kind, nanoseconds, count) since the last call; resets them.
+pub fn take() -> Vec<(&'static str, u64, u64)> {
+    (0..KINDS.len())
+        .map(|i| {
+            (
+                KINDS[i],
+                NANOS[i].swap(0, Ordering::Relaxed),
+                COUNT[i].swap(0, Ordering::Relaxed),
+            )
+        })
+        .collect()
+}
@@ -0,0 +1,39 @@
+//! What the streamer's queues hold, for `horizon-ctl memory` and captures.
+use super::{Queued, Streaming};
+
+/// What the streamer's work queues hold, each as (entries, estimated bytes).
+#[derive(Debug, Default)]
+pub struct QueueCensus {
+    /// Jobs queued and chunks generating.
+    pub generation: (usize, usize),
+    /// Chunks being lit and the edit log their jobs replay.
+    pub light: (usize, usize),
+}
+
+impl Streaming {
+    /// The queues' lengths and the bytes of their tables, from capacities. For `horizon-ctl memory`.
+    pub fn queue_census(&self) -> QueueCensus {
+        use std::mem::size_of;
+        let table = |capacity: usize, entry: usize| capacity * (entry + 1);
+        let queued = {
+            let queue = self.shared.queue.lock().unwrap();
+            (queue.len(), queue.capacity() * size_of::<Queued>())
+        };
+        QueueCensus {
+            generation: (
+                queued.0 + self.generating.len(),
+                queued.1 + table(self.generating.capacity(), size_of::<(i32, i32)>()),
+            ),
+            light: (
+                self.lighting.len(),
+                table(self.lighting.capacity(), size_of::<((i32, i32), u64)>())
+                    + table(
+                        self.light_snapshots.capacity(),
+                        size_of::<((i32, i32), u64)>(),
+                    )
+                    + self.light_log.capacity() * size_of::<(u64, (i32, i32, i32))>()
+                    + self.light_scratch.capacity() * size_of::<(i64, i32, i32)>(),
+            ),
+        }
+    }
+}
@@ -104,7 +104,7 @@ pub fn read_metadata(root: &Path) -> UiMetadata {
        let Ok(text) = horizon_core::prepared_files::read_to_string(&p) else {
            continue;
        };
-        let Some(nine_slice) = serde_json::from_str(&text)
+        let Some(nine_slice) = crate::packs::first_json(text.as_bytes())
            .ok()
            .as_ref()
            .and_then(parse_nine_slice)
@@ -2025,6 +2025,28 @@ impl EditBox {
 mod tests {
    use super::*;

+    #[test]
+    fn notes_after_a_sprites_metadata_keep_its_nine_slice() {
+        // Gson stops reading after the first value, so vanilla keeps this nine slice
+        // (CozyUI+'s highlighted button, #3046).
+        let root = std::env::temp_dir().join(format!("horizon-ui-meta-{}", std::process::id()));
+        let widget = root.join("assets/minecraft/textures/gui/sprites/widget");
+        std::fs::create_dir_all(&widget).unwrap();
+        std::fs::write(
+            widget.join("button_highlighted.png.mcmeta"),
+            "{\"gui\": {\"scaling\": {\"type\": \"nine_slice\", \"width\": 80, \"height\": 20,\n\
+             \"border\": {\"left\": 34, \"top\": 8, \"right\": 34, \"bottom\": 8}}}}\n\n// 0  10\n// 1  8\n",
+        )
+        .unwrap();
+        let metadata = read_metadata(&root);
+        std::fs::remove_dir_all(&root).unwrap();
+        let slice = metadata.0["gui/sprites/widget/button_highlighted"];
+        assert_eq!(
+            (slice.width, slice.height, slice.border),
+            (80, 20, [34, 8, 34, 8])
+        );
+    }
+
    /// The quads' destination rectangles and their UVs.
    fn quads(batch: &HudBatch) -> Vec<([f32; 4], [f32; 4])> {
        batch
@@ -9,6 +9,9 @@ use horizon_core::random::{LegacyRandom, LevelRandom};
 use horizon_world::registry::BlockStateId;
 use std::sync::Arc;

+mod pending_entity;
+pub use pending_entity::{EntityLoadReason, PendingEntity};
+
 mod modified;
 pub use modified::ModifiedChunks;

@@ -81,7 +84,7 @@ pub struct World {
    /// incrementally by streaming.
    pub light_edits: Vec<((i32, i32, i32), u32, u32)>,
    /// Saved entities of chunks that just loaded, spawned by the game.
-    pub loaded_entities: Vec<((i32, i32), Vec<horizon_world::nbt::Tag>)>,
+    pub loaded_entities: Vec<((i32, i32), Vec<PendingEntity>)>,
    /// Chunks loaded since the level's last pass, their entity sections not
    /// ready yet (`PersistentEntitySectionManager`'s PENDING), empty ones too:
    /// the pass ends by readying them (`processPendingLoads`).
@@ -215,6 +218,12 @@ impl Weather {
    }
 }
 impl World {
+    /// Queue ordinary NBT; transient transfer state is never decoded from it.
+    pub fn queue_entity_nbt(&mut self, key: (i32, i32), tags: Vec<horizon_world::nbt::Tag>) {
+        self.loaded_entities
+            .push((key, tags.into_iter().map(PendingEntity::from).collect()));
+    }
+
    pub fn new(air: BlockStateId, seed: i64) -> Self {
        Self {
            shape: LevelShape::OVERWORLD,
@@ -0,0 +1,89 @@
+//! Pending entity NBT and the runtime context that must not be stored inside it.
+use horizon_world::nbt::Tag;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum EntityLoadReason {
+    Ordinary,
+    TeleportedTnt,
+}
+
+#[derive(Clone, Debug)]
+pub struct PendingEntity {
+    tag: Tag,
+    reason: EntityLoadReason,
+}
+
+impl From<Tag> for PendingEntity {
+    fn from(tag: Tag) -> Self {
+        Self {
+            tag,
+            reason: EntityLoadReason::Ordinary,
+        }
+    }
+}
+
+impl PendingEntity {
+    /// Only an in-memory TNT transfer supplies this context, never saved NBT.
+    pub fn after_tnt_portal(tag: Tag) -> Self {
+        Self {
+            tag,
+            reason: EntityLoadReason::TeleportedTnt,
+        }
+    }
+
+    pub fn into_parts(self) -> (Tag, EntityLoadReason) {
+        (self.tag, self.reason)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ordinary_nbt_cannot_request_transient_portal_state() {
+        for marker in [0, 1] {
+            let tag = Tag::compound([("horizon:tnt_used_portal", Tag::Byte(marker))]);
+            let (loaded, reason) = PendingEntity::from(tag.clone()).into_parts();
+            assert_eq!(loaded, tag);
+            assert_eq!(reason, EntityLoadReason::Ordinary);
+        }
+    }
+
+    #[test]
+    fn queue_swaps_and_appends_keep_each_entitys_context_and_order() {
+        let ordinary = Tag::compound([("id", Tag::String("ordinary".into()))]);
+        let transfer = Tag::compound([("id", Tag::String("transfer".into()))]);
+        let mut batches = vec![(
+            (1, 2),
+            vec![
+                ordinary.clone().into(),
+                PendingEntity::after_tnt_portal(transfer.clone()),
+            ],
+        )];
+        let mut waiting = std::mem::take(&mut batches);
+        batches.push(((3, 4), vec![ordinary.clone().into()]));
+        waiting.append(&mut batches);
+        assert!(batches.is_empty());
+        let mut batches = waiting.into_iter();
+        let (key, entities) = batches.next().unwrap();
+        assert_eq!(key, (1, 2));
+        let mut entities = entities.into_iter();
+        assert_eq!(
+            entities.next().unwrap().into_parts(),
+            (ordinary.clone(), EntityLoadReason::Ordinary)
+        );
+        assert_eq!(
+            entities.next().unwrap().into_parts(),
+            (transfer, EntityLoadReason::TeleportedTnt)
+        );
+        assert!(entities.next().is_none());
+        let (key, entities) = batches.next().unwrap();
+        assert_eq!(key, (3, 4));
+        assert_eq!(
+            entities.into_iter().next().unwrap().into_parts(),
+            (ordinary, EntityLoadReason::Ordinary)
+        );
+        assert!(batches.next().is_none());
+    }
+}
@@ -26,6 +26,7 @@ horizon-hooks = { path = "../horizon-hooks" }
 horizon-optifine = { path = "../horizon-optifine" }
 # The server thread ahead of the workers (MinecraftServer.spin's Thread.setPriority).
 horizon-threads = { path = "../horizon-threads" }
+horizon-perf-format = { path = "../horizon-perf-format" }
 horizon-hdr = { path = "../horizon-hdr" }
 horizon-world = { path = "../horizon-world" }
 horizon-protocol = { path = "../horizon-protocol" }
@@ -134,7 +135,9 @@ friends = ["dep:horizon-friends"]
 rng-trace = ["horizon-core/rng-trace", "horizon-client-lib/rng-trace"]
 # Rust's allocations go to the system heap instead of mimalloc, where heap profilers that replace
 # malloc (heaptrack, valgrind's massif) see them. For profiling only: mimalloc is faster.
-system-allocator = []
+system-allocator = ["horizon-threads/system-allocator"]
+# mimalloc that counts each thread's allocations and frees (`stats` replies with `alloc`).
+alloc-count = ["horizon-threads/alloc-count"]
 # mimalloc with a tag on each block: `horizon-ctl memory` lists the live heap by startup step and
 # thread (`heap_by_tag_mb`). For measuring only: each block costs 16 bytes more.
 alloc-census = ["horizon-threads/alloc-census"]
@@ -178,5 +181,6 @@ workspace = true
 [dev-dependencies]
 horizon-client-render = { path = "../horizon-client-render", features = ["test-support"] }
 horizon-items = { path = "../horizon-items", features = ["test-support"] }
+horizon-perf = { path = "../horizon-perf" }
 # Every WGSL shader translated as wgpu's DirectX 12 backend does (gfx.rs tests).
 naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out", "msl-out", "spv-out"] }
@@ -316,6 +316,7 @@
  "horizon.multiplayer.invite_code": "Invite Code",
  "horizon.multiplayer.relay": "Relay (optional)",
  "Preset": "Preset",
+  "Horizon Preset": "Horizon Preset",
  "LOD Distance": "LOD Distance",
  "Far Detail": "Far Detail",
  "Cave Culling": "Cave Culling",
@@ -707,6 +708,9 @@
  "Pick a shader pack. Picking the one in use turns shaders off.": "Pick a shader pack. Picking the one in use turns shaders off.",
  "Changed options apply with Apply, or when you leave.": "Changed options apply with Apply, or when you leave.",
  "Pack settings": "Pack settings",
+  "Whole pack": "Whole pack",
+  "Reset all": "Reset all",
+  "Every option is at its default already.": "Every option is at its default already.",
  "Built-in settings": "Built-in settings",
  "%s settings": "%s settings",
  "Settings made by the pack's author: they change only this pack.": "Settings made by the pack's author: they change only this pack.",
@@ -1129,6 +1133,34 @@
  "horizon.recipe_transfer.no_room": "Inventory full",
  "horizon.recipe_transfer.unavailable": "Recipe does not fit this menu",
  "horizon.recipe_transfer.unsupported": "Server requires a known recipe",
+  "horizon.debug.pass_detail.title": "Horizon pass detail (%s)",
+  "horizon.debug.pass_detail.inside_passes": "timestamps inside passes",
+  "horizon.debug.pass_detail.separate_passes": "separate passes, adds GPU time",
+  "horizon.debug.pass_detail.part": "%s › %s: %s ms",
+  "horizon.debug.pass_detail.counters": "%s: %s fragments, %s per pixel, %s vertices, %s of %s triangles kept",
+  "horizon.debug.pass_detail.no_counters": "GPU counters: Vulkan only",
+  "horizon.perf.started": "Profiling the client and server. %s",
+  "horizon.perf.uploading": "Uploading the profile…",
+  "horizon.perf.shared": "Shared: %s %s",
+  "horizon.perf.upload_failed": "Could not share the profile: %s. %s",
+  "horizon.perf.upload_interrupted": "the upload worker stopped",
+  "horizon.perf.unavailable": "Opening and sharing profiles is not available in this build.",
+  "horizon.perf.share_missing": "No profile saved in this session yet. %s",
+  "horizon.perf.saved": "Profile saved (%s s). %s",
+  "horizon.perf.open_button": "[Open]",
+  "horizon.perf.open_hover": "Open this profile in your browser. It is served once to your own browser and goes nowhere else.",
+  "horizon.perf.share_button": "[Share]",
+  "horizon.perf.share_hover": "Upload this profile and get a link to share. Nothing is uploaded until you click this.",
+  "horizon.perf.opened": "Opened in your browser",
+  "horizon.perf.open_failed": "Could not open the profile: %s. %s",
+  "horizon.perf.not_found": "No saved profile named %s.",
+  "horizon.perf.error": "Profiler: %s",
+  "horizon.perf.not_horizon": "this server isn't running Horizon",
+  "horizon.perf.denied": "a server profile needs operator level 4",
+  "horizon.perf.already_running": "the server is already running a profile",
+  "horizon.perf.not_running": "no server profile of yours is running",
+  "horizon.perf.failed": "the server could not write the profile; see its log",
+  "horizon.perf.part_incomplete": "the server's part of the profile did not arrive whole",
  "horizon.studio.timeline.freecam_on": "Freecam: ON",
  "horizon.studio.timeline.freecam_off": "Freecam: OFF",
  "horizon.studio.timeline.freecam_short": "Cam",
@@ -1164,5 +1196,25 @@
  "horizon.studio.topbar.split_scene": "Split Scene",
  "horizon.recipes.fuel.options": "Hold SHIFT to pin this tooltip, then click an ingredient to view recipes.",
  "horizon.recipes.fuel.any": "Any Fuel",
-  "horizon.recipes.fuel.minecraft": "Minecraft"
+  "horizon.recipes.fuel.minecraft": "Minecraft",
+  "horizon.perf.idle": "Not profiling. %s",
+  "horizon.perf.marked": "Marked %s",
+  "horizon.perf.started.client": "Profiling the client. %s",
+  "horizon.perf.started.server": "Profiling the server. %s",
+  "horizon.perf.saving": "Saving the profile…",
+  "horizon.perf.running.client": "Profiling the client for %s s. %s",
+  "horizon.perf.running.server": "Profiling the server for %s s. %s",
+  "horizon.perf.running.both": "Profiling the client and server for %s s. %s",
+  "horizon.perf.client_only": "Profiling the client only: %s",
+  "horizon.perf.stop_button": "[Stop]",
+  "horizon.perf.stop_hover": "Stop profiling and save the profile.",
+  "horizon.perf.start_button": "[Start]",
+  "horizon.perf.start_hover": "Start profiling.",
+  "horizon.perf.folder_button": "[Folder]",
+  "horizon.perf.folder_hover": "Show %s in its folder.",
+  "horizon.perf.copy_button": "[Copy]",
+  "horizon.perf.copy_hover": "Copy the link.",
+  "horizon.perf.retry_button": "[Retry]",
+  "horizon.perf.retry_hover": "Try the upload again. The profile is still saved on your computer.",
+  "horizon.perf.link_hover": "Open the shared profile in your browser."
 }
@@ -21,5 +21,19 @@ fn main() {
    if !staged.is_empty() {
        println!("cargo:rustc-env=HORIZON_MIXIN_MODS={}", staged.join(","));
    }
+    // Whether a native mod can run in a mob's turn (`game/creatures/mob_islands.rs`). The
+    // launcher adds trait packages to the workspace's members.
+    println!(
+        "cargo:rerun-if-changed={}",
+        root.join("Cargo.toml").display()
+    );
+    for dir in ["native-api", "native-crates"] {
+        if root.join(dir).is_dir() {
+            println!("cargo:rerun-if-changed={}", root.join(dir).display());
+        }
+    }
+    if let Some(found) = horizon_mod_api_gen::mob_turn(&root) {
+        println!("cargo:rustc-env=HORIZON_MOB_TURN={found}");
+    }
    windows_exe::resources("horizon-client");
 }
@@ -318,6 +318,8 @@ pub fn main() -> horizon_client::Result<()> {
                        Ok(())
                    }
                    drops::Drop::Orb(v) => writeln!(out, "orb {v}"),
+                    // The star's `setExtendedLifetime` is no part of the loot.
+                    drops::Drop::Aged(s, _) => writeln!(out, "{}", line(&s)),
                };
            }
        }
@@ -1517,10 +1517,8 @@ fn predicate_references(
                .unwrap_or("");
            match &*full(kind) {
                "minecraft:inverted" => predicate_references(&v["term"], w, active),
-                "minecraft:all_of" | "minecraft:any_of" => v["terms"]
-                    .as_array()
-                    .into_iter()
-                    .flatten()
+                "minecraft:all_of" | "minecraft:any_of" => terms(v)
+                    .iter()
                    .try_for_each(|v| predicate_references(v, w, active)),
                _ => Ok(()),
            }
@@ -1529,6 +1527,16 @@ fn predicate_references(
    }
 }

+/// `terms` as `HolderSetCodec` reads it: a list, or one holder alone; a `#tag` is not expanded.
+fn terms(v: &Value) -> &[Value] {
+    match &v["terms"] {
+        Value::Array(list) => list,
+        Value::Null => &[],
+        Value::String(tag) if tag.starts_with('#') => &[],
+        one => std::slice::from_ref(one),
+    }
+}
+
 /// The existing condition traversal with a caller-owned leaf context.
 /// Leaves run synchronously, in order, with normal boolean short-circuiting.
 pub fn conditions_with(
@@ -1547,16 +1555,8 @@ pub fn conditions_with(
                .unwrap_or("");
            match &*full(ty) {
                "minecraft:inverted" => !conditions_with(&v["term"], ctx, test),
-                "minecraft:all_of" => v["terms"]
-                    .as_array()
-                    .into_iter()
-                    .flatten()
-                    .all(|t| conditions_with(t, ctx, test)),
-                "minecraft:any_of" => v["terms"]
-                    .as_array()
-                    .into_iter()
-                    .flatten()
-                    .any(|t| conditions_with(t, ctx, test)),
+                "minecraft:all_of" => terms(v).iter().all(|t| conditions_with(t, ctx, test)),
+                "minecraft:any_of" => terms(v).iter().any(|t| conditions_with(t, ctx, test)),
                _ => test(v, ctx),
            }
        }
@@ -11,6 +11,7 @@ use std::sync::mpsc::{self, Sender};
 use std::thread;
 use std::time::{Duration, Instant};

+use horizon_bench::compare::Ab;
 use horizon_bench::{App, Frames, Kind, Report};
 use serde_json::Value;

@@ -54,14 +55,105 @@ const FLIGHT_SECONDS: f64 = 12.0;
 const SETTLE: Duration = Duration::from_secs(2);
 const LOAD_LIMIT: Duration = Duration::from_secs(600);

-/// `standard` flies every scene; a scene's name flies only that one.
-pub fn scenes(scenario: &str) -> Option<Vec<Scene>> {
-    match scenario {
-        "standard" => Some(SCENES.to_vec()),
-        name => SCENES.iter().find(|s| s.0 == name).map(|s| vec![*s]),
+/// Where the trip starts and ends: 512 blocks at 16 blocks/s, the pace that scrambles section ids.
+const TRAVEL_FROM: [f64; 3] = [-960.0, 150.0, -176.0];
+const TRAVEL_TO: [f64; 3] = [-960.0, 150.0, 336.0];
+const TRAVEL_PITCH: f64 = 30.0;
+const TRAVEL_SECONDS: f64 = 32.0;
+const HOLD_BLOCKS: u32 = 4;
+const BLOCK_SECONDS: f64 = 4.0;
+const WARMUP_SECONDS: f64 = 2.0;
+const PAIRS: u32 = 8;
+/// Frame-rate settings the benchmark can set for a run; `a` is the default.
+pub struct Switch {
+    pub name: &'static str,
+    pub word: &'static str,
+    pub key: &'static str,
+    pub a: &'static str,
+    pub b: &'static str,
+}
+pub const SWITCHES: [Switch; 4] = [
+    Switch {
+        name: "gpu-culling",
+        word: "gpu-culling",
+        key: "gpu_culling",
+        a: "off",
+        b: "on",
+    },
+    Switch {
+        name: "section-cull",
+        word: "section-cull",
+        key: "cull",
+        a: "on",
+        b: "off",
+    },
+    Switch {
+        name: "section-sides",
+        word: "section-sides",
+        key: "sides",
+        a: "on",
+        b: "off",
+    },
+    Switch {
+        name: "section-draws",
+        word: "section-draws",
+        key: "flat",
+        a: "flat",
+        b: "indirect",
+    },
+];
+
+/// What `--benchmark` runs.
+pub enum Scenario {
+    /// `standard` flies every scene; a scene's name flies only that one.
+    Scenes(Vec<Scene>),
+    /// A 512-block flight, then held at its end.
+    Travel,
+    /// The flight with the switch's B applied, then its two values interleaved B A A B.
+    Ab(&'static Switch),
+}
+
+impl Scenario {
+    pub fn parse(name: &str) -> Result<Scenario, String> {
+        match name {
+            "standard" => Ok(Scenario::Scenes(SCENES.to_vec())),
+            "travel" => Ok(Scenario::Travel),
+            name if name.starts_with("ab:") => SWITCHES
+                .iter()
+                .find(|s| s.name == &name[3..])
+                .map(Scenario::Ab)
+                .ok_or_else(|| {
+                    format!(
+                        "unknown switch {}: {}",
+                        &name[3..],
+                        SWITCHES.map(|s| s.name).join(", ")
+                    )
+                }),
+            name => SCENES
+                .iter()
+                .find(|s| s.0 == name)
+                .map(|s| Scenario::Scenes(vec![*s]))
+                .ok_or_else(|| {
+                    format!("unknown benchmark {name}: standard, village, forest, ocean, mountain, travel or ab:SWITCH ({})", SWITCHES.map(|s| s.name).join(", "))
+                }),
+        }
    }
 }

+/// `--benchmark-set SWITCH=VALUE`: the value must be one of the switch's two.
+pub fn parse_set(value: &str) -> Result<(String, String), String> {
+    let (name, setting) = value.split_once('=').ok_or("expected SWITCH=VALUE")?;
+    let names = || SWITCHES.map(|s| s.name).join(", ");
+    let switch = SWITCHES
+        .iter()
+        .find(|s| s.name == name)
+        .ok_or_else(|| format!("unknown switch {name}: {}", names()))?;
+    if setting != switch.a && setting != switch.b {
+        return Err(format!("{name} is {} or {}", switch.a, switch.b));
+    }
+    Ok((name.to_owned(), setting.to_owned()))
+}
+
 /// What the game knows about the run before it starts.
 pub struct Setup {
    pub scenario: String,
@@ -73,6 +165,10 @@ pub struct Setup {
    pub fps_cap: Option<u32>,
    pub offscreen: bool,
    pub game_dir: PathBuf,
+    /// `--benchmark-set`: a switch and its value, applied before the world opens.
+    pub set: Option<(String, String)>,
+    /// `--profile`: record a .hzperf capture of the run and embed the report in it.
+    pub profile: bool,
 }

 /// Starts the driver; the game quits when it is done, and the report's path is printed.
@@ -150,8 +246,7 @@ fn time_passes(control: &Control, scene: &str, report: &mut Report) -> Result<bo
 }

 fn run(control: &Control, setup: Setup) -> Result<PathBuf, String> {
-    let scenes =
-        scenes(&setup.scenario).ok_or_else(|| format!("unknown scenario {}", setup.scenario))?;
+    let scenario = Scenario::parse(&setup.scenario)?;
    let mut report = Report::new(Kind::Game, setup.app.clone());
    let pid = std::process::id();
    report.conditions.load_avg_1m = horizon_bench::load_average();
@@ -191,85 +286,12 @@ fn run(control: &Control, setup: Setup) -> Result<PathBuf, String> {
        horizon_telemetry::system::storage(&setup.game_dir).map(str::to_owned);
    report.hardware.display = serde_json::from_value(title["display"].clone()).ok();

-    replace_world(&setup.game_dir)?;
-    control.call(&format!("open {WORLD} {SEED} creative"))?;
-    // The world opens on a worker: its folder may not exist yet when `open` replies.
-    std::fs::create_dir_all(setup.game_dir.join("saves").join(WORLD)).map_err(|e| e.to_string())?;
-    std::fs::write(
-        setup.game_dir.join("saves").join(WORLD).join(MARKER),
-        "Created by horizon-client --benchmark; replaced by the next run.\n",
-    )
-    .map_err(|e| e.to_string())?;
-    let loaded = wait_loaded(control, |_| true)?;
-    report.metric("startup.world_ms", &[ms(loaded - setup.started)]);
-
    let mut steady = Vec::new();
-    for (name, start, end, pitch) in scenes {
-        control.call("time 6000")?;
-        let meshed = control.status()["meshed_sections"].as_f64().unwrap_or(0.0);
-        let generated = control.status()["generated_chunks"].as_f64().unwrap_or(0.0);
-        let [x, y, z] = start;
-        control.call(&format!("tp {x} {y} {z}"))?;
-        let teleported = Instant::now();
-        // A zero-length flight holds the player at the start, flying.
-        control.call(&format!("fly {x} {y} {z} {x} {y} {z} 0.1 {pitch}"))?;
-        control.call(&format!("look {:.3} {pitch}", yaw(start, end)))?;
-        let near = |p: &Value| {
-            let p: Vec<f64> = p
-                .as_array()
-                .into_iter()
-                .flatten()
-                .filter_map(Value::as_f64)
-                .collect();
-            p.len() == 3 && (0..3).map(|i| (p[i] - start[i]).powi(2)).sum::<f64>() < 4.0
-        };
-        let loaded = wait_loaded(control, near)?;
-        let load = loaded - teleported;
-        report.metric(&format!("chunks.{name}.load_ms"), &[ms(load)]);
-        let status = control.status();
-        let meshes = status["meshed_sections"].as_f64().unwrap_or(0.0) - meshed;
-        let chunks = status["generated_chunks"].as_f64().unwrap_or(0.0) - generated;
-        report.metric(&format!("chunks.{name}.meshed_count"), &[meshes]);
-        report.metric(&format!("chunks.{name}.generated_count"), &[chunks]);
-        if load.as_secs_f64() > 0.0 {
-            report.metric(
-                &format!("chunks.{name}.generated_per_s"),
-                &[chunks / load.as_secs_f64()],
-            );
-        }
-        if !time_passes(control, name, &mut report)? {
-            thread::sleep(SETTLE);
-        }
-        let [ex, ey, ez] = end;
-        let begin = Instant::now();
-        let flight = control.call(&format!(
-            "fly {x} {y} {z} {ex} {ey} {ez} {FLIGHT_SECONDS} {pitch} raw"
-        ))?;
-        steady.push((begin, Instant::now()));
-        let series = |key: &str| -> Vec<f32> {
-            flight[key]
-                .as_array()
-                .into_iter()
-                .flatten()
-                .filter_map(Value::as_f64)
-                .map(|v| v as f32)
-                .collect()
-        };
-        let frames = Frames::of(
-            name,
-            0,
-            &series("frame_ms"),
-            &series("cpu_ms"),
-            &series("gpu_ms"),
-        )
-        .ok_or("the flight drew no frames")?;
-        report.metric(&format!("fps.{name}.avg_fps"), &[frames.avg_fps]);
-        report.metric(&format!("fps.{name}.low_1pct_fps"), &[frames.low_1pct_fps]);
-        report.metric(
-            &format!("fps.{name}.low_01pct_fps"),
-            &[frames.low_01pct_fps],
-        );
-        report.frames.push(frames);
+    match &scenario {
+        Scenario::Ab(switch) => keeping_switch(control, switch, || {
+            measure(control, &setup, &scenario, &mut report, &mut steady)
+        })?,
+        _ => measure(control, &setup, &scenario, &mut report, &mut steady)?,
    }

    let status = control.status();
@@ -287,8 +309,12 @@ fn run(control: &Control, setup: Setup) -> Result<PathBuf, String> {
    c.vsync = Some(setup.vsync);
    c.fps_cap = setup.fps_cap;
    c.offscreen = Some(setup.offscreen);
-    c.repeats = Some(1);
-    c.warmup_s = Some(SETTLE.as_secs_f64());
+    let (repeats, warmup) = match scenario {
+        Scenario::Travel => (HOLD_BLOCKS, None),
+        Scenario::Ab(_) => (2 * PAIRS, Some(WARMUP_SECONDS)),
+        Scenario::Scenes(_) => (1, Some(SETTLE.as_secs_f64())),
+    };
+    (c.repeats, c.warmup_s) = (Some(repeats), warmup);
    if let Some(bytes) = renderer["gpu_allocated_bytes"].as_f64() {
        report.metric("memory.gpu_mb", &[bytes / f64::from(1 << 20)]);
    }
@@ -312,9 +338,342 @@ fn run(control: &Control, setup: Setup) -> Result<PathBuf, String> {
        report.metric("game.binary_bytes", &[meta.len() as f64]);
    }
    crate::telemetry::keep_benchmark(&crate::logging::game_home(), &report);
-    report
+    let written = report
        .write_to(&setup.game_dir.join("benchmarks"))
-        .map_err(|e| e.to_string())
+        .map_err(|e| e.to_string())?;
+    if setup.profile {
+        match control.call(&stop_capture(&written)) {
+            Ok(done) => println!("Horizon: benchmark capture {}", text(&done["path"])),
+            Err(e) => eprintln!("Horizon: the benchmark capture failed: {e}"),
+        }
+    }
+    Ok(written)
+}
+
+/// Starts the capture the run's frames feed; its trigger is the benchmark's.
+const START_CAPTURE: &str = "profile client start";
+
+/// Ends the capture with the written report embedded in it.
+fn stop_capture(report: &Path) -> String {
+    format!("profile client stop --bench {}", report.display())
+}
+
+/// Opens the benchmark world and flies the scenario in it.
+fn measure(
+    control: &Control,
+    setup: &Setup,
+    scenario: &Scenario,
+    report: &mut Report,
+    steady: &mut Vec<(Instant, Instant)>,
+) -> Result<(), String> {
+    match (scenario, &setup.set) {
+        (Scenario::Ab(switch), _) => apply_set(control, switch.name, switch.b)?,
+        (_, Some((name, value))) => apply_set(control, name, value)?,
+        _ => {}
+    }
+    replace_world(&setup.game_dir)?;
+    control.call(&format!("open {WORLD} {SEED} creative"))?;
+    // The world opens on a worker: its folder may not exist yet when `open` replies.
+    std::fs::create_dir_all(setup.game_dir.join("saves").join(WORLD)).map_err(|e| e.to_string())?;
+    std::fs::write(
+        setup.game_dir.join("saves").join(WORLD).join(MARKER),
+        "Created by horizon-client --benchmark; replaced by the next run.\n",
+    )
+    .map_err(|e| e.to_string())?;
+    let loaded = wait_loaded(control, |_| true)?;
+    report.metric("startup.world_ms", &[ms(loaded - setup.started)]);
+
+    if setup.profile {
+        control.call(START_CAPTURE)?;
+    }
+
+    match scenario {
+        Scenario::Scenes(scenes) => {
+            for &(name, start, end, pitch) in scenes {
+                control.call("time 6000")?;
+                load_scene(control, name, start, end, pitch, report)?;
+                if !time_passes(control, name, report)? {
+                    thread::sleep(SETTLE);
+                }
+                let frames = fly(control, name, start, end, FLIGHT_SECONDS, pitch, steady)?;
+                fps_metrics(report, name, std::slice::from_ref(&frames));
+                report.frames.push(frames);
+            }
+        }
+        Scenario::Travel => travel(control, report, steady)?,
+        Scenario::Ab(switch) => {
+            trip(control, report, steady)?;
+            let plan = Plan {
+                pairs: PAIRS,
+                warmup: Duration::from_secs_f64(WARMUP_SECONDS),
+            };
+            ab_blocks(control, switch, &plan, report, steady)?;
+        }
+    }
+    Ok(())
+}
+
+/// Reads a switch before the run and puts it back after, whatever the run did and however it ended.
+fn keeping_switch<T>(
+    control: &Control,
+    switch: &Switch,
+    run: impl FnOnce() -> Result<T, String>,
+) -> Result<T, String> {
+    let initial = control.call(switch.word)?[switch.key].clone();
+    let result = run();
+    let restored = restore(control, switch, &initial);
+    match result {
+        Ok(value) => restored.map(|()| value),
+        Err(e) => Err(e),
+    }
+}
+
+/// Sends the arm whose reply has the value the switch had.
+fn restore(control: &Control, switch: &Switch, initial: &Value) -> Result<(), String> {
+    if control.call(switch.word)?[switch.key] == *initial {
+        return Ok(());
+    }
+    for value in [switch.a, switch.b] {
+        if control.call(&format!("{} {value}", switch.word))?[switch.key] == *initial {
+            return Ok(());
+        }
+    }
+    Err(format!("{} could not be put back", switch.name))
+}
+
+/// Sets a switch with its control word; a refusal (GPU culling not offered) is the game's reason.
+fn apply_set(control: &Control, name: &str, value: &str) -> Result<(), String> {
+    let switch = SWITCHES
+        .iter()
+        .find(|s| s.name == name)
+        .ok_or("unknown switch")?;
+    control.call(&format!("{} {value}", switch.word)).map(drop)
+}
+
+/// Teleports to a scene's start, holds there and waits for the view to load, reporting the load.
+fn load_scene(
+    control: &Control,
+    name: &str,
+    start: [f64; 3],
+    end: [f64; 3],
+    pitch: f64,
+    report: &mut Report,
+) -> Result<(), String> {
+    let meshed = control.status()["meshed_sections"].as_f64().unwrap_or(0.0);
+    let generated = control.status()["generated_chunks"].as_f64().unwrap_or(0.0);
+    let [x, y, z] = start;
+    control.call(&format!("tp {x} {y} {z}"))?;
+    let teleported = Instant::now();
+    // A zero-length flight holds the player at the start, flying.
+    control.call(&format!("fly {x} {y} {z} {x} {y} {z} 0.1 {pitch}"))?;
+    control.call(&format!("look {:.3} {pitch}", yaw(start, end)))?;
+    let loaded = wait_loaded(control, near(start))?;
+    let load = loaded - teleported;
+    report.metric(&format!("chunks.{name}.load_ms"), &[ms(load)]);
+    let status = control.status();
+    let meshes = status["meshed_sections"].as_f64().unwrap_or(0.0) - meshed;
+    let chunks = status["generated_chunks"].as_f64().unwrap_or(0.0) - generated;
+    report.metric(&format!("chunks.{name}.meshed_count"), &[meshes]);
+    report.metric(&format!("chunks.{name}.generated_count"), &[chunks]);
+    if load.as_secs_f64() > 0.0 {
+        report.metric(
+            &format!("chunks.{name}.generated_per_s"),
+            &[chunks / load.as_secs_f64()],
+        );
+    }
+    Ok(())
+}
+
+/// Whether a status position is within 2 blocks of `target`.
+fn near(target: [f64; 3]) -> impl Fn(&Value) -> bool {
+    move |p| {
+        let p: Vec<f64> = p
+            .as_array()
+            .into_iter()
+            .flatten()
+            .filter_map(Value::as_f64)
+            .collect();
+        p.len() == 3 && (0..3).map(|i| (p[i] - target[i]).powi(2)).sum::<f64>() < 4.0
+    }
+}
+
+/// Flies the camera from `start` to `end` and returns the flight's frames.
+fn fly(
+    control: &Control,
+    phase: &str,
+    start: [f64; 3],
+    end: [f64; 3],
+    seconds: f64,
+    pitch: f64,
+    steady: &mut Vec<(Instant, Instant)>,
+) -> Result<Frames, String> {
+    let ([x, y, z], [ex, ey, ez]) = (start, end);
+    let begin = Instant::now();
+    let flight = control.call(&format!(
+        "fly {x} {y} {z} {ex} {ey} {ez} {seconds} {pitch} raw"
+    ))?;
+    steady.push((begin, Instant::now()));
+    frames_of(&flight, phase, 0)
+}
+
+/// The frames of a `fly ... raw` or `bench ... raw` reply.
+fn frames_of(reply: &Value, phase: &str, repeat: u32) -> Result<Frames, String> {
+    let series = |key: &str| -> Vec<f32> {
+        reply[key]
+            .as_array()
+            .into_iter()
+            .flatten()
+            .filter_map(Value::as_f64)
+            .map(|v| v as f32)
+            .collect()
+    };
+    Frames::of(
+        phase,
+        repeat,
+        &series("frame_ms"),
+        &series("cpu_ms"),
+        &series("gpu_ms"),
+    )
+    .ok_or_else(|| format!("{phase} drew no frames"))
+}
+
+/// The phase's frame figures over its blocks (one for a flight).
+fn fps_metrics(report: &mut Report, phase: &str, blocks: &[Frames]) {
+    let each = |f: fn(&Frames) -> f64| blocks.iter().map(f).collect::<Vec<_>>();
+    report.metric(&format!("fps.{phase}.avg_fps"), &each(|b| b.avg_fps));
+    report.metric(
+        &format!("fps.{phase}.low_1pct_fps"),
+        &each(|b| b.low_1pct_fps),
+    );
+    report.metric(
+        &format!("fps.{phase}.low_01pct_fps"),
+        &each(|b| b.low_01pct_fps),
+    );
+}
+
+/// The median CPU and GPU time of a frame over the phase's blocks, where measured.
+fn timing_metrics(report: &mut Report, phase: &str, blocks: &[Frames]) {
+    let cpu: Vec<f64> = blocks.iter().filter_map(|b| b.cpu_p50_ms).collect();
+    let gpu: Vec<f64> = blocks.iter().filter_map(|b| b.gpu_p50_ms).collect();
+    report.metric(&format!("cpu.{phase}.p50_ms"), &cpu);
+    report.metric(&format!("gpu.{phase}.p50_ms"), &gpu);
+}
+
+/// The flight, then the view at its end loaded.
+fn trip(
+    control: &Control,
+    report: &mut Report,
+    steady: &mut Vec<(Instant, Instant)>,
+) -> Result<(), String> {
+    for line in [
+        "command gamerule advance_time false",
+        "command gamerule advance_weather false",
+        "command weather clear",
+        "time 6000",
+    ] {
+        control.call(line)?;
+    }
+    let (from, to) = (TRAVEL_FROM, TRAVEL_TO);
+    load_scene(control, "travel", from, to, TRAVEL_PITCH, report)?;
+    let flight = fly(
+        control,
+        "travel",
+        from,
+        to,
+        TRAVEL_SECONDS,
+        TRAVEL_PITCH,
+        steady,
+    )?;
+    let blocks = std::slice::from_ref(&flight);
+    fps_metrics(report, "travel", blocks);
+    timing_metrics(report, "travel", blocks);
+    report.frames.push(flight);
+
+    let [x, y, z] = to;
+    control.call(&format!("fly {x} {y} {z} {x} {y} {z} 0.1 {TRAVEL_PITCH}"))?;
+    control.call(&format!("look {:.3} {TRAVEL_PITCH}", yaw(from, to)))?;
+    wait_loaded(control, near(to))?;
+    Ok(())
+}
+
+/// The state that matters: fly 512 blocks over terrain that loads and unloads, then hold at the end.
+fn travel(
+    control: &Control,
+    report: &mut Report,
+    steady: &mut Vec<(Instant, Instant)>,
+) -> Result<(), String> {
+    trip(control, report, steady)?;
+    let mut blocks = Vec::new();
+    for repeat in 0..HOLD_BLOCKS {
+        let held = control.call(&format!("bench {BLOCK_SECONDS} raw"))?;
+        blocks.push(frames_of(&held, "hold", repeat)?);
+    }
+    fps_metrics(report, "hold", &blocks);
+    timing_metrics(report, "hold", &blocks);
+    report.frames.extend(blocks);
+    Ok(())
+}
+
+struct Plan {
+    pairs: u32,
+    warmup: Duration,
+}
+
+/// The two values of a switch in B A A B order, a block each, then each arm's passes timed once.
+fn ab_blocks(
+    control: &Control,
+    switch: &Switch,
+    plan: &Plan,
+    report: &mut Report,
+    steady: &mut Vec<(Instant, Instant)>,
+) -> Result<(), String> {
+    let began = Instant::now();
+    let mut blocks = Vec::new();
+    for pair in 0..plan.pairs {
+        control.call("time 6000")?;
+        for (n, b) in [(0, pair % 2 == 0), (1, pair % 2 == 1)] {
+            let (phase, value) = if b {
+                ("ab.b", switch.b)
+            } else {
+                ("ab.a", switch.a)
+            };
+            control.call(&format!("{} {value}", switch.word))?;
+            thread::sleep(plan.warmup);
+            let held = control.call(&format!("bench {BLOCK_SECONDS} raw"))?;
+            blocks.push(frames_of(&held, phase, 2 * pair + n)?);
+        }
+    }
+    steady.push((began, Instant::now()));
+    for phase in ["ab.a", "ab.b"] {
+        let arm: Vec<Frames> = blocks
+            .iter()
+            .filter(|f| f.phase == phase)
+            .cloned()
+            .collect();
+        fps_metrics(report, phase, &arm);
+        timing_metrics(report, phase, &arm);
+    }
+    let ab = Ab::from_frames(
+        switch.name,
+        switch.a,
+        switch.b,
+        BLOCK_SECONDS,
+        plan.warmup.as_secs_f64(),
+        &blocks,
+    )?;
+    if ab.first_block_outside_range {
+        eprintln!(
+            "Horizon: benchmark warning: the first B block, measured before any switch, is outside the later B blocks: switching {} may reset what is measured",
+            switch.name
+        );
+    }
+    report.frames.extend(blocks);
+    report.ab = Some(ab);
+    for (scene, value) in [("ab_a", switch.a), ("ab_b", switch.b)] {
+        control.call(&format!("{} {value}", switch.word))?;
+        time_passes(control, scene, report)?;
+    }
+    Ok(())
 }

 /// Removes the previous run's world, never one the benchmark didn't create.
@@ -472,11 +831,65 @@ impl RssSampler {
 mod tests {
    use super::*;

+    #[test]
+    fn the_capture_commands_are_the_ones_the_game_parses() {
+        use crate::client_perf::request::{self, ProfileSide, Request, StartOptions};
+        let words = |line: &str| request::parse(&line.split(' ').skip(1).collect::<Vec<_>>());
+        let start = words(START_CAPTURE).unwrap();
+        assert_eq!(start.side, Some(ProfileSide::Client));
+        assert_eq!(start.request, Request::Start(StartOptions::default()));
+        let path = Path::new("/home/a b/game/benchmarks/game-20261108-travel.json");
+        let stop = words(&stop_capture(path)).unwrap();
+        assert_eq!(stop.side, Some(ProfileSide::Client));
+        assert_eq!(
+            stop.request,
+            Request::Stop {
+                bench: Some(path.display().to_string())
+            }
+        );
+    }
+
    #[test]
    fn scenarios() {
-        assert_eq!(scenes("standard").unwrap().len(), 4);
-        assert_eq!(scenes("ocean").unwrap()[0].0, "ocean");
-        assert!(scenes("nether").is_none());
+        let scenes = |name: &str| match Scenario::parse(name) {
+            Ok(Scenario::Scenes(scenes)) => scenes,
+            _ => panic!("{name} is not scenes"),
+        };
+        assert_eq!(scenes("standard").len(), 4);
+        assert_eq!(scenes("ocean")[0].0, "ocean");
+        assert!(matches!(Scenario::parse("travel"), Ok(Scenario::Travel)));
+        assert!(matches!(
+            Scenario::parse("ab:gpu-culling"),
+            Ok(Scenario::Ab(s)) if s.name == "gpu-culling"
+        ));
+        let Err(e) = Scenario::parse("ab:nope") else {
+            panic!("nope is no switch")
+        };
+        assert!(
+            e.contains("gpu-culling") && e.contains("section-draws"),
+            "{e}"
+        );
+        let Err(e) = Scenario::parse("nether") else {
+            panic!("nether is no scenario")
+        };
+        assert!(e.contains("travel") && e.contains("mountain"), "{e}");
+    }
+
+    #[test]
+    fn a_set_names_a_switch_and_one_of_its_two_values() {
+        assert_eq!(
+            parse_set("gpu-culling=on"),
+            Ok(("gpu-culling".into(), "on".into()))
+        );
+        assert_eq!(
+            parse_set("section-draws=indirect"),
+            Ok(("section-draws".into(), "indirect".into()))
+        );
+        let nope = parse_set("gpu-culling=maybe").unwrap_err();
+        assert!(nope.contains("off or on"), "{nope}");
+        let unknown = parse_set("fog=on").unwrap_err();
+        assert!(unknown.contains("gpu-culling") && unknown.contains("section-draws"));
+        assert!(parse_set("gpu-culling").is_err());
    }

    #[test]
@@ -588,6 +1001,325 @@ mod tests {
        assert!(metrics.is_empty());
    }

+    /// A fake game for the trip: the player stands where `tp` or `fly` put it and counts settle.
+    fn trip_server(rx: mpsc::Receiver<Request>) -> thread::JoinHandle<Vec<String>> {
+        thread::spawn(move || {
+            let (mut lines, mut at, mut polls) = (Vec::new(), [0.0_f64; 3], 0_u64);
+            while let Ok(request) = rx.recv() {
+                let words: Vec<&str> = request.line.split(' ').collect();
+                let reply = match words[0] {
+                    "status" => {
+                        polls += 1;
+                        let mut s: Value =
+                            serde_json::from_str(&status(400 + polls.min(3))).unwrap();
+                        s["player"]["position"] = serde_json::json!(at);
+                        s
+                    }
+                    "bench" | "fly" if words.contains(&"raw") => {
+                        serde_json::json!({
+                            "frames": 200,
+                            "frame_ms": vec![5.0; 200],
+                            "cpu_ms": vec![2.0; 200],
+                            "gpu_ms": vec![4.0; 200],
+                        })
+                    }
+                    _ => serde_json::json!({ "ok": true }),
+                };
+                if matches!(words[0], "tp" | "fly") {
+                    let n: Vec<f64> = words[1..4].iter().filter_map(|w| w.parse().ok()).collect();
+                    at = [n[0], n[1], n[2]];
+                    polls = 0;
+                }
+                let _ = request.reply.send(reply.to_string());
+                lines.push(request.line);
+            }
+            lines
+        })
+    }
+
+    #[test]
+    fn the_trip_flies_512_blocks_then_holds_four_blocks_at_its_end() {
+        let (tx, rx) = mpsc::channel::<Request>();
+        let server = trip_server(rx);
+        let mut report = Report::new(Kind::Game, App::default());
+        let control = Control(tx);
+        let mut steady = Vec::new();
+        travel(&control, &mut report, &mut steady).expect("the trip runs");
+        drop(control);
+        let lines: Vec<String> = server
+            .join()
+            .unwrap()
+            .into_iter()
+            .filter(|l| l != "status")
+            .map(|l| l.replace("-0.000", "0.000"))
+            .collect();
+        // Facing +Z is yaw 0, which the formatter may print as -0.
+        let mut expected = vec![
+            "command gamerule advance_time false",
+            "command gamerule advance_weather false",
+            "command weather clear",
+            "time 6000",
+            "tp -960 150 -176",
+            "fly -960 150 -176 -960 150 -176 0.1 30",
+            "look 0.000 30",
+            "fly -960 150 -176 -960 150 336 32 30 raw",
+            "fly -960 150 336 -960 150 336 0.1 30",
+            "look 0.000 30",
+        ];
+        expected.extend(["bench 4 raw"; 4]);
+        assert_eq!(lines, expected);
+
+        let phases: Vec<_> = report
+            .frames
+            .iter()
+            .map(|f| (f.phase.as_str(), f.repeat))
+            .collect();
+        assert_eq!(
+            phases,
+            [
+                ("travel", 0),
+                ("hold", 0),
+                ("hold", 1),
+                ("hold", 2),
+                ("hold", 3)
+            ]
+        );
+        assert_eq!(steady.len(), 1);
+        let metric = |name: &str| report.metrics.get(name).map(|s| (s.n, s.mean));
+        assert_eq!(metric("fps.travel.avg_fps"), Some((1, 200.0)));
+        assert_eq!(metric("fps.hold.avg_fps"), Some((4, 200.0)));
+        assert_eq!(metric("cpu.hold.p50_ms"), Some((4, 2.0)));
+        assert_eq!(metric("gpu.hold.p50_ms"), Some((4, 4.0)));
+        assert_eq!(metric("gpu.travel.p50_ms"), Some((1, 4.0)));
+        assert!(metric("chunks.travel.load_ms").is_some());
+    }
+
+    #[test]
+    fn a_refused_command_ends_the_trip_with_the_games_reason() {
+        let (tx, rx) = mpsc::channel::<Request>();
+        let server = thread::spawn(move || {
+            while let Ok(request) = rx.recv() {
+                let reply = if request.line.starts_with("command weather") {
+                    serde_json::json!({ "error": "no such weather" })
+                } else {
+                    serde_json::json!({ "ok": true })
+                };
+                let _ = request.reply.send(reply.to_string());
+            }
+        });
+        let mut report = Report::new(Kind::Game, App::default());
+        let control = Control(tx);
+        let error = travel(&control, &mut report, &mut Vec::new()).unwrap_err();
+        assert!(error.contains("no such weather"), "{error}");
+        assert!(report.frames.is_empty());
+        drop(control);
+        server.join().unwrap();
+    }
+
+    #[test]
+    fn a_refused_switch_is_the_games_reason() {
+        let (tx, rx) = mpsc::channel::<Request>();
+        let server = thread::spawn(move || {
+            let mut lines = Vec::new();
+            while let Ok(request) = rx.recv() {
+                let reply = match request.line.as_str() {
+                    "gpu-culling on" => serde_json::json!({ "error": "not offered here" }),
+                    _ => serde_json::json!({ "ok": true }),
+                };
+                let _ = request.reply.send(reply.to_string());
+                lines.push(request.line);
+            }
+            lines
+        });
+        let control = Control(tx);
+        apply_set(&control, "section-draws", "indirect").unwrap();
+        let error = apply_set(&control, "gpu-culling", "on").unwrap_err();
+        assert!(error.contains("not offered here"), "{error}");
+        drop(control);
+        assert_eq!(
+            server.join().unwrap(),
+            ["section-draws indirect", "gpu-culling on"]
+        );
+    }
+
+    /// A fake game with GPU culling: `on` is its state; `fail_at` makes that `bench` (counted from 1) fail.
+    fn culling_server(
+        rx: mpsc::Receiver<Request>,
+        mut on: bool,
+        offered: bool,
+        fail_at: Option<usize>,
+    ) -> thread::JoinHandle<(Vec<String>, bool)> {
+        thread::spawn(move || {
+            let (mut lines, mut benches) = (Vec::new(), 0);
+            while let Ok(request) = rx.recv() {
+                let reply = match request.line.as_str() {
+                    "gpu-culling on" if !offered => {
+                        serde_json::json!({ "error": "not offered here" })
+                    }
+                    "gpu-culling on" | "gpu-culling off" => {
+                        on = request.line.ends_with("on");
+                        serde_json::json!({ "gpu_culling": on })
+                    }
+                    "gpu-culling" => serde_json::json!({ "gpu_culling": on }),
+                    "bench 4 raw" => {
+                        benches += 1;
+                        let gpu = if on { 5.0 } else { 3.0 };
+                        if Some(benches) == fail_at {
+                            serde_json::json!({ "error": "the window closed" })
+                        } else {
+                            serde_json::json!({
+                                "frame_ms": vec![gpu + 1.0; 200],
+                                "cpu_ms": vec![1.0; 200],
+                                "gpu_ms": vec![gpu; 200],
+                            })
+                        }
+                    }
+                    "bench 2" => serde_json::json!({
+                        "gpu_passes": {"World": if on { 1.5 } else { 0.5 }},
+                    }),
+                    _ => serde_json::json!({ "ok": true }),
+                };
+                let _ = request.reply.send(reply.to_string());
+                lines.push(request.line);
+            }
+            (lines, on)
+        })
+    }
+
+    const GPU_CULLING: &Switch = &SWITCHES[0];
+
+    fn quick(pairs: u32) -> Plan {
+        Plan {
+            pairs,
+            warmup: Duration::ZERO,
+        }
+    }
+
+    fn vulkan_report() -> Report {
+        let gpu = horizon_bench::Gpu {
+            backend: "vulkan".into(),
+            ..Default::default()
+        };
+        let hardware = horizon_bench::Hardware {
+            gpu: Some(gpu),
+            ..Default::default()
+        };
+        Report::with_hardware(Kind::Game, App::default(), hardware)
+    }
+
+    #[test]
+    fn the_blocks_run_b_a_a_b_and_each_arm_is_timed_by_pass() {
+        let (tx, rx) = mpsc::channel::<Request>();
+        let server = culling_server(rx, false, true, None);
+        let mut report = vulkan_report();
+        let control = Control(tx);
+        keeping_switch(&control, GPU_CULLING, || {
+            ab_blocks(
+                &control,
+                GPU_CULLING,
+                &quick(6),
+                &mut report,
+                &mut Vec::new(),
+            )
+        })
+        .expect("the blocks run");
+        drop(control);
+        let (lines, on) = server.join().unwrap();
+        let arms: String = lines
+            .iter()
+            .take_while(|l| *l != "gpu-passes on")
+            .filter_map(|l| match l.as_str() {
+                "gpu-culling on" => Some('B'),
+                "gpu-culling off" => Some('A'),
+                _ => None,
+            })
+            .collect();
+        assert_eq!(arms, "BAABBAABBAABA");
+        assert_eq!(lines.iter().filter(|l| *l == "time 6000").count(), 6);
+        assert!(!on, "the initial value is back");
+        assert_eq!(lines.last().unwrap(), "gpu-culling off");
+
+        let positions: Vec<_> = report
+            .frames
+            .iter()
+            .map(|f| (f.phase.as_str(), f.repeat))
+            .collect();
+        assert_eq!(
+            positions[..4],
+            [("ab.b", 0), ("ab.a", 1), ("ab.a", 2), ("ab.b", 3)]
+        );
+        let ab = report.ab.as_ref().expect("an A/B run has its result");
+        let gpu = &ab.result["gpu_p50_ms"];
+        assert_eq!((gpu.pairs, gpu.a, gpu.b, gpu.diff), (6, 3.0, 5.0, 2.0));
+        assert_eq!(gpu.verdict, horizon_bench::compare::Verdict::Slower);
+        assert!(!ab.first_block_outside_range);
+        let metric = |name: &str| report.metrics.get(name).map(|s| (s.n, s.mean));
+        assert_eq!(metric("gpu.ab.a.p50_ms"), Some((6, 3.0)));
+        assert_eq!(metric("gpu.ab.b.p50_ms"), Some((6, 5.0)));
+        assert_eq!(metric("gpu_pass.ab_a.world_ms"), Some((1, 0.5)));
+        assert_eq!(metric("gpu_pass.ab_b.world_ms"), Some((1, 1.5)));
+    }
+
+    #[test]
+    fn a_setting_that_was_on_is_on_again_after_the_run() {
+        let (tx, rx) = mpsc::channel::<Request>();
+        let server = culling_server(rx, true, true, None);
+        let control = Control(tx);
+        keeping_switch(&control, GPU_CULLING, || {
+            ab_blocks(
+                &control,
+                GPU_CULLING,
+                &quick(2),
+                &mut vulkan_report(),
+                &mut Vec::new(),
+            )
+        })
+        .expect("the blocks run");
+        drop(control);
+        assert!(server.join().unwrap().1);
+    }
+
+    #[test]
+    fn the_setting_is_put_back_when_the_run_fails_midway() {
+        let (tx, rx) = mpsc::channel::<Request>();
+        // The 3rd block is A: the setting is off when it fails.
+        let server = culling_server(rx, true, true, Some(3));
+        let control = Control(tx);
+        let mut report = vulkan_report();
+        let error = keeping_switch(&control, GPU_CULLING, || {
+            ab_blocks(
+                &control,
+                GPU_CULLING,
+                &quick(6),
+                &mut report,
+                &mut Vec::new(),
+            )
+        })
+        .unwrap_err();
+        assert!(error.contains("the window closed"), "{error}");
+        assert!(report.frames.is_empty() && report.ab.is_none());
+        drop(control);
+        let (lines, on) = server.join().unwrap();
+        assert!(on, "on was the player's setting");
+        assert_eq!(lines.last().unwrap(), "gpu-culling on");
+    }
+
+    #[test]
+    fn a_refused_switch_ends_the_run_with_the_games_reason_and_changes_nothing() {
+        let (tx, rx) = mpsc::channel::<Request>();
+        let server = culling_server(rx, false, false, None);
+        let control = Control(tx);
+        let error = keeping_switch(&control, GPU_CULLING, || {
+            apply_set(&control, "gpu-culling", "on")
+        })
+        .unwrap_err();
+        assert!(error.contains("not offered here"), "{error}");
+        drop(control);
+        let (lines, on) = server.join().unwrap();
+        assert_eq!(lines, ["gpu-culling", "gpu-culling on", "gpu-culling"]);
+        assert!(!on);
+    }
+
    #[test]
    fn yaw_matches_vanilla() {
        // South (+Z) is 0, west (-X) 90, east (+X) -90.
@@ -589,12 +589,22 @@ pub const COMMANDS: &[Cmd] = &[
    cmd!("mcp", Scripting, "mcp [--paced]", "serve the Model Context Protocol on stdin/stdout, one tool per command",
        "Add it to an MCP client as a stdio server: command horizon-ctl, args [\"mcp\"] (with --socket PATH first if needed). The screenshot tool returns the image. --paced stops a single-player world between tool calls: the pause menu opens after each action and closes before the next, so time passes only while an action (or wait) runs, not while the agent thinks; reading tools (state, inventory, entities, events...) leave it paused.",
        ["horizon-ctl mcp", "horizon-ctl mcp --paced"], &[], mcp: false, local: true),
-    cmd!("bench", Scripting, "bench SECONDS", "reset frame stats, wait, reply with the summary", "", ["horizon-ctl bench 10"], &[p("seconds", Ty::Num, "how long to measure")], mcp: true, local: false),
-    cmd!("stats", Scripting, "stats [reset] [raw]", "frame-time summary since the last reset", "", ["horizon-ctl stats"], &[opt("reset", Ty::Bool, "start counting again"), opt("raw", Ty::Bool, "every frame time too (frame_ms, cpu_ms, gpu_ms)")], mcp: true, local: false),
-    cmd!("gpu-passes", Scripting, "gpu-passes [on|off]", "time Horizon's own render passes on the GPU, shown in F3 and in stats and bench", "", ["horizon-ctl gpu-passes on"], &[opt("mode", Ty::Enum(&["on", "off"]), "on or off; without it, only reports")], mcp: false, local: false),
-    cmd!("trace", Scripting, "trace [FILE [SECONDS] | stop]", "write every thread's timed spans to FILE as a timeline that ui.perfetto.dev opens, for SECONDS or until stop",
-        "Each span (ticks by system, streaming, uploads, far terrain, lighting, the renderer) shows on the thread that ran it, nested by time. Without arguments, only reports whether a trace is being written. HORIZON_TRACE=FILE writes one from the start; horizon-trace on a dedicated server's console writes one to reports/. See docs/graphics.md.",
-        ["horizon-ctl trace /tmp/frame.json 10", "horizon-ctl trace stop"], &[], mcp: false, local: false),
+    cmd!("bench", Scripting, "bench SECONDS [raw]", "reset frame stats, wait, reply with the summary", "", ["horizon-ctl bench 10", "horizon-ctl bench 4 raw"], &[p("seconds", Ty::Num, "how long to measure"), opt("raw", Ty::Bool, "every frame time too (frame_ms, cpu_ms, gpu_ms; alloc_count and alloc_bytes in an alloc-count build)")], mcp: true, local: false),
+    cmd!("stats", Scripting, "stats [reset] [raw]", "frame-time summary since the last reset", "A build with the alloc-count feature adds alloc: the window thread's allocations and KiB per frame and all threads' allocations per second, else null.", ["horizon-ctl stats"], &[opt("reset", Ty::Bool, "start counting again"), opt("raw", Ty::Bool, "every frame time too (frame_ms, cpu_ms, gpu_ms; alloc_count and alloc_bytes in an alloc-count build)")], mcp: true, local: false),
+    cmd!("gpu-passes", Scripting, "gpu-passes [on|off|detail]", "time Horizon's own render passes on the GPU, shown in F3 and in stats and bench; detail adds dispatch times and, on Vulkan, fragment and vertex counts per world pass", "", ["horizon-ctl gpu-passes on"], &[opt("mode", Ty::Enum(&["on", "off", "detail"]), "on, off or detail; without it, only reports")], mcp: false, local: false),
+    cmd!("trace", Scripting, "trace [FILE [SECONDS] | stop]", "write every thread's timed spans to FILE as a .hzperf capture holding a timeline, for SECONDS or until stop",
+        "Each span (ticks by system, streaming, uploads, far terrain, lighting, the renderer) is recorded on the thread that ran it, with its depth; the timeline stops after 60 seconds. trace stop replies with the file's path once it is whole. Without arguments, only reports whether a trace is being written. HORIZON_TRACE=FILE writes one from the start; horizon-trace on a dedicated server's console writes one to reports/. Open the file in the web UI. See docs/graphics.md.",
+        ["horizon-ctl trace /tmp/frame.hzperf 10", "horizon-ctl trace stop"], &[], mcp: false, local: false),
+    cmd!("profile", Scripting, "profile [client|server] start [--seconds S] [--hz N] [--over MS] [--threads main|all] [--wall] [--gpu[=detail]] [--no-samples] [--timeline] | stop [--bench REPORT] | status | mark NAME | open FILE | share FILE", "capture the game's performance to a .hzperf file in reports/ in the game home",
+        "start records the frame times, the health history and the render thread's call trees until stop or --seconds (at most 600). stop replies with the file's path once the file is whole, and with the viewer's address (open_at) only in a build that has a part to open captures; open FILE serves the file once on 127.0.0.1 and opens the viewer on it, share FILE uploads it and replies with the link; both fail in a build without that part and work with every telemetry switch off; status says whether a capture runs, its age and its size; mark NAME puts a label at the current time. F3+O does start and stop from the keyboard; HORIZON_PROFILE=DIR records the first 10 minutes of a run into DIR. --gpu adds each render pass's median GPU time and --gpu=detail the dispatch times and, on Vulkan, fragment and vertex counts per pass; HORIZON_SHADER_PACK_TIMING and HORIZON_GPU_PASS_DETAIL start a capture with them. stop --bench REPORT embeds a benchmark report (benchmarks/*.json) in the capture; --benchmark --profile does this by itself. Read the file with horizon-perf (query gpu). With no side a single-player run captures both sides in one file (the window, and the server thread as its own section); client or server captures one. Connected to a Horizon server, server asks that server to capture its side: it needs operator level 4, only one server capture runs at a time, and the server keeps the file in its reports/ and logs who asked; a refusal is a warning in the window's own capture.",
+        ["horizon-ctl profile start --seconds 30", "horizon-ctl profile mark loaded-the-nether", "horizon-ctl profile stop", "horizon-ctl profile open reports/profile-20251107-143844Z.hzperf"],
+        &[p("action", Ty::Enum(&["start", "stop", "status", "mark", "open", "share"]), "what to do"), opt("name", Ty::Rest, "mark: the label; open and share: the file"),
+          flag("side", Ty::Enum(&["client", "server"]), "client or server, for the window or the server (the single-player server thread, or the server joined); both when omitted"), flag("seconds", Ty::Int, "start: stop after this many seconds, 1 to 600"),
+          flag("hz", Ty::Int, "start: samples per second, 10 to 1000 (default 250)"), flag("over", Ty::Num, "start: sample only frames slower than this many milliseconds"),
+          flag("threads", Ty::Enum(&["main", "all"]), "start: the render thread (default) or every thread that opted in"), flag("wall", Ty::Bool, "start: also sample on the wall clock, to find waits"),
+          flag("gpu", Ty::Enum(&["passes", "detail"]), "start: also record each render pass's GPU time (detail: its parts and counters too)"),
+          flag("no-samples", Ty::Bool, "start: record frame times and health only"), flag("timeline", Ty::Bool, "start: also record every thread's spans, for 60 seconds at most"),
+          flag("bench", Ty::Str, "stop: the path of a benchmark report to embed in the capture")], mcp: true, local: false),
    cmd!("screenshot-sequence", Scripting, "screenshot-sequence FRAMES STEP_MS PATH|cancel", "draw a shader pack's first FRAMES frames on a set clock and write the last as a PNG",
        "Needs HORIZON_STILL and a frozen world (docs/agent-control.md). The pack starts over, frame n's clock is n frames and (n - 1) × STEP_MS milliseconds, the PNG is written as screenshot PATH writes it, and the reply comes once it is. Relative paths are taken from horizon-ctl's directory. cancel stops a running sequence.",
        ["horizon-ctl screenshot-sequence 64 50 frame64.png", "horizon-ctl screenshot-sequence 64 16.666667 frame64.png", "horizon-ctl screenshot-sequence cancel"],
@@ -71,6 +71,10 @@ pub fn trample_allowed(entity: i32, kind: &str, position: BlockPos, distance: f6
    let (Some(dimension), Some(hook)) = (LEVEL.get(), TRAMPLE.get()) else {
        return true;
    };
+    // A grouped mob turn: no mod hooks it (`native_client_hooks::Deferred`).
+    if crate::native_client_hooks::deferring() {
+        return true;
+    }
    let mut cancel = false;
    let at = [position.x, position.y, position.z];
    hook(dimension, entity, kind, at, distance, &mut cancel);
@@ -87,7 +91,8 @@ fn dispatch(event: Event<'_>, damage: &mut f32) {
    let contact = match event {
        Event::StepOn(c) | Event::Inside(c) | Event::FallOn(c, _) => c,
    };
-    if contact.block.starts_with("minecraft:") {
+    // A grouped mob turn reaches no mod's hook (`native_client_hooks::Deferred`).
+    if contact.block.starts_with("minecraft:") || crate::native_client_hooks::deferring() {
        return;
    }
    if let Some(dimension) = LEVEL.get()
@@ -213,6 +218,15 @@ mod tests {
            let bounds = bounds.move_by(Vec3::new(-1.0, 0.0, 0.0));
            swept_inside(17, c.kind, at, at, bounds, block);
            assert_eq!(SEEN.get(), 8, "stationary overlap still notifies");
+            // A grouped mob turn, on any thread: no mod hears its contacts or tramples.
+            let ((), _) = crate::native_client_hooks::deferring_turn(|| {
+                emit(Event::StepOn(c));
+                assert_eq!(fall(c, 12.0, 10.0), 10.0);
+                let _ = TRAMPLE.set(|_, _, _, _, _, cancel| *cancel = true);
+                assert!(trample_allowed(17, c.kind, c.position, 12.0));
+            });
+            assert_eq!(SEEN.get(), 8, "a grouped turn reaches no contact hook");
+            assert!(!trample_allowed(17, c.kind, c.position, 12.0));
        });
        let _ =
            std::panic::catch_unwind(|| in_level(Some("minecraft:the_nether"), || panic!("test")));
@@ -123,18 +123,32 @@ pub fn spawn_egg_entity_data<'a>(

 /// `EntityType.appendDefaultStackConfig` for a hanging entity or armor stand an
 /// item places: `Entity.applyImplicitComponents` stores the item's
-/// `minecraft:custom_data` as the entity's `data`, then `updateCustomEntityTag`
+/// `minecraft:custom_name` as the entity's `CustomName` and its
+/// `minecraft:custom_data` as its `data`, then `updateCustomEntityTag`
 /// (`TypedEntityData.loadInto`) merges the item's `minecraft:entity_data` over
 /// the entity's saved tag `own` when its type is `kind`.
 pub fn stack_configured_entity(stack: &crate::items::ItemStack, kind: &str, own: &Tag) -> Tag {
+    stack_configured_entity_by(stack, kind, own, false)
+}
+
+/// [`stack_configured_entity`], `op` saying whether the user may load the
+/// data of an op-only entity type (`EntityType.onlyOpCanSetNbt`).
+pub fn stack_configured_entity_by(
+    stack: &crate::items::ItemStack,
+    kind: &str,
+    own: &Tag,
+    op: bool,
+) -> Tag {
    let mut tag = own.clone();
-    if let (Tag::Compound(map), Some(custom)) = (
-        &mut tag,
-        stack.data().and_then(|d| d.other("minecraft:custom_data")),
-    ) {
-        map.insert("data".into(), custom.clone());
+    if let Tag::Compound(map) = &mut tag {
+        if let Some(name) = stack.data().and_then(|d| d.custom_name.clone()) {
+            map.insert("CustomName".into(), name);
+        }
+        if let Some(custom) = stack.data().and_then(|d| d.other("minecraft:custom_data")) {
+            map.insert("data".into(), custom.clone());
+        }
    }
-    match spawn_egg_entity_data(stack, kind, false) {
+    match spawn_egg_entity_data(stack, kind, op) {
        Some(data) => crate::data_cmd::merged(&tag, data),
        None => tag,
    }
@@ -19,16 +19,16 @@ pub use horizon_client_render::{
    effects, environment, extras, fast_hash, fluid_render, fog, font, gfx, graphics,
    graphics_style, graphics_ui, hdr_calibration, hud, hud_kit, hud_layout, hud_overlays,
    inventory_effects, java_text, jigsaw_block, json_folder, level_loading, light, lod, logging,
-    menu_blur, menu_style, mesher, minimap, mipmap, mod_browser, mod_list, model_library, models,
-    multiline_edit, native_emissive, options_file, options_fixes, options_ui, overlay,
-    pack_browser, pack_formats, pack_hooks, pack_palette, pack_screen, packs, pad_cursor,
-    pad_glyph, par, particles, poi_sections, polytone_creative_tabs, polytone_post, post_chain,
-    potent_sulfur, preedit, providers, pvp, pvp_hud, random_source, screen_draw, screen_effects,
-    sculk, section_mask, server_terrain, settings, shader_options, shader_pack_list, signs, skins,
-    social, sound_engine, sound_events, sound_preview, spans, split_layout, split_map,
-    split_profiles, sprites, streaming, structure_block, tab_list, terrain_model, test_block,
-    test_instance_block, testgen, title_edition, trims, ui, vault, weather, widgets, world,
-    worldborder, zip,
+    mark_sprite, menu_blur, menu_style, mesher, minimap, mipmap, mod_browser, mod_list,
+    model_library, models, multiline_edit, native_emissive, options_file, options_fixes,
+    options_ui, overlay, pack_browser, pack_formats, pack_hooks, pack_palette, pack_screen, packs,
+    pad_cursor, pad_glyph, par, particles, poi_sections, polytone_creative_tabs, polytone_post,
+    post_chain, potent_sulfur, preedit, providers, pvp, pvp_hud, random_source, screen_draw,
+    screen_effects, sculk, section_mask, server_terrain, settings, shader_options,
+    shader_pack_list, signs, skins, social, sound_engine, sound_events, sound_preview, spans,
+    split_layout, split_map, split_profiles, sprites, streaming, structure_block, tab_list,
+    terrain_model, test_block, test_instance_block, testgen, title_edition, trims, ui, vault,
+    weather, widgets, world, worldborder, zip,
 };
 pub mod attack_strength;
 pub mod attribute_updates;
@@ -43,6 +43,7 @@ pub mod boss_overlay;
 pub mod breathing;
 pub mod cauldron;
 pub mod chunk_io;
+pub mod client_perf;
 pub mod clock;
 pub mod command_storage;
 pub mod confirm_screen;
@@ -107,6 +108,7 @@ pub mod offline_name;
 pub mod old_world;
 pub mod osk;
 pub mod patrol;
+pub mod perf_net;
 pub mod perf_overlay;
 pub mod pick_item;
 pub mod player_sync;
@@ -129,6 +131,7 @@ pub mod sound_playback;
 pub use horizon_server_files as server;
 pub mod controller_notice;
 pub mod server_packs;
+pub mod server_perf;
 pub mod shadows;
 pub mod spear;
 pub mod spectator_menu;
@@ -0,0 +1,321 @@
+//! The client's .hzperf captures (docs/perf-platform.md §4.1): the window's frames feed the always-on health history, and a capture writes it with the samples of the render thread.
+use crate::gfx::pack_timing::{GpuReadout, TimedFrames};
+use crate::server_perf::traffic::{Conn, Wire};
+use crate::server_perf::{
+    self, CaptureEnd, CaptureOptions, CaptureStatus, MAX_WINDOW_S, Role, SamplerOptions, Saved,
+    ServerPerf, TickDetail, WorldCounts,
+};
+use horizon_perf_format::FieldSender;
+use horizon_perf_format::v1::{
+    BenchResult, Machine, Side, Start, StopReason, Trigger, WarningCode,
+};
+use horizon_protocol::connection::Counters;
+use request::{GpuSwitch, StartOptions, Threads};
+use std::ffi::OsStr;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::sync::atomic::Ordering;
+use std::time::{Duration, Instant};
+
+pub mod request;
+
+#[cfg(test)]
+mod tests;
+
+/// A frame this slow enters the slow ring when `HORIZON_SPIKES` names no other threshold.
+pub const SLOW_FRAME_MS: f32 = 50.0;
+
+/// The variables that start a capture with the GPU passes timed: pass timing, and pass timing with its parts.
+pub const ENV_PASS_TIMING: &str = "HORIZON_SHADER_PACK_TIMING";
+pub const ENV_PASS_DETAIL: &str = "HORIZON_GPU_PASS_DETAIL";
+
+/// The GPU switch a run's environment asks for; the detail variable wins over the timing one.
+pub fn env_gpu(timing: Option<&OsStr>, detail: Option<&OsStr>) -> GpuSwitch {
+    if detail.is_some() {
+        GpuSwitch::Detail
+    } else if timing.is_some() {
+        GpuSwitch::Passes
+    } else {
+        GpuSwitch::Off
+    }
+}
+
+/// Where a client's captures go: `HORIZON_PROFILE` when set, else `reports/` in the game home.
+pub fn reports_dir(profile: Option<&OsStr>, home: &Path) -> PathBuf {
+    match profile.filter(|p| !p.is_empty()) {
+        Some(dir) => PathBuf::from(dir),
+        None => home.join("reports"),
+    }
+}
+
+/// What a side on another thread needs to write into the running capture's file.
+#[derive(Clone)]
+pub struct Join {
+    pub sender: FieldSender,
+    pub path: PathBuf,
+    /// The instant every `t` of the capture counts from.
+    pub origin: Instant,
+    /// When the capture's window ends, and why it stops then.
+    pub ends: Option<(Instant, StopReason)>,
+    pub options: StartOptions,
+    pub trigger: Trigger,
+}
+
+/// The client's health history, always on, and the capture running from it, if any.
+pub struct ClientPerf {
+    perf: ServerPerf,
+    epoch: Instant,
+    cpu_ms: Vec<f32>,
+    gpu_ms: Vec<f32>,
+    /// When the running capture's window ends, and why it stops then.
+    window: Option<(f64, StopReason)>,
+    /// The running capture's switches, which a side that joins it follows.
+    running: Option<(StartOptions, Trigger)>,
+    /// The server connection's byte counts while the window plays on one: the capture's own traffic.
+    connection: Option<Arc<Counters>>,
+}
+
+/// The window's one connection as the traffic recorder's wire list.
+fn wire_of(connection: Option<&Counters>) -> Wire {
+    let order = Ordering::Relaxed;
+    connection
+        .map(|c| {
+            let count = |n: &std::sync::atomic::AtomicI64| n.load(order).max(0) as u64;
+            vec![Conn {
+                id: 1,
+                bytes: (count(&c.bytes_in), count(&c.bytes_out)),
+                ..Conn::default()
+            }]
+        })
+        .unwrap_or_default()
+}
+
+impl ClientPerf {
+    pub fn new(slow_ms: f32) -> Self {
+        Self {
+            perf: ServerPerf::with_role(Role::CLIENT, 0.0, slow_ms),
+            epoch: Instant::now(),
+            cpu_ms: Vec::new(),
+            gpu_ms: Vec::new(),
+            window: None,
+            running: None,
+            connection: None,
+        }
+    }
+
+    /// The connection whose bytes a capture records, or None in a world of the window's own.
+    pub fn set_connection(&mut self, connection: Option<Arc<Counters>>) {
+        self.connection = connection;
+    }
+
+    /// Seconds since the game began, the clock every other time here is on.
+    pub fn now(&self) -> f64 {
+        self.epoch.elapsed().as_secs_f64()
+    }
+
+    pub fn capturing(&self) -> bool {
+        self.perf.capturing()
+    }
+
+    pub fn health(&self) -> &horizon_perf_format::HealthRecorder {
+        self.perf.health()
+    }
+
+    /// One rendered frame that took `wall_ms`, of which `cpu_ms` was the CPU's own work, ending at `t`.
+    pub fn frame(
+        &mut self,
+        t: f64,
+        wall_ms: f32,
+        cpu_ms: f32,
+        gpu_ms: Option<f32>,
+        detail: Option<TickDetail>,
+        world: impl FnOnce() -> WorldCounts,
+    ) {
+        self.frame_with_gpu(t, wall_ms, cpu_ms, gpu_ms, detail, world, || None);
+    }
+
+    /// [`ClientPerf::frame`], where `gpu` is asked for the pass timings only when this frame ends the capture's window.
+    #[allow(clippy::too_many_arguments)]
+    pub fn frame_with_gpu(
+        &mut self,
+        t: f64,
+        wall_ms: f32,
+        cpu_ms: f32,
+        gpu_ms: Option<f32>,
+        detail: Option<TickDetail>,
+        world: impl FnOnce() -> WorldCounts,
+        gpu: impl FnOnce() -> Option<GpuReadout>,
+    ) {
+        self.cpu_ms.push(cpu_ms);
+        self.gpu_ms.extend(gpu_ms);
+        if self.perf.gauges_due(t) {
+            self.perf
+                .set_frame_medians(median(&mut self.cpu_ms), median(&mut self.gpu_ms));
+        }
+        let connection = self.connection.as_deref();
+        self.perf
+            .tick(t, wall_ms, detail, world, || wire_of(connection));
+        if let Some((end, reason)) = self.window
+            && t >= end
+        {
+            self.stop_with_gpu(t, reason, gpu());
+        }
+    }
+
+    /// The GPU frames timed since the last frame, with this frame's CPU ms, for a capture that times the GPU.
+    pub fn gpu_frames(&mut self, t: f64, cpu_ms: f32, frames: &TimedFrames) {
+        self.perf.gpu_frames(t, cpu_ms, frames);
+    }
+
+    /// Opens a capture in `dir`; call it on the render thread, which it samples.
+    pub fn start(
+        &mut self,
+        t: f64,
+        dir: &Path,
+        trigger: Trigger,
+        options: &StartOptions,
+        start: Start,
+        block_names: Vec<String>,
+    ) -> std::io::Result<PathBuf> {
+        let capture = CaptureOptions {
+            window_s: options.seconds.map(f64::from),
+            trigger,
+            start,
+            samples: options.samples,
+            sampler: SamplerOptions {
+                hz: options.hz,
+                over_ms: options.over_ms,
+                wall: options.wall,
+                all_threads: options.threads == Threads::All,
+            },
+            block_names,
+            levels: Vec::new(),
+            wire: wire_of(self.connection.as_deref()),
+            gpu: options.gpu.mode(),
+            timeline: options.timeline.then(Default::default),
+            file: options.file.clone(),
+        };
+        let path = self.perf.start_capture(t, dir, capture)?;
+        self.window = Some(match options.seconds {
+            Some(s) => (t + f64::from(s), StopReason::Normal),
+            None => (t + MAX_WINDOW_S, StopReason::WindowCap),
+        });
+        self.running = Some((options.clone(), trigger));
+        Ok(path)
+    }
+
+    /// What the server thread needs to write its side into the running capture; None when none runs.
+    pub fn join(&self) -> Option<Join> {
+        let (sender, path, origin) = self.perf.joinable()?;
+        let (options, trigger) = self.running.clone()?;
+        let at = |t: f64| self.epoch + Duration::from_secs_f64(t.max(0.0));
+        Some(Join {
+            sender,
+            path,
+            origin: at(origin),
+            ends: self.window.map(|(end, reason)| (at(end), reason)),
+            options,
+            trigger,
+        })
+    }
+
+    /// Ends the running capture; its file is finished off this thread and comes back from [`ClientPerf::take_saved`].
+    pub fn stop(&mut self, t: f64, reason: StopReason) -> bool {
+        self.stop_with(t, reason, None, Vec::new())
+    }
+
+    /// [`ClientPerf::stop`], recording `gpu`'s pass timings if the capture asked for them.
+    pub fn stop_with_gpu(&mut self, t: f64, reason: StopReason, gpu: Option<GpuReadout>) -> bool {
+        self.stop_with(t, reason, gpu, Vec::new())
+    }
+
+    /// [`ClientPerf::stop_with_gpu`] with benchmark reports embedded in the capture.
+    pub fn stop_with(
+        &mut self,
+        t: f64,
+        reason: StopReason,
+        gpu: Option<GpuReadout>,
+        bench: Vec<BenchResult>,
+    ) -> bool {
+        self.window = None;
+        self.running = None;
+        let end = CaptureEnd {
+            gpu,
+            bench,
+            wire: wire_of(self.connection.as_deref()),
+            ..CaptureEnd::default()
+        };
+        self.perf.begin_stop(t, reason, end)
+    }
+
+    /// Whether a stopped capture's file is still being finished or waits to be taken.
+    pub fn saving(&self) -> bool {
+        self.perf.finishing()
+    }
+
+    /// The captures whose files are done; with `wait`, every one begun.
+    pub fn take_saved(&mut self, wait: bool) -> Vec<std::io::Result<Saved>> {
+        self.perf.take_saved(wait)
+    }
+
+    pub fn mark(&mut self, t: f64, name: &str) -> bool {
+        self.perf.mark(t, name)
+    }
+
+    /// Records a memory snapshot in the running capture; false when none runs.
+    pub fn memory_snapshot(&mut self, t: f64, label: &str, rows: &[(String, f64)]) -> bool {
+        self.perf.memory_snapshot(t, label, rows)
+    }
+
+    /// Records `code` in the running capture; false when none runs.
+    pub fn warn(&mut self, t: f64, code: WarningCode) -> bool {
+        self.perf.warn(t, code)
+    }
+
+    pub fn status(&self, t: f64) -> Option<CaptureStatus> {
+        self.perf.status(t)
+    }
+
+    /// The seconds left in the running capture's window.
+    pub fn remaining_s(&self, t: f64) -> Option<f64> {
+        self.window.map(|(end, _)| (end - t).max(0.0))
+    }
+}
+
+/// A benchmark report as the capture embeds it, minus its local-only label and paths; anything but a `horizon-benchmark-report` is refused.
+pub fn bench_result(report_json: String) -> Result<BenchResult, String> {
+    let mut report = horizon_bench::Report::parse(&report_json)?;
+    report.label = None;
+    report.local.clear();
+    Ok(BenchResult {
+        side: Side::Client as i32,
+        format: horizon_bench::FORMAT.to_owned(),
+        report_json: report.to_json(),
+        corpus_id: String::new(),
+    })
+}
+
+/// The median of the values, which are cleared; None when there were none.
+fn median(values: &mut Vec<f32>) -> Option<f32> {
+    values.sort_by(f32::total_cmp);
+    let rank = values.len().div_ceil(2);
+    let m = rank.checked_sub(1).map(|i| values[i]);
+    values.clear();
+    m
+}
+
+/// `Start` for a client capture: its build and machine; the capture fills the rest.
+pub fn start_message(same_process: bool, gpu: Option<&str>) -> Start {
+    let mut machine: Machine = server_perf::machine(Some(
+        server_perf::hardware().unwrap_or_else(server_perf::hardware_now),
+    ));
+    if let Some(gpu) = gpu {
+        machine.gpu = gpu.to_owned();
+    }
+    Start {
+        build: Some(server_perf::build()),
+        machine: Some(machine),
+        same_process,
+        ..Start::default()
+    }
+}
@@ -0,0 +1,519 @@
+//! `horizon-ctl profile`: the words the game receives, as typed requests, and the typed replies.
+use horizon_perf_format::v1::GpuMode;
+use serde::{Deserialize, Serialize};
+use std::ops::RangeInclusive;
+use std::path::PathBuf;
+use std::str::FromStr;
+
+/// The longest name a mark takes; it is the one free text in a capture.
+pub const MARK_NAME_MAX: usize = 100;
+/// The sampler's rate bounds, per second.
+pub const HZ_RANGE: RangeInclusive<u32> = 10..=1000;
+
+/// Which side `profile` addresses; no side means every side the game can reach.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ProfileSide {
+    Client,
+    Server,
+}
+
+impl FromStr for ProfileSide {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, String> {
+        match s {
+            "client" => Ok(Self::Client),
+            "server" => Ok(Self::Server),
+            other => Err(format!("unknown side {other}; use client or server")),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Threads {
+    Main,
+    All,
+}
+
+impl FromStr for Threads {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, String> {
+        match s {
+            "main" => Ok(Self::Main),
+            "all" => Ok(Self::All),
+            other => Err(format!("unknown threads {other}; use main or all")),
+        }
+    }
+}
+
+/// What `--gpu` records: nothing, the passes' times, or also their parts and counters.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum GpuSwitch {
+    #[default]
+    Off,
+    Passes,
+    Detail,
+}
+
+impl FromStr for GpuSwitch {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, String> {
+        match s {
+            "passes" => Ok(Self::Passes),
+            "detail" => Ok(Self::Detail),
+            other => Err(format!(
+                "unknown --gpu value {other}; use --gpu, --gpu=passes or --gpu=detail"
+            )),
+        }
+    }
+}
+
+impl GpuSwitch {
+    pub fn mode(self) -> GpuMode {
+        match self {
+            Self::Off => GpuMode::Off,
+            Self::Passes => GpuMode::Passes,
+            Self::Detail => GpuMode::Detail,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Action {
+    Start,
+    Stop,
+    Status,
+    Mark,
+    Open,
+    Share,
+}
+
+impl FromStr for Action {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, String> {
+        match s {
+            "start" => Ok(Self::Start),
+            "stop" => Ok(Self::Stop),
+            "status" => Ok(Self::Status),
+            "mark" => Ok(Self::Mark),
+            "open" => Ok(Self::Open),
+            "share" => Ok(Self::Share),
+            other => Err(format!("unknown profile action {other}")),
+        }
+    }
+}
+
+/// The switches of `profile start`.
+#[derive(Clone, Debug, PartialEq)]
+pub struct StartOptions {
+    /// Unset runs until `stop`, or the longest window.
+    pub seconds: Option<u32>,
+    pub hz: Option<u32>,
+    pub over_ms: Option<f32>,
+    pub threads: Threads,
+    pub wall: bool,
+    pub samples: bool,
+    pub gpu: GpuSwitch,
+    /// Also record every thread's spans (`--timeline`), for 60 s at most.
+    pub timeline: bool,
+    /// Write the capture here instead of into the reports folder: `trace` and `HORIZON_TRACE` only, never a profile switch.
+    pub file: Option<PathBuf>,
+}
+
+impl Default for StartOptions {
+    fn default() -> Self {
+        Self {
+            seconds: None,
+            hz: None,
+            over_ms: None,
+            threads: Threads::Main,
+            wall: false,
+            samples: true,
+            gpu: GpuSwitch::Off,
+            timeline: false,
+            file: None,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Request {
+    Start(StartOptions),
+    /// With the path of a benchmark report to embed in the capture.
+    Stop {
+        bench: Option<String>,
+    },
+    Status,
+    Mark(String),
+    /// Open the saved capture in the viewer, through the captures hook.
+    Open(PathBuf),
+    /// Upload the saved capture, through the captures hook; the reply is the link.
+    Share(PathBuf),
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Parsed {
+    pub side: Option<ProfileSide>,
+    pub request: Request,
+}
+
+const USAGE: &str = "profile [client|server] start [--seconds S] [--hz N] [--over MS] [--threads main|all] [--wall] [--gpu[=detail]] [--no-samples] [--timeline] | stop [--bench REPORT] | status | mark NAME | open FILE | share FILE";
+
+/// The words after `profile`; the side comes first or as `--side`, and the switches follow `start`.
+pub fn parse(words: &[&str]) -> Result<Parsed, String> {
+    let (mut side, words) = match words.first().map(|w| w.parse::<ProfileSide>()) {
+        Some(Ok(side)) => (Some(side), &words[1..]),
+        _ => (None, words),
+    };
+    let Some((action, rest)) = words.split_first() else {
+        return Err(format!("usage: {USAGE}"));
+    };
+    let action: Action = action.parse().map_err(|e| format!("{e}; usage: {USAGE}"))?;
+    if action == Action::Mark {
+        return mark(side, rest);
+    }
+    if matches!(action, Action::Open | Action::Share) {
+        let file = rest.join(" ");
+        if file.is_empty() {
+            return Err(format!("{} needs a FILE; usage: {USAGE}", words[0]));
+        }
+        let file = PathBuf::from(file);
+        let request = match action {
+            Action::Open => Request::Open(file),
+            _ => Request::Share(file),
+        };
+        return Ok(Parsed {
+            side: None,
+            request,
+        });
+    }
+    let mut options = StartOptions::default();
+    let mut switched = false;
+    let mut bench = None;
+    let mut words = rest.iter().copied().peekable();
+    while let Some(word) = words.next() {
+        let mut value = || {
+            words
+                .next()
+                .ok_or_else(|| format!("{word} needs a value; usage: {USAGE}"))
+        };
+        match word {
+            "--side" => side = Some(value()?.parse()?),
+            "--seconds" => options.seconds = Some(number(word, value()?, 1..=600)?),
+            "--hz" => options.hz = Some(number(word, value()?, HZ_RANGE)?),
+            "--over" => {
+                let ms: f32 = value()?
+                    .parse()
+                    .map_err(|_| "--over must be a number of milliseconds".to_owned())?;
+                if !ms.is_finite() || ms <= 0.0 {
+                    return Err("--over must be more than 0".into());
+                }
+                options.over_ms = Some(ms);
+            }
+            "--threads" => options.threads = value()?.parse()?,
+            "--wall" => options.wall = true,
+            "--gpu" => {
+                options.gpu = match words.next_if(|w| w.parse::<GpuSwitch>().is_ok()) {
+                    Some(kind) => kind.parse()?,
+                    None => GpuSwitch::Passes,
+                }
+            }
+            _ if word.starts_with("--gpu=") => options.gpu = word["--gpu=".len()..].parse()?,
+            "--no-samples" => options.samples = false,
+            "--timeline" => options.timeline = true,
+            "--bench" => {
+                // The line arrives split on whitespace, so a run of spaces or a tab in the path becomes one space.
+                let path = words.by_ref().collect::<Vec<_>>().join(" ");
+                if path.is_empty() {
+                    return Err(format!("--bench needs a report path; usage: {USAGE}"));
+                }
+                bench = Some(path);
+                continue;
+            }
+            other => return Err(format!("unexpected {other}; usage: {USAGE}")),
+        }
+        switched |= word != "--side";
+    }
+    let request = match action {
+        Action::Start if bench.is_some() => {
+            return Err(format!("only stop takes --bench; usage: {USAGE}"));
+        }
+        Action::Start => Request::Start(options),
+        _ if switched => return Err(format!("only start takes options; usage: {USAGE}")),
+        Action::Stop => Request::Stop { bench },
+        _ if bench.is_some() => return Err(format!("only stop takes --bench; usage: {USAGE}")),
+        _ => Request::Status,
+    };
+    Ok(Parsed { side, request })
+}
+
+fn mark(mut side: Option<ProfileSide>, mut words: &[&str]) -> Result<Parsed, String> {
+    if let [flag @ "--side", value, rest @ ..] = words {
+        let _ = flag;
+        side = Some(value.parse()?);
+        words = rest;
+    }
+    let name = words.join(" ");
+    if name.is_empty() {
+        return Err("mark needs a NAME".into());
+    }
+    if name.chars().count() > MARK_NAME_MAX || name.chars().any(char::is_control) {
+        return Err(format!(
+            "a mark name is at most {MARK_NAME_MAX} characters without control characters"
+        ));
+    }
+    Ok(Parsed {
+        side,
+        request: Request::Mark(name),
+    })
+}
+
+fn number(flag: &str, text: &str, range: RangeInclusive<u32>) -> Result<u32, String> {
+    match text.parse::<u32>() {
+        Ok(n) if range.contains(&n) => Ok(n),
+        _ => Err(format!(
+            "{flag} must be a whole number from {} to {}",
+            range.start(),
+            range.end()
+        )),
+    }
+}
+
+/// The reply to `profile start`.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Started {
+    pub ok: bool,
+    /// The sides asked for, server first; the server thread's join is confirmed by `status` and `stop`.
+    pub sides: Vec<ProfileSide>,
+    pub path: String,
+    pub seconds: Option<u32>,
+    pub samples: bool,
+    pub gpu: GpuSwitch,
+}
+
+/// The reply to `profile stop`, once the file is whole.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Stopped {
+    pub ok: bool,
+    pub sides: Vec<ProfileSide>,
+    pub path: String,
+    /// The viewer page, when the build has a part that opens captures.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub open_at: Option<String>,
+    pub removed: Vec<String>,
+}
+
+/// The viewer page a registered captures hook offers.
+pub fn viewer() -> Option<String> {
+    horizon_hooks::engine::captures().map(|c| c.viewer().to_owned())
+}
+
+/// The reply to `profile status`.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Status {
+    pub ok: bool,
+    pub capturing: bool,
+    pub sides: Vec<ProfileSide>,
+    pub path: Option<String>,
+    pub elapsed_s: Option<f64>,
+    pub bytes: Option<u64>,
+}
+
+/// The reply of a deferred `profile stop` that failed.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Failed {
+    pub error: String,
+}
+
+/// The reply to `trace`: whether a timeline capture runs, and where it writes.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Traced {
+    pub ok: bool,
+    pub tracing: bool,
+    pub file: Option<String>,
+}
+
+/// The reply to `profile open`: the viewer the capture was opened in.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Opened {
+    pub ok: bool,
+    pub viewer: String,
+}
+
+/// The reply to `profile share`: the capture's share link.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Shared {
+    pub ok: bool,
+    pub url: String,
+}
+
+/// The reply to `profile mark`.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Marked {
+    pub ok: bool,
+    pub name: String,
+    /// Seconds on the game clock, which counts from when the game began, for every side.
+    pub t: f64,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn p(line: &str) -> Result<Parsed, String> {
+        parse(&line.split_whitespace().collect::<Vec<_>>())
+    }
+
+    #[test]
+    fn open_and_share_take_a_file_with_spaces_kept() {
+        assert_eq!(
+            p("open reports/a.hzperf").unwrap().request,
+            Request::Open(PathBuf::from("reports/a.hzperf"))
+        );
+        assert_eq!(
+            p("share /tmp/my  capture.hzperf").unwrap().request,
+            Request::Share(PathBuf::from("/tmp/my capture.hzperf"))
+        );
+        assert!(p("open").is_err());
+        assert!(p("share").is_err());
+    }
+
+    #[test]
+    fn the_side_comes_first_or_as_a_flag() {
+        let a = p("client start --seconds 30").unwrap();
+        let b = p("start --side client --seconds 30").unwrap();
+        assert_eq!(a, b);
+        assert_eq!(a.side, Some(ProfileSide::Client));
+        assert_eq!(p("start").unwrap().side, None);
+        assert_eq!(p("server stop").unwrap().side, Some(ProfileSide::Server));
+        assert_eq!(
+            p("stop --side client").unwrap().side,
+            Some(ProfileSide::Client)
+        );
+    }
+
+    #[test]
+    fn every_start_switch_lands_in_its_field() {
+        let Request::Start(o) = p(
+            "start --hz 500 --over 12.5 --threads all --wall --gpu=detail --no-samples --timeline --seconds 9",
+        )
+        .unwrap()
+        .request
+        else {
+            panic!("not a start");
+        };
+        assert_eq!(
+            o,
+            StartOptions {
+                seconds: Some(9),
+                hz: Some(500),
+                over_ms: Some(12.5),
+                threads: Threads::All,
+                wall: true,
+                samples: false,
+                gpu: GpuSwitch::Detail,
+                timeline: true,
+                file: None,
+            }
+        );
+    }
+
+    #[test]
+    fn a_mark_takes_the_rest_of_the_line_as_its_name() {
+        assert_eq!(
+            p("mark   loaded the nether").unwrap().request,
+            Request::Mark("loaded the nether".into())
+        );
+        assert_eq!(
+            p("client mark --wall").unwrap(),
+            Parsed {
+                side: Some(ProfileSide::Client),
+                request: Request::Mark("--wall".into())
+            }
+        );
+        assert_eq!(
+            p("mark --side client the nether").unwrap(),
+            Parsed {
+                side: Some(ProfileSide::Client),
+                request: Request::Mark("the nether".into())
+            }
+        );
+        assert!(p("mark").is_err());
+        assert!(p("mark --side client").is_err());
+        assert!(p(&format!("mark {}", "x".repeat(MARK_NAME_MAX + 1))).is_err());
+        assert!(p(&format!("mark {}", "x".repeat(MARK_NAME_MAX))).is_ok());
+    }
+
+    #[test]
+    fn stop_takes_the_rest_of_the_line_as_a_report_path() {
+        assert_eq!(p("stop").unwrap().request, Request::Stop { bench: None });
+        let with = p("client stop --bench /home/a b/games/benchmarks/game-1.json").unwrap();
+        assert_eq!(with.side, Some(ProfileSide::Client));
+        assert_eq!(
+            with.request,
+            Request::Stop {
+                bench: Some("/home/a b/games/benchmarks/game-1.json".into())
+            }
+        );
+        for line in [
+            "stop --bench",
+            "start --bench x.json",
+            "status --bench x.json",
+        ] {
+            assert!(p(line).is_err(), "{line:?} was accepted");
+        }
+    }
+
+    #[test]
+    fn bad_words_are_refused_with_the_usage() {
+        for line in [
+            "",
+            "client",
+            "begin",
+            "start --seconds 0",
+            "start --seconds 601",
+            "start --seconds",
+            "start --hz 5",
+            "start --over 0",
+            "start --over nan",
+            "start --threads some",
+            "start --gpu=all",
+            "start --gpu=",
+            "stop now",
+            "stop --wall",
+            "status --hz 100",
+            "start --side everyone",
+        ] {
+            assert!(p(line).is_err(), "{line:?} was accepted");
+        }
+        assert!(p("start --gpu=all").unwrap_err().contains("--gpu=detail"));
+        assert!(
+            p("start --gpu fast")
+                .unwrap_err()
+                .contains("usage: profile")
+        );
+    }
+
+    #[test]
+    fn gpu_alone_records_the_passes_and_detail_asks_for_more() {
+        let gpu = |line: &str| match p(line).unwrap().request {
+            Request::Start(o) => o.gpu,
+            other => panic!("{other:?}"),
+        };
+        assert_eq!(gpu("start"), GpuSwitch::Off);
+        assert_eq!(gpu("start --gpu"), GpuSwitch::Passes);
+        assert_eq!(
+            gpu("client start --seconds 5 --gpu=detail"),
+            GpuSwitch::Detail
+        );
+        assert_eq!(gpu("start --gpu detail --wall"), GpuSwitch::Detail);
+        assert_eq!(gpu("start --gpu --wall"), GpuSwitch::Passes);
+        assert!(p("stop --gpu").is_err(), "only start takes options");
+    }
+}
@@ -10,6 +10,7 @@
 //! writes `{"transport":"tcp","port":N,"token":"..."}` to the path, readable
 //! only by its user; a client's first line must then be `auth TOKEN`.
 use crate::block_entity_render::StaticCacheFrameStats;
+use horizon_threads::alloc_count::{Counts, ON};
 use std::{
    io::{self, BufRead, BufReader, Read, Write},
    net::{Ipv4Addr, TcpListener, TcpStream},
@@ -20,6 +21,7 @@ use std::{
        mpsc,
    },
    thread,
+    time::Instant,
 };

 #[cfg(unix)]
@@ -497,6 +499,7 @@ mod tests {
    }

    use super::*;
+    use std::time::Duration;

    /// The check agrees with the system at every length around its limit.
    #[cfg(unix)]
@@ -602,6 +605,22 @@ mod tests {
        assert!(same_token("abc", "abc") && !same_token("abc", "abd") && !same_token("a", "ab"));
    }

+    #[test]
+    fn the_series_cover_every_frame_the_summary_counts() {
+        let mut stats = FrameStats::default();
+        for ms in [4.0, 5.0, 6.0] {
+            stats.record(ms);
+            stats.record_cpu(ms / 2.0);
+        }
+        let mut summary = stats.summary();
+        assert!(summary.get("frame_ms").is_none());
+        stats.add_series(&mut summary);
+        assert_eq!(summary["frame_ms"], serde_json::json!([4.0, 5.0, 6.0]));
+        assert_eq!(summary["cpu_ms"], serde_json::json!([2.0, 2.5, 3.0]));
+        assert_eq!(summary["gpu_ms"], serde_json::json!([]));
+        assert_eq!(summary["frames"], 3);
+    }
+
    #[test]
    fn frame_summary_reports_block_entity_cache_work() {
        let mut stats = FrameStats::default();
@@ -625,6 +644,67 @@ mod tests {
        assert_eq!(summary["static_entities_drawn_avg_per_frame"], 4.0);
        assert_eq!(summary["dynamic_entities_drawn_avg_per_frame"], 3.0);
    }
+
+    fn counts(allocs: u64, bytes: u64, frees: u64, freed: u64) -> Counts {
+        Counts {
+            allocs,
+            bytes,
+            frees,
+            freed,
+        }
+    }
+
+    #[test]
+    fn allocations_are_summarized_per_frame_and_per_second() {
+        let mut stats = FrameStats::default();
+        let start = Instant::now();
+        for (i, a) in [100u64, 200, 300, 400, 1000].into_iter().enumerate() {
+            // Window: 10 blocks kept; process: twice the blocks, 1 MiB per 100, 20 blocks and 1 MiB kept.
+            let window = counts(a, a * 1024, a - 10, 0);
+            let all = counts(
+                2 * a,
+                (2 * a / 100) << 20,
+                2 * a - 20,
+                ((2 * a / 100) - 1) << 20,
+            );
+            stats.record_allocs(window, all, start + Duration::from_millis(100 * i as u64));
+        }
+        let alloc = stats.alloc_summary();
+        let window = &alloc["window_thread"];
+        assert_eq!(window["allocs_per_frame"]["avg"], 400.0);
+        assert_eq!(window["allocs_per_frame"]["p50"], 300.0);
+        assert_eq!(window["allocs_per_frame"]["p95"], 1000.0);
+        assert_eq!(window["allocs_per_frame"]["max"], 1000.0);
+        assert_eq!(window["kib_per_frame"]["p50"], 300.0);
+        assert_eq!(window["frees_per_frame_avg"], 390.0);
+        // The first frame only starts the clock: the rates cover the four after it, 0.4 s.
+        let process = &alloc["process"];
+        assert_eq!(process["allocs_per_s"], 9500.0);
+        assert_eq!(process["frees_per_s"], 9300.0);
+        assert_eq!(process["mib_per_s"], 95.0);
+        assert_eq!(process["net_mib"], 4.0);
+        assert_eq!(stats.alloc_counts(), [100, 200, 300, 400, 1000]);
+    }
+
+    #[test]
+    fn one_frame_has_counts_but_no_rate() {
+        let mut stats = FrameStats::default();
+        stats.record_allocs(counts(5, 64, 5, 64), counts(9, 99, 9, 99), Instant::now());
+        let alloc = stats.alloc_summary();
+        assert_eq!(alloc["window_thread"]["allocs_per_frame"]["max"], 5.0);
+        assert!(alloc["process"]["allocs_per_s"].is_null());
+        assert!(FrameStats::default().alloc_summary().is_null());
+    }
+
+    #[test]
+    fn the_summary_has_alloc_only_when_the_game_counts() {
+        let mut stats = FrameStats::default();
+        stats.record(10.0);
+        stats.record_allocs(counts(5, 64, 5, 64), Counts::default(), Instant::now());
+        assert_eq!(stats.summary()["alloc"].is_null(), !ON);
+        stats.reset();
+        assert!(stats.alloc_counts().is_empty() && stats.alloc_summary().is_null());
+    }
 }

 /// Frame durations since the last reset, summarized like the Java recorder,
@@ -641,6 +721,15 @@ pub struct FrameStats {
    static_bytes_uploaded: u64,
    static_entities_drawn: u64,
    dynamic_entities_drawn: u64,
+    /// Window-thread allocations and bytes of each rendered frame (`alloc-count` builds).
+    allocs: Vec<u32>,
+    alloc_bytes: Vec<u64>,
+    /// Window-thread frees summed over the frames in `allocs`.
+    alloc_frees: u64,
+    /// When the first and the last frame since the reset were recorded.
+    alloc_span: Option<(Instant, Instant)>,
+    /// All threads' counts over the frames after the first, the time base of the rates.
+    alloc_process: Counts,
 }

 /// The parts of a frame's CPU time: world streaming and uploads, game ticks,
@@ -717,17 +806,77 @@ impl FrameStats {
        self.static_entities_drawn += stats.static_entities_drawn;
        self.dynamic_entities_drawn += stats.dynamic_entities_drawn;
    }
-    /// Every recorded frame time, in milliseconds, in order.
-    pub fn frame_millis(&self) -> &[f32] {
-        &self.millis
+    /// Adds every frame's time (`frame_ms`, `cpu_ms`, `gpu_ms`) to a summary.
+    pub fn add_series(&self, summary: &mut serde_json::Value) {
+        summary["frame_ms"] = self.millis.clone().into();
+        summary["cpu_ms"] = self.cpu.clone().into();
+        summary["gpu_ms"] = self.gpu.clone().into();
    }
-    /// CPU time of every recorded frame, in milliseconds.
-    pub fn cpu_millis(&self) -> &[f32] {
-        &self.cpu
+    /// One frame's allocations: this thread's since the last frame, all threads' since then.
+    pub fn record_allocs(&mut self, window: Counts, process: Counts, now: Instant) {
+        if self.allocs.len() < Self::LIMIT {
+            self.allocs
+                .push(u32::try_from(window.allocs).unwrap_or(u32::MAX));
+            self.alloc_bytes.push(window.bytes);
+            self.alloc_frees += window.frees;
+        }
+        match &mut self.alloc_span {
+            None => self.alloc_span = Some((now, now)),
+            Some((_, last)) => {
+                *last = now;
+                let sum = &mut self.alloc_process;
+                sum.allocs += process.allocs;
+                sum.bytes += process.bytes;
+                sum.frees += process.frees;
+                sum.freed += process.freed;
+            }
+        }
    }
-    /// GPU time of every frame the GPU timed, in milliseconds.
-    pub fn gpu_millis(&self) -> &[f32] {
-        &self.gpu
+    /// Window-thread allocations of every recorded frame, in order.
+    pub fn alloc_counts(&self) -> &[u32] {
+        &self.allocs
+    }
+    /// Window-thread bytes allocated in every recorded frame, in order.
+    pub fn alloc_bytes(&self) -> &[u64] {
+        &self.alloc_bytes
+    }
+    /// The `alloc` object of [`summary`](Self::summary), `null` before a frame was recorded.
+    fn alloc_summary(&self) -> serde_json::Value {
+        let n = self.allocs.len();
+        if n == 0 {
+            return serde_json::Value::Null;
+        }
+        let round = |v: f64| (v * 10.0).round() / 10.0;
+        let stats = |mut values: Vec<f64>| {
+            values.sort_by(f64::total_cmp);
+            let pick = |p: f64| values[((n as f64 * p).ceil() as usize).clamp(1, n) - 1];
+            serde_json::json!({
+                "avg": round(values.iter().sum::<f64>() / n as f64),
+                "p50": round(pick(0.5)),
+                "p95": round(pick(0.95)),
+                "max": round(values[n - 1]),
+            })
+        };
+        let per_second =
+            |amount: u64, seconds: f64| (seconds > 0.0).then(|| round(amount as f64 / seconds));
+        let seconds = self.alloc_span.map_or(0.0, |(first, last)| {
+            last.duration_since(first).as_secs_f64()
+        });
+        let mib = |bytes: u64| bytes as f64 / 1048576.0;
+        let process = &self.alloc_process;
+        serde_json::json!({
+            "window_thread": {
+                "allocs_per_frame": stats(self.allocs.iter().map(|&a| f64::from(a)).collect()),
+                "kib_per_frame": stats(self.alloc_bytes.iter().map(|&b| b as f64 / 1024.0).collect()),
+                "frees_per_frame_avg": round(self.alloc_frees as f64 / n as f64),
+            },
+            "process": {
+                "allocs_per_s": per_second(process.allocs, seconds),
+                "mib_per_s": (seconds > 0.0).then(|| round(mib(process.bytes) / seconds)),
+                "frees_per_s": per_second(process.frees, seconds),
+                "net_mib": round(mib(process.bytes) - mib(process.freed)),
+            },
+        })
    }
    pub fn reset(&mut self) {
        self.millis.clear();
@@ -739,6 +888,11 @@ impl FrameStats {
        self.static_bytes_uploaded = 0;
        self.static_entities_drawn = 0;
        self.dynamic_entities_drawn = 0;
+        self.allocs.clear();
+        self.alloc_bytes.clear();
+        self.alloc_frees = 0;
+        self.alloc_span = None;
+        self.alloc_process = Counts::default();
    }
    pub fn summary(&self) -> serde_json::Value {
        let mut sorted = self.millis.clone();
@@ -789,6 +943,7 @@ impl FrameStats {
            "dynamic_entities_drawn": self.dynamic_entities_drawn,
            "static_entities_drawn_avg_per_frame": self.static_entities_drawn as f64 / n as f64,
            "dynamic_entities_drawn_avg_per_frame": self.dynamic_entities_drawn as f64 / n as f64,
+            "alloc": if ON { self.alloc_summary() } else { serde_json::Value::Null },
        })
    }
 }
@@ -8,6 +8,7 @@ use crate::{
    java_text,
    text::Text,
 };
+use horizon_client_render::gfx::pack_timing::{Counters, DetailSupport, PartsMode, PassCounters};
 use std::time::{Duration, Instant};

 /// `extractLines`'s background: ARGB 0x90505050.
@@ -148,6 +149,76 @@ pub fn labelled_pass_lines(label: &str, passes: &[(String, f32)]) -> Vec<String>
    lines
 }

+/// `n` in three digits and an SI suffix: `512`, `83.0k`, `6.30M`, `1.20G`.
+pub fn compact_count(n: u64) -> String {
+    let (mut value, mut unit) = (n as f64, 0);
+    while value >= 999.5 && unit < 4 {
+        value /= 1000.0;
+        unit += 1;
+    }
+    let suffix = ["", "k", "M", "G", "T"][unit];
+    match value {
+        _ if unit == 0 => n.to_string(),
+        v if v < 9.995 => format!("{v:.2}{suffix}"),
+        v if v < 99.95 => format!("{v:.1}{suffix}"),
+        v => format!("{v:.0}{suffix}"),
+    }
+}
+
+/// F3's detail lines: each pass's parts, then the six passes with the most fragments and their segments.
+pub fn pass_detail_lines(
+    parts: &[(String, Vec<(String, f32)>)],
+    counters: &[(String, PassCounters)],
+    support: DetailSupport,
+) -> Vec<String> {
+    const SHOWN: usize = 6;
+    let tr = |key: &str, args: &[&dyn std::fmt::Display]| Text::tr(key, args).plain();
+    let mode = match support.parts {
+        PartsMode::InsidePasses => "horizon.debug.pass_detail.inside_passes",
+        PartsMode::SeparatePasses => "horizon.debug.pass_detail.separate_passes",
+    };
+    let mut lines = vec![tr("horizon.debug.pass_detail.title", &[&tr(mode, &[])])];
+    for (pass, parts) in parts {
+        for (part, ms) in parts {
+            let ms = format!("{ms:.2}");
+            lines.push(tr("horizon.debug.pass_detail.part", &[pass, part, &ms]));
+        }
+    }
+    if !support.counters {
+        lines.push(tr("horizon.debug.pass_detail.no_counters", &[]));
+        return lines;
+    }
+    let per_pixel = |fragments: u64, pixels: u64| match support.fragment_unit {
+        Some(unit) if pixels > 0 => {
+            format!("{:.2}", unit.pixels_of(fragments) as f64 / pixels as f64)
+        }
+        _ => "?".to_owned(),
+    };
+    let line = |name: &str, c: &Counters, pixels: u64| {
+        let (fragments, vertices) = (c.fragment_shader_invocations, c.vertex_shader_invocations);
+        tr(
+            "horizon.debug.pass_detail.counters",
+            &[
+                &name,
+                &compact_count(fragments),
+                &per_pixel(fragments, pixels),
+                &compact_count(vertices),
+                &compact_count(c.clipper_primitives_out),
+                &compact_count(c.clipper_invocations),
+            ],
+        )
+    };
+    let mut busiest: Vec<&(String, PassCounters)> = counters.iter().collect();
+    busiest.sort_by_key(|c| std::cmp::Reverse(c.1.total.fragment_shader_invocations));
+    for (pass, c) in busiest.into_iter().take(SHOWN) {
+        lines.push(line(pass, &c.total, c.pixels));
+        for (part, counted) in &c.parts {
+            lines.push(format!("  {}", line(part, counted, c.pixels)));
+        }
+    }
+    lines
+}
+
 /// `Mth.wrapDegrees`.
 fn wrap_degrees(angle: f32) -> f32 {
    let wrapped = angle % 360.0;
@@ -547,6 +618,7 @@ pub fn memory_lines(m: ProcessMemory, rate: i64) -> [String; 3] {
 #[cfg(test)]
 mod tests {
    use super::*;
+    use horizon_client_render::gfx::pack_timing;

    fn lines(v: &[&str]) -> Vec<String> {
        v.iter().map(|s| (*s).to_owned()).collect()
@@ -584,6 +656,88 @@ mod tests {
        assert_eq!(cache.fresh(start, layout).map(<[_]>::len), Some(0));
    }

+    #[test]
+    fn counts_read_in_three_digits_with_an_si_suffix() {
+        for (n, want) in [
+            (0, "0"),
+            (999, "999"),
+            (1000, "1.00k"),
+            (83_049, "83.0k"),
+            (999_999, "1.00M"),
+            (6_300_000, "6.30M"),
+            (1_200_000_000, "1.20G"),
+        ] {
+            assert_eq!(compact_count(n), want, "{n}");
+        }
+    }
+
+    fn counted(fragments: u64, parts: &[(&str, u64)]) -> PassCounters {
+        let c = |fragment_shader_invocations| Counters {
+            vertex_shader_invocations: 1000,
+            clipper_invocations: 400,
+            clipper_primitives_out: 300,
+            fragment_shader_invocations,
+        };
+        PassCounters {
+            total: c(fragments),
+            pixels: 1000,
+            parts: parts.iter().map(|p| (p.0.to_owned(), c(p.1))).collect(),
+        }
+    }
+
+    #[test]
+    fn pass_detail_lines_list_parts_then_the_six_busiest_passes_with_segments() {
+        let support = DetailSupport {
+            parts: PartsMode::InsidePasses,
+            encoder_stamps: true,
+            counters: true,
+            fragment_unit: Some(pack_timing::FragmentUnit::Quad),
+        };
+        let parts = vec![("GPU culling".to_owned(), vec![("cull".to_owned(), 0.3141)])];
+        let mut counters: Vec<(String, PassCounters)> = (1..=7)
+            .map(|i| (format!("P{i}"), counted(i * 100, &[])))
+            .collect();
+        counters[2].1 = counted(1_000_000, &[("a", 600_000), ("b", 400_000)]);
+        let (lines, _) = crate::lang::scoped(crate::lang::Language::load(&[], "en_us"), || {
+            pass_detail_lines(&parts, &counters, support)
+        });
+        assert_eq!(
+            lines,
+            [
+                "Horizon pass detail (timestamps inside passes)",
+                "GPU culling › cull: 0.31 ms",
+                "P3: 1.00M fragments, 4000.00 per pixel, 1.00k vertices, 300 of 400 triangles kept",
+                "  a: 600k fragments, 2400.00 per pixel, 1.00k vertices, 300 of 400 triangles kept",
+                "  b: 400k fragments, 1600.00 per pixel, 1.00k vertices, 300 of 400 triangles kept",
+                "P7: 700 fragments, 2.80 per pixel, 1.00k vertices, 300 of 400 triangles kept",
+                "P6: 600 fragments, 2.40 per pixel, 1.00k vertices, 300 of 400 triangles kept",
+                "P5: 500 fragments, 2.00 per pixel, 1.00k vertices, 300 of 400 triangles kept",
+                "P4: 400 fragments, 1.60 per pixel, 1.00k vertices, 300 of 400 triangles kept",
+                "P2: 200 fragments, 0.80 per pixel, 1.00k vertices, 300 of 400 triangles kept",
+            ]
+        );
+    }
+
+    #[test]
+    fn pass_detail_lines_say_so_when_the_device_has_no_counters() {
+        let support = DetailSupport {
+            parts: PartsMode::SeparatePasses,
+            encoder_stamps: false,
+            counters: false,
+            fragment_unit: None,
+        };
+        let (lines, _) = crate::lang::scoped(crate::lang::Language::load(&[], "en_us"), || {
+            pass_detail_lines(&[], &[], support)
+        });
+        assert_eq!(
+            lines,
+            [
+                "Horizon pass detail (separate passes, adds GPU time)",
+                "GPU counters: Vulkan only"
+            ]
+        );
+    }
+
    #[test]
    fn looking_at_lines_match_vanilla() {
        let props = [
@@ -75,6 +75,12 @@ fn grid_state(count: u32, mut x: i32, mut z: i32) -> u32 {
 impl ChunkGenerator for DebugTerrain {
    type Worker = ();
    fn worker(&self) {}
+    /// DebugLevelSource's proto is already its decorated column. Keep a copy
+    /// for lighting a finished neighbour outside the kept area, matching the
+    /// vanilla FEATURES neighbour path.
+    fn light_view(&self, proto: &crate::streaming::Proto) -> Option<Chunk> {
+        proto.downcast_ref::<Chunk>().cloned()
+    }
    /// `DebugLevelSource.buildTerrain` builds nothing; `applyBiomeDecoration`
    /// writes the barriers and the grid.
    fn proto(&self, _: &mut (), cx: i32, cz: i32) -> crate::streaming::Proto {
@@ -128,4 +134,20 @@ mod tests {
        assert_eq!(grid_state(1000, 65, 1), 0);
        assert_eq!(grid_state(1000, 61, 3), 30 * 32 + 1);
    }
+
+    #[test]
+    fn light_view_keeps_a_debug_proto_column() {
+        let terrain = DebugTerrain {
+            shape: LevelShape::OVERWORLD,
+            biome: 0,
+            barrier: 0,
+            states: 0,
+        };
+        let mut chunk = Chunk::empty(-2, 5);
+        chunk.set(0, 0, 0, 42);
+        let proto: crate::streaming::Proto = Box::new(chunk);
+        let view = terrain.light_view(&proto).expect("debug proto light view");
+        assert_eq!((view.x, view.z), (-2, 5));
+        assert_eq!(view.block(0, 0, 0).0, 42);
+    }
 }
@@ -1652,9 +1652,7 @@ pub fn mob_to_nbt(
        if let Some(saddle) = m.saddle_item() {
            equipment.insert("saddle".into(), crate::save::item_to_nbt(&saddle));
        }
-        // A happy ghast wears its harness in the body slot (and a nautilus
-        // its armour, a sulfur cube its swallowed block, a wolf its armor,
-        // with the durability it lost).
+        // Body slot: harness, armour, a cube's block, a wolf's armor; emptied, it leaves the earlier save.
        if crate::mobs::species::body_slot(m.species())
            && let Some(id) = &m.extra.body
        {
@@ -1664,6 +1662,8 @@ pub fn mob_to_nbt(
                stack.extra = m.extra.body_extra.clone();
            }
            equipment.insert("body".into(), crate::save::item_to_nbt(&stack));
+        } else if crate::mobs::species::body_slot(m.species()) {
+            equipment.remove(&"body".into());
        }
        // Vanilla saves `equipment` only when something is equipped.
        if equipment.is_empty() {
@@ -2867,7 +2867,7 @@ pub fn evoker_fangs_to_nbt(
        motion: raw.map(motion).unwrap_or(Vec3::ZERO),
        rotation: [yaw, raw.map(rotation).unwrap_or([0.0; 2])[1]],
        on_ground: raw.is_some_and(|t| flag(t, "OnGround")),
-        fall_distance: 0.0,
+        fall_distance: raw.map_or(0.0, |t| ground_from_nbt(t).1),
    }
    .tag(raw);
    put(&mut tag, "Warmup", Tag::Int(warmup));
@@ -4163,6 +4163,28 @@ mod tests {
        );
    }

+    /// `EvokerFangs` extends `Entity` and never moves: `Entity.saveWithoutId`
+    /// writes the `fall_distance` it loaded, and 0 for fangs a spell made.
+    #[test]
+    fn evoker_fangs_keep_their_loaded_fall_distance() {
+        let raw = horizon_world::nbt::parse_snbt(
+            "{id:\"minecraft:evoker_fangs\",Pos:[1d,200d,1d],fall_distance:5.0d,Warmup:100}",
+        )
+        .unwrap()
+        .0;
+        let at = super::Vec3::new(1.0, 200.0, 1.0);
+        let fall = |raw: Option<&super::Tag>| match super::evoker_fangs_to_nbt(
+            at, 0.0, 99, None, [1; 4], raw,
+        )
+        .get("fall_distance")
+        {
+            Some(super::Tag::Double(bits)) => f64::from_bits(*bits),
+            other => panic!("no fall_distance: {other:?}"),
+        };
+        assert_eq!(fall(Some(&raw)), 5.0);
+        assert_eq!(fall(None), 0.0);
+    }
+
    /// `Shulker` reads `AttachFace` as a byte before
    /// `Direction.from3DDataValue` (`abs(data % 6)`): an int is narrowed
    /// first, so 258 is byte 2, not 258 % 6 = 0, and 250 is byte -6, face 0.
@@ -4549,6 +4571,37 @@ mod tests {
        assert_eq!(id("head"), "minecraft:iron_helmet");
    }

+    /// A body item taken off (`/item replace entity <cube> armor.body with minecraft:air`)
+    /// is not saved again from the entity's earlier save: vanilla writes `equipment.body` only
+    /// while the slot holds something (#12038).
+    #[test]
+    fn an_emptied_body_slot_is_not_saved_from_the_earlier_nbt() {
+        let mut kind = crate::mobs::sensor_scan_tests::kind();
+        let ty = Arc::make_mut(&mut kind);
+        ty.id = "minecraft:sulfur_cube".into();
+        ty.species = crate::mobs::Species::SulfurCube;
+        let types = [("minecraft:sulfur_cube".into(), kind)].into();
+        let raw = Tag::compound([
+            ("id", string("minecraft:sulfur_cube")),
+            ("Pos", doubles(&[4.5, 220.0, 4.5])),
+            (
+                "equipment",
+                Tag::compound([(
+                    "body",
+                    Tag::compound([
+                        ("id", string("minecraft:oak_planks")),
+                        ("count", Tag::Int(1)),
+                    ]),
+                )]),
+            ),
+        ]);
+        let mut m = mob_from_nbt(&raw, &types, 1, None).unwrap();
+        assert_eq!(m.extra.body.as_deref(), Some("minecraft:oak_planks"));
+        m.extra.body = None;
+        let saved = mob_to_nbt(&m, [0; 4], Some(&raw), None, |_| None);
+        assert!(saved.get("equipment").is_none(), "{saved:?}");
+    }
+
    /// A wolf loads its armor (`equipment.body`) into the body slot with the
    /// durability it lost, and a helmet next to it into the head slot.
    #[test]
@@ -5514,6 +5567,34 @@ mod tests {
        }
    }

+    /// `Goat` reads `HasLeftHorn` and `HasRightHorn` with `getBooleanOr(key,
+    /// true)`: a number is true when its byte value is not 0, so an int 256
+    /// (byte 0) is a lost horn, as `0b` is.
+    #[test]
+    fn a_goats_horn_flags_are_read_as_bytes() {
+        let mut kind = crate::mobs::sensor_scan_tests::kind();
+        let ty = Arc::make_mut(&mut kind);
+        ty.id = "minecraft:goat".into();
+        ty.species = crate::mobs::Species::Goat;
+        let types = [("minecraft:goat".into(), kind)].into();
+        let lost = |left: Option<Tag>| {
+            let mut fields = vec![
+                ("id", string("minecraft:goat")),
+                ("Pos", doubles(&[4.5, 220.0, 4.5])),
+            ];
+            fields.extend(left.map(|v| ("HasLeftHorn", v)));
+            mob_from_nbt(&Tag::compound(fields), &types, 1, None)
+                .unwrap()
+                .extra
+                .lost_horns
+        };
+        assert_eq!(lost(None), [false, false]);
+        assert_eq!(lost(Some(Tag::Byte(1))), [false, false]);
+        assert_eq!(lost(Some(Tag::Byte(0))), [true, false]);
+        assert_eq!(lost(Some(Tag::Int(256))), [true, false]);
+        assert_eq!(lost(Some(Tag::Int(257))), [false, false]);
+    }
+
    #[test]
    fn non_mob_saves_drop_mob_flags_without_losing_entity_fields() {
        let uuid = [104, 0, 0, 1];
@@ -8003,6 +8084,14 @@ mod fireball_nbt_tests {
            ("Facing", Tag::Byte(1)),
        ]);
        assert_eq!(item_frame_from_nbt(&frame, 1).unwrap().pos, [-1, 80, 6]);
+        // BlockAttachedEntity.readAdditionalSaveData: a block_pos 16 blocks or
+        // more from the Pos block is refused for that block.
+        let mut far = painting.clone();
+        put(&mut far, "block_pos", Tag::IntArray(vec![28, 80, 22]));
+        assert_eq!(painting_from_nbt(&far).map(|p| p.0), Some([28, 80, 6]));
+        let mut near = painting.clone();
+        put(&mut near, "block_pos", Tag::IntArray(vec![28, 80, 21]));
+        assert_eq!(painting_from_nbt(&near).map(|p| p.0), Some([28, 80, 21]));
    }

    #[test]
@@ -13,7 +13,8 @@ fn loaded_pitch(raw: Option<&Tag>) -> f32 {
        0.0
    }
 }
-/// Painting.addAdditionalSaveData: `facing`, `variant` and `block_pos`.
+/// Painting.addAdditionalSaveData: `facing`, `variant` and `block_pos`, after
+/// Entity.saveWithoutId's common fields.
 pub fn painting_to_nbt(p: &Painting, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
    let (lo, hi) = p.bounds();
    let base = Base {
@@ -26,8 +27,12 @@ pub fn painting_to_nbt(p: &Painting, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
        ),
        motion: Vec3::ZERO,
        rotation: [f32::from(p.facing) * 90.0, loaded_pitch(raw)],
-        on_ground: false,
-        fall_distance: 0.0,
+        // BlockAttachedEntity.tick never moves a painting (nor runs baseTick), so its
+        // onGround and fallDistance stay the ones Entity.load read.
+        on_ground: raw.is_some_and(|raw| flag(raw, "OnGround")),
+        fall_distance: raw
+            .and_then(|raw| float(raw.get("fall_distance")))
+            .unwrap_or(0.0),
    };
    let mut tag = base.tag(raw);
    put(&mut tag, "facing", Tag::Byte(p.facing as i8));
@@ -35,21 +40,37 @@ pub fn painting_to_nbt(p: &Painting, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
    put(&mut tag, "block_pos", Tag::IntArray(p.pos.to_vec()));
    tag
 }
-/// `BlockAttachedEntity.readAdditionalSaveData`: `block_pos` when saved; a
-/// summoned one has none, and `setPos` puts its block at the block holding
-/// the summon position.
+/// `BlockAttachedEntity.readAdditionalSaveData`: `block_pos` when saved and
+/// closer than 16 blocks to the block holding `Pos`; else (a summoned one
+/// has none) `setPos` puts it at that block.
 fn attached_block_pos(tag: &Tag) -> Option<[i32; 3]> {
-    match tag.get("block_pos") {
+    let stored = match tag.get("block_pos") {
        Some(Tag::IntArray(v)) if v.len() == 3 => Some([v[0], v[1], v[2]]),
-        _ => {
-            let at = position(tag)?;
-            Some([
-                at.x.floor() as i32,
-                at.y.floor() as i32,
-                at.z.floor() as i32,
-            ])
-        }
-    }
+        _ => None,
+    };
+    let Some(at) = position(tag) else {
+        return stored;
+    };
+    let here = [
+        at.x.floor() as i32,
+        at.y.floor() as i32,
+        at.z.floor() as i32,
+    ];
+    // Vec3i.closerThan(blockPosition(), 16): the squared distance under 256.
+    let near = |p: &[i32; 3]| {
+        (0..3)
+            .map(|i| (f64::from(p[i]) - f64::from(here[i])).powi(2))
+            .sum::<f64>()
+            < 256.0
+    };
+    Some(stored.filter(near).unwrap_or(here))
+}
+/// The block position and facing of a saved painting (`HangingEntity`'s
+/// `facing`, a 2D direction).
+pub fn painting_placement_from_nbt(tag: &Tag) -> Option<([i32; 3], u8)> {
+    let pos = attached_block_pos(tag)?;
+    let facing = wrap_data_value(number(tag.get("facing")).unwrap_or(0), 4);
+    Some((pos, facing))
 }
 /// `Direction.from3DDataValue` / `from2DDataValue`: the byte read by
 /// `LEGACY_ID_CODEC` indexes the table as `abs(data % modulus)`, never clamped.
@@ -59,8 +80,7 @@ fn wrap_data_value(raw: impl TryInto<i64> + Copy, modulus: i64) -> u8 {
 }
 /// The block position, facing and variant (if saved) of a painting.
 pub fn painting_from_nbt(tag: &Tag) -> Option<([i32; 3], u8, Option<String>)> {
-    let pos = attached_block_pos(tag)?;
-    let facing = wrap_data_value(number(tag.get("facing")).unwrap_or(0), 4);
+    let (pos, facing) = painting_placement_from_nbt(tag)?;
    Some((pos, facing, text(tag.get("variant"))))
 }
 /// ItemFrame.addAdditionalSaveData.
@@ -74,10 +94,14 @@ pub fn item_frame_to_nbt(f: &ItemFrame, uuid: [i32; 4], raw: Option<&Tag>) -> Ta
            (lo[1] + hi[1]) / 2.0,
            (lo[2] + hi[2]) / 2.0,
        ),
-        motion: Vec3::ZERO,
+        // BlockAttachedEntity.tick never runs super.tick, so the Motion, onGround and
+        // fallDistance that Entity.load read stay.
+        motion: raw.map_or(Vec3::ZERO, loaded_motion),
        rotation: [0.0, 0.0],
-        on_ground: false,
-        fall_distance: 0.0,
+        on_ground: raw.is_some_and(|raw| flag(raw, "OnGround")),
+        fall_distance: raw
+            .and_then(|raw| float(raw.get("fall_distance")))
+            .unwrap_or(0.0),
    };
    let mut tag = base.tag(raw);
    // `Entity.saveWithoutId`: `CustomName` before the frame's own fields.
@@ -148,4 +172,27 @@ mod tests {
        ]);
        assert_eq!(painting_from_nbt(&tag).unwrap().1, 1);
    }
+
+    #[test]
+    fn item_frame_keeps_loaded_motion_on_ground_and_fall_distance() {
+        let tag = Tag::compound([
+            ("id", string("minecraft:item_frame")),
+            ("Pos", doubles(&[0.5, 64.0, 0.5])),
+            ("Facing", Tag::Byte(2)),
+            ("Motion", doubles(&[0.5, 20.0, -0.25])),
+            ("OnGround", Tag::Byte(1)),
+            ("fall_distance", Tag::Double(3.5f64.to_bits())),
+        ]);
+        let frame = item_frame_from_nbt(&tag, 1).unwrap();
+        let saved = item_frame_to_nbt(&frame, [1, 2, 3, 4], Some(&tag));
+        // A component beyond 10 loads as 0, the others stay.
+        assert_eq!(motion(&saved), Vec3::new(0.5, 0.0, -0.25));
+        assert!(flag(&saved, "OnGround"));
+        assert_eq!(float(saved.get("fall_distance")), Some(3.5));
+        // A frame made in play has nothing loaded: zeros.
+        let made = item_frame_to_nbt(&frame, [1, 2, 3, 4], None);
+        assert_eq!(motion(&made), Vec3::ZERO);
+        assert!(!flag(&made, "OnGround"));
+        assert_eq!(float(made.get("fall_distance")), Some(0.0));
+    }
 }
@@ -33,7 +33,6 @@ pub fn main_with(mods: crate::mod_api::Mods) {
    // The text crates ship (`horizon_hooks::lang`), loaded with the game's own languages.
    horizon_client::lang::install_crate_files(horizon_hooks::lang::engine::all());
    horizon_client::spans::startup::init(std::time::Instant::now());
-    horizon_client::spans::trace::start_from_env();
    let args: Vec<String> = std::env::args().skip(1).collect();
    let game_args = args.iter().take_while(|a| *a != "--dedicated");
    let help = game_args
@@ -317,6 +317,12 @@ pub fn settings_from_json(
 impl ChunkGenerator for FlatTerrain {
    type Worker = ();
    fn worker(&self) {}
+    /// FlatLevelSource's proto is already its decorated column. Keep a copy
+    /// for lighting a finished neighbour outside the kept area, just as the
+    /// vanilla pipeline does for FEATURES neighbours.
+    fn light_view(&self, proto: &crate::streaming::Proto) -> Option<Chunk> {
+        proto.downcast_ref::<Chunk>().cloned()
+    }
    fn lod_surface(&self, _: &mut (), _: i32, _: i32) -> Option<crate::lod::Surface> {
        self.surface
    }
@@ -610,4 +616,21 @@ mod tests {
            .is_none()
        );
    }
+
+    #[test]
+    fn light_view_keeps_a_flat_proto_column() {
+        let terrain = FlatTerrain {
+            shape: LevelShape::OVERWORLD,
+            layers: Vec::new(),
+            biome: 0,
+            surface: None,
+            void_platform: None,
+        };
+        let mut chunk = Chunk::empty(3, -4);
+        chunk.set(0, 0, 0, 42);
+        let proto: crate::streaming::Proto = Box::new(chunk);
+        let view = terrain.light_view(&proto).expect("flat proto light view");
+        assert_eq!((view.x, view.z), (3, -4));
+        assert_eq!(view.block(0, 0, 0).0, 42);
+    }
 }
@@ -219,6 +219,7 @@ mod lan_far;
 mod lan_idle;
 mod lan_mobs;
 mod lan_mount_menu;
+mod lan_op;
 mod lan_particles;
 mod lan_pvp;
 mod lan_quiet;
@@ -362,6 +363,8 @@ mod paintings;
 mod pandas;
 mod particle_culling;
 mod passengers;
+mod perf_link;
+mod perf_remote;
 mod persist;
 mod perspective;
 mod physical_trigger;
@@ -384,6 +387,8 @@ mod potent_sulfur;
 mod potions;
 mod powder_snow;
 mod prediction;
+mod profile_capture;
+mod profile_lines;
 mod pumpkin;
 mod quick_actions;
 mod raids;
@@ -471,7 +476,6 @@ mod trial_spawner;
 mod trial_visuals;
 mod trident;
 mod tutorial;
-mod tweaks;
 mod ui_control;
 mod use_hand;
 mod using_item;
@@ -2225,7 +2229,7 @@ struct Game<'a> {
    /// `AbstractContainerScreen`'s quick craft and skip-release state.
    inv_clicks: horizon_client::container_screen::Clicks,
    /// The Mouse Tweaks extra's drag and wheel (`tweaks`).
-    tweaks: tweaks::Tweaks,
+    tweaks: extras::mouse_tweaks::Tweaks,
    /// The wheel and hovered slot of `BundleMouseActions`.
    bundle_mouse: bundles::BundleMouse,
    /// The last inventory click, for the double click that gathers a stack.
@@ -2322,6 +2326,8 @@ struct Game<'a> {
    debug: bool,
    /// `horizon-ctl gpu-passes`: time Horizon's own passes on the GPU with F3 shut.
    gpu_passes: bool,
+    /// `horizon-ctl gpu-passes detail`: also dispatch times and counters.
+    gpu_pass_detail: bool,
    screen: Screen,
    observed_screen: Option<native_hooks::ObservedScreen>,
    window: Option<Arc<Window>>,
@@ -2359,9 +2365,6 @@ struct Game<'a> {
    /// `SpectatorGui`: the menu a spectator opens with the hotbar keys.
    spectator_gui: horizon_client::spectator_menu::SpectatorGui,
    previous: Instant,
-    /// When the last frame's work ended: what runs before the next one starts (`idle`, the
-    /// event loop) shows in HORIZON_SPIKES as the time between frames.
-    frame_end: Instant,
    /// FramerateLimitTracker.latestInputTime.
    last_input: Instant,
    /// Controllers (Horizon's own).
@@ -2805,6 +2808,11 @@ struct Game<'a> {
    /// When an agent's last command came.
    agent_last: Option<Instant>,
    frame_stats: horizon_client::control::FrameStats,
+    /// This thread's and all threads' allocation counts at the last rendered frame.
+    alloc_mark: Option<(
+        horizon_threads::alloc_count::Counts,
+        horizon_threads::alloc_count::Counts,
+    )>,
    /// This play session's frame and tick times, for opt-in performance statistics.
    perf: horizon_client::telemetry::Session,
    /// Control replies waiting for a rendered frame or a benchmark deadline.
@@ -2813,7 +2821,7 @@ struct Game<'a> {
    screenshot_sequence: Option<screenshot_sequence::Sequence>,
    /// `render-capture DIR`: replied once the renderer wrote the scene.
    pending_render_capture: Option<std::sync::mpsc::Sender<String>>,
-    pending_bench: Option<(Instant, std::sync::mpsc::Sender<String>)>,
+    pending_bench: Option<(Instant, std::sync::mpsc::Sender<String>, bool)>,
    /// Recent frame times for the performance overlay.
    frame_graph: horizon_client::perf_overlay::FrameGraph,
    /// Horizon's extras (minimap, auto-reconnect; mods' counters): `game/extras.rs`.
@@ -2869,6 +2877,8 @@ struct Game<'a> {
    input_trace: input_trace::InputTrace,
    /// A repro recording, export or replay (game/repro.rs).
    repro: repro::Repro,
+    /// The health history and client captures (game/profile_capture.rs).
+    profile: profile_capture::Profile,
    /// `HORIZON_TICK_SCRIPT`'s scenario (game/tick_script.rs).
    tick_script: tick_script::TickScript,
    /// The overworld's last `sky_darken` and its inputs (time, rain, thunder).
@@ -7200,14 +7210,14 @@ impl Game<'_> {
        laps.lap("eg_objects");
        // Particles (ParticleEngine.extract): camera-facing quads.
        self.mark_stage(out.len(), "PARTICLES");
-        let world = &self.world;
        let particle_mode = self.settings.horizon.particle_culling;
        if particle_mode == horizon_client::graphics::ParticleCullingMode::Off {
-            self.particles.render(
+            self.particles.render_in_view(
                camera,
                self.particle_rotation(),
                alpha as f32,
-                &|b| world.light(b[0], b[1], b[2]),
+                self.view_frustum.as_ref(),
+                &|b| self.world.light(b[0], b[1], b[2]),
                &mut out,
            );
        } else {
@@ -7230,7 +7240,7 @@ impl Game<'_> {
                    true,
                    frustum.as_ref(),
                    &mut |min, max| particle_culling.hidden(min, max),
-                    &|b| world.light(b[0], b[1], b[2]),
+                    &|b| self.world.light(b[0], b[1], b[2]),
                    &mut out,
                );
            }
@@ -8178,19 +8188,16 @@ impl Game<'_> {
                    .ok_or("missing lit block state")?;
                state.properties.insert("lit".into(), "true".into());
                self.level_set(hit.pos, registry.resolve(&state)?)?;
-                self.audio.play(
-                    if item == "fire_charge" {
-                        "minecraft:item.firecharge.use"
-                    } else {
-                        "minecraft:item.flintandsteel.use"
-                    },
-                    Some(at(hit.pos)),
-                    1.0,
-                    horizon_client::items::fire_starter_pitch(
-                        item == "fire_charge",
-                        &mut self.world.random,
-                    ),
+                let sound = if item == "fire_charge" {
+                    "minecraft:item.firecharge.use"
+                } else {
+                    "minecraft:item.flintandsteel.use"
+                };
+                let pitch = horizon_client::items::fire_starter_pitch(
+                    item == "fire_charge",
+                    &mut self.world.random,
                );
+                self.play_block_use_sound(sound, at(hit.pos), pitch);
                // FlintAndSteelItem / FireChargeItem.useOn: BLOCK_CHANGE at the lit block,
                // and ItemStack.useOn's used statistic.
                self.post_block_game_event(
@@ -8221,7 +8228,7 @@ impl Game<'_> {
                    item == "fire_charge",
                    &mut self.world.random,
                );
-                self.audio.play(sound, Some(at(target)), 1.0, pitch);
+                self.play_block_use_sound(sound, at(target), pitch);
                // BLOCK_PLACE: flint and steel names the clicked block, a fire charge the
                // fire. Then ItemStack.useOn's used statistic.
                let placed_at = if item == "fire_charge" {
@@ -9762,9 +9769,14 @@ impl Game<'_> {
        let debug_passes = self.debug_lists_gpu_passes();
        let result = match self.renderer.as_mut() {
            Some(renderer) => {
-                renderer.set_pass_timing(debug_passes || self.gpu_passes);
-                // `gpu_passes` is a measurement: it takes every sample it can.
-                renderer.set_pass_timing_gap(if self.gpu_passes {
+                use horizon_client::client_perf::request::GpuSwitch;
+                let capture_gpu = self.profile.gpu();
+                let recording = capture_gpu != GpuSwitch::Off;
+                renderer.set_pass_timing(debug_passes || self.gpu_passes || recording);
+                renderer.set_keep_timed_frames(recording);
+                renderer.set_pass_detail(self.gpu_pass_detail || capture_gpu == GpuSwitch::Detail);
+                // `gpu_passes` and a capture's `--gpu` are measurements: they take every sample they can.
+                renderer.set_pass_timing_gap(if self.gpu_passes || recording {
                    Duration::ZERO
                } else {
                    horizon_client::debug_overlay::GPU_TIMING_GAP
@@ -11047,12 +11059,8 @@ impl Game<'_> {
                    self.observe_fullscreen();
                    self.sync_ime();
                    let now = Instant::now();
-                    let frame_cpu = self
-                        .options
-                        .spikes
-                        .and_then(|_| horizon_client::spans::thread_cpu());
+                    horizon_threads::work::tick_start();
                    let elapsed = now.duration_since(self.previous);
-                    let between = now.saturating_duration_since(self.frame_end);
                    self.frame_ticks = elapsed.as_secs_f32() * 20.0;
                    self.previous = now;
                    self.studio_fly(elapsed);
@@ -11140,46 +11148,19 @@ impl Game<'_> {
                        result => result?,
                    };
                    horizon_client::spans::time("pr_cursor", || self.apply_cursor_icon());
-                    // The frame's spans, taken every frame they are recorded so they never
-                    // pile up: the slow-frame line's, and the session's (`perf.frame`).
+                    // The frame's spans, taken every frame they are recorded so they never pile up.
                    let frame_spans = if horizon_client::spans::recording_here() {
                        horizon_client::spans::take_raw()
                    } else {
                        Vec::new()
                    };
-                    if horizon_client::spans::trace::due() {
-                        horizon_client::spans::trace::stop();
-                    }
-                    if let Some(threshold) = self.options.spikes
-                        && let Some(r) = self.renderer.as_ref()
-                    {
-                        let cpu = now.elapsed().saturating_sub(r.last_wait).as_secs_f32() * 1000.0;
-                        // Spans timed between frames (`idle`) come first.
-                        let spans = horizon_client::spans::merge(&frame_spans);
-                        let between = between.as_secs_f32() * 1000.0;
-                        if cpu > threshold || between > threshold {
-                            // The render thread's own CPU time in the frame:
-                            // far below the wall time, the frame waited.
-                            let worked = horizon_client::spans::thread_cpu()
-                                .zip(frame_cpu)
-                                .map_or_else(String::new, |(end, start)| {
-                                    format!(", cpu {:.1} ms", (end - start).as_secs_f32() * 1000.0)
-                                });
-                            let gap = if between > threshold {
-                                format!(", {between:.1} ms before it")
-                            } else {
-                                String::new()
-                            };
-                            log::info!(
-                                "Horizon: slow frame {cpu:.1} ms{worked}{gap} ({steps} ticks): {}",
-                                horizon_client::spans::describe(&spans)
-                            );
-                        }
-                    }
+                    let mut perf_times = None;
                    if let Some(r) = self.renderer.as_mut() {
                        let cpu = now.elapsed().saturating_sub(r.last_wait);
+                        horizon_threads::work::tick_end(cpu.as_nanos() as u64);
                        if rendered {
                            let ms = |d: Duration| d.as_secs_f32() * 1000.0;
+                            perf_times = Some((ms(cpu), r.gpu_times.last().copied()));
                            self.frame_graph.record(
                                ms(elapsed),
                                ms(cpu),
@@ -11259,6 +11240,17 @@ impl Game<'_> {
                    }
                    if rendered {
                        self.frame_stats.record(elapsed.as_secs_f32() * 1000.0);
+                        if let Some((cpu, gpu)) = perf_times {
+                            self.record_perf_frame(
+                                elapsed.as_secs_f32() * 1000.0,
+                                cpu,
+                                gpu,
+                                &frame_spans,
+                            );
+                        }
+                        if horizon_threads::alloc_count::ON {
+                            self.record_frame_allocs();
+                        }
                        self.debug_charts.frame_times.log(elapsed.as_nanos() as i64);
                        if self.frames == 0 {
                            // The launcher times Play to this line (launcher/src/perf.rs).
@@ -11299,7 +11291,6 @@ impl Game<'_> {
                            self.fps_frames = 0;
                            self.fps_at = Instant::now();
                        }
-                        self.frame_end = Instant::now();
                        if self.options.frames.is_some_and(|f| self.frames >= f)
                            || self
                                .options
@@ -11383,6 +11374,9 @@ impl<'a> Game<'a> {
        let inventory = vec![None; 36];
        let now = Instant::now();
        let look = options.look;
+        let slow_frame_ms = options
+            .spikes
+            .unwrap_or(horizon_client::client_perf::SLOW_FRAME_MS);
        let particles = horizon_client::particles::ParticleEngine::new(
            &root,
            &gui.atlas.sprites,
@@ -11499,6 +11493,7 @@ impl<'a> Game<'a> {
            pause: false,
            debug: false,
            gpu_passes: false,
+            gpu_pass_detail: false,
            screen: Screen::Playing,
            observed_screen: None,
            window: None,
@@ -11521,7 +11516,6 @@ impl<'a> Game<'a> {
            started: now,
            spectator_gui: Default::default(),
            previous: now,
-            frame_end: now,
            last_input: now,
            pad: Default::default(),
            frames: 0,
@@ -11775,6 +11769,7 @@ impl<'a> Game<'a> {
            agent_control_on: false,
            agent_last: None,
            frame_stats: Default::default(),
+            alloc_mark: None,
            perf: Default::default(),
            pending_screenshot: None,
            screenshot_sequence: None,
@@ -11785,6 +11780,7 @@ impl<'a> Game<'a> {
            events: Default::default(),
            input_trace: Default::default(),
            repro: Default::default(),
+            profile: profile_capture::Profile::new(slow_frame_ms),
            tick_script: tick_script::TickScript::from_env(),
            agent: agent::Agent::default(),
            view_frustum: None,
@@ -12279,10 +12275,7 @@ pub fn run_with() -> Result<()> {
        horizon_threads::catch_stop_signals();
    }
    let started = Instant::now();
-    // A dedicated server writes its slow ticks to the log with the spans
-    // they spent their time in (`HORIZON_SPIKES`'s line; the variable still
-    // sets another threshold), so a lag spike players felt can be traced
-    // from the log alone. Timing the spans costs microseconds a tick.
+    // A dedicated server times its spans always, so its slow ring holds the steps of a lag spike (microseconds a tick).
    if options.spikes.is_none()
        && options.execution_role == execution_role::ExecutionRole::DedicatedServer
    {
@@ -12593,6 +12586,35 @@ mod subtitles;
 #[cfg(test)]
 #[path = "game_tests.rs"]
 mod tests;
+#[cfg(test)]
+mod test_neighbourhood {
+    //! Shared fixture step for tests that tick entities on prepared data.
+    use super::*;
+
+    impl Game<'_> {
+        /// Loads the chunks within 2 columns of `(cx, cz)` that are not loaded yet.
+        /// Entity ticking waits for every chunk in that 5x5 neighbourhood
+        /// (`ChunkMap.prepareEntityTickingChunk`), so a fixture that ticks mobs,
+        /// items or TNT in a chunk calls this after setting up its own chunks.
+        pub(crate) fn load_ticking_neighbourhood(&mut self, cx: i32, cz: i32) {
+            for z in cz - 2..=cz + 2 {
+                for x in cx - 2..=cx + 2 {
+                    if self.world.chunks.contains_key(&(x, z)) {
+                        continue;
+                    }
+                    self.world.chunks.insert(
+                        (x, z),
+                        std::sync::Arc::new(horizon_client::chunk::Chunk::empty(x, z)),
+                    );
+                    // A chunk that is already registered keeps its ticks.
+                    let _ = self
+                        .block_ticks
+                        .add_empty_chunk(horizon_core::position::ChunkPos::new(x, z));
+                }
+            }
+        }
+    }
+}

 fn write_level_for_role(
    level: &mut Level,
@@ -51,6 +51,7 @@ fn game() -> Game<'static> {
    game.block_ticks
        .add_empty_chunk(ChunkPos::new(0, 0))
        .unwrap();
+    game.load_ticking_neighbourhood(0, 0);
    for command in [
        "forceload add 0 0",
        "fill 0 99 0 15 99 15 stone",
@@ -2709,6 +2709,7 @@ mod postbaseline_lodestone_controls {
        game.block_ticks
            .add_empty_chunk(BlockPos::new(64, 0, 64).chunk())
            .unwrap();
+        game.load_ticking_neighbourhood(0, 0);
        assert!(game.run_command("fill 64 199 64 79 199 79 stone"));
        assert!(game.run_command(&format!("summon armor_stand 65.5 200.0 65.5 {{UUID:[I;42321,0,0,102],Health:20f,NoGravity:1b,equipment:{{mainhand:{}}}}}",item("minecraft:compass",tracked,100,1))));
        let id = |n| {
@@ -15,6 +15,28 @@ use horizon_client::{
 use horizon_core::position::BlockPos;
 use horizon_world::registry::BlockStateId;

+/// The block entity type a sample is attributed to while its ticker runs.
+fn ticker_name(entity: &BlockEntity) -> &'static str {
+    match entity {
+        BlockEntity::Chest(_) => "hopper",
+        BlockEntity::Crafter(_) => "crafter",
+        BlockEntity::Jukebox(_) => "jukebox",
+        BlockEntity::Beacon(_) => "beacon",
+        BlockEntity::CreakingHeart(_) => "creaking_heart",
+        BlockEntity::Spawner(_) => "mob_spawner",
+        BlockEntity::TrialSpawner(_) => "trial_spawner",
+        BlockEntity::Vault(_) => "vault",
+        BlockEntity::Beehive(_) => "beehive",
+        BlockEntity::Furnace(_) => "furnace",
+        BlockEntity::Brewing(_) => "brewing_stand",
+        BlockEntity::DaylightDetector => "daylight_detector",
+        BlockEntity::Campfire(_) => "campfire",
+        BlockEntity::Mod(_) => "mod_block_entity",
+        BlockEntity::PotentSulfur(_) => "potent_sulfur",
+        _ => "block_entity",
+    }
+}
+
 impl Game<'_> {
    pub(super) fn tick_block_entities(&mut self) -> Result<()> {
        self.tick_mount_menu();
@@ -65,7 +87,12 @@ impl Game<'_> {
            {
                continue;
            }
-            match self.world.block_entities.get(&pos) {
+            horizon_threads::work::set_chunk(pos.0 >> 4, pos.2 >> 4);
+            let entity = self.world.block_entities.get(&pos);
+            horizon_threads::work::set_entity(horizon_threads::work::entity_id(
+                entity.map_or("", ticker_name),
+            ));
+            match entity {
                Some(BlockEntity::Chest(items)) if items.len() == HOPPER_SLOTS => {
                    self.tick_hopper(pos)
                }
@@ -100,6 +127,7 @@ impl Game<'_> {
                _ => {}
            }
        }
+        horizon_threads::work::clear_work();
        // Items move between passes: the columns hold for this one only.
        self.item_columns = None;
        self.pass_mobs = None;
@@ -224,6 +224,7 @@ impl Game<'_> {
        if !debug {
            self.tick_scheduled()?;
        }
+        horizon_threads::work::clear_work();
        self.with_level(|b, level, ticks| {
            // The masks the random ticks will read, built on helper threads first while the
            // parallel tick is on (`HORIZON_PARALLEL_TICK`): the draws and ticks don't depend on them.
@@ -271,6 +272,7 @@ impl Game<'_> {
                }
            });
        });
+        horizon_threads::work::clear_work();
        laps = horizon_client::spans::laps();
        let sent = self.lan_broadcast_changes();
        laps.lap("tb_broadcast");
@@ -1508,7 +1508,6 @@ impl Game<'_> {
            Vec3::new(b.position.x, top, b.position.z)
        }
    }
-    /// `BoatItem.use`: aim at a block or the water surface.
    /// `Entity.setYRot` on a boat just made (its old rotation moves with it).
    pub(super) fn set_boat_yaw(&mut self, id: u32, yaw: f32) {
        if let Some(b) = self.boats.iter_mut().find(|b| b.id == id) {
@@ -1516,6 +1515,7 @@ impl Game<'_> {
            b.previous_yaw = yaw;
        }
    }
+    /// `BoatItem.use`: aim at a block or the water surface.
    pub(super) fn place_boat(&mut self, stack: &ItemStack) -> bool {
        let Some(boat) = self.boat_to_place(stack) else {
            return false;
@@ -1528,7 +1528,7 @@ impl Game<'_> {
        self.world.modified.insert(key);
        let (id, kind, yaw) = (boat.id, boat.entity_type(), boat.yaw);
        self.boats.push(boat);
-        self.apply_vehicle_stack_config(super::commands::Target::Boat(id), &kind, stack, true);
+        self.apply_item_stack_config(super::commands::Target::Boat(id), &kind, stack, true);
        // BoatItem.use: setYRot(player.getYRot()) after the stack's config.
        self.set_boat_yaw(id, yaw);
        if self.serving.is_some() || self.options.dedicated.is_some() {
@@ -1765,6 +1765,82 @@ impl Game<'_> {
    pub(super) fn hurt_boat(&mut self, i: usize, damage: f32, creative: bool) -> bool {
        self.hurt_boat_result(i, damage, creative).unwrap_or(false)
    }
+    /// Whether a spectator must be refused this boat's menu.
+    pub(super) fn boat_loot_pending(&self, id: u32) -> bool {
+        matches!(
+            self.persist.raw.get(&id),
+            Some(horizon_world::nbt::Tag::Compound(map)) if map.contains_key(&"LootTable".into())
+        )
+    }
+
+    /// `ContainerEntity.unpackChestVehicleLootTable`: slot access rolls once;
+    /// only a player opening the menu fires `CriteriaTriggers.GENERATE_LOOT`, before filling.
+    pub(super) fn unpack_boat_loot(&mut self, i: usize, player: bool) {
+        use horizon_world::nbt::Tag;
+        let id = self.boats[i].id;
+        let (table, seed) = {
+            let Some(Tag::Compound(map)) = self.persist.raw.get(&id) else {
+                return;
+            };
+            let Some(table) = crate::save::text(map.get(&"LootTable".into()))
+                .and_then(|id| horizon_client_core::identifier::normalize_id(&id))
+            else {
+                return;
+            };
+            let seed = match map.get(&"LootTableSeed".into()) {
+                Some(Tag::Long(seed)) => Some(*seed),
+                _ => None,
+            };
+            (table, seed)
+        };
+        if player {
+            self.trigger_loot_table(&table);
+        }
+        // Advancement rewards can remove the boat or shift its index.
+        let Some(i) = self.boats.iter().position(|b| b.id == id) else {
+            return;
+        };
+        if let Some(Tag::Compound(map)) = self.persist.raw.get_mut(&id) {
+            map.remove(&"LootTable".into());
+            map.remove(&"LootTableSeed".into());
+        }
+        let key = (i32::MAX - 15, super::minecarts::CART_KEY_Y, id as i32);
+        self.store_cart_items(key);
+        let loot = crate::structure_blocks::loot_data(&self.options.resources, &self.pack_files());
+        let b = &self.boats[i];
+        let at = Vec3::new(b.position.x, b.position.y, b.position.z);
+        let biome = self.biome_name_at(at).unwrap_or_default();
+        let pos = (
+            b.position.x.floor() as i32,
+            b.position.y.floor() as i32,
+            b.position.z.floor() as i32,
+        );
+        crate::structure_blocks::roll_container(
+            &mut self.boats[i].items,
+            loot.as_deref(),
+            table,
+            seed,
+            pos,
+            &biome,
+        );
+        if let Some(horizon_client::containers::BlockEntity::Chest(items)) =
+            self.world.block_entities.get_mut(&key)
+        {
+            items.clone_from(&self.boats[i].items);
+        }
+    }
+
+    /// `AbstractChestBoat.remove`: destroying removals spill the live inventory.
+    pub(super) fn kill_boat(&mut self, id: u32) {
+        if let Some(i) = self.boats.iter().position(|b| b.id == id) {
+            self.release_vehicle_container(id);
+            self.unpack_boat_loot(i, false);
+            let b = self.boats.remove(i);
+            self.drop_vehicle_contents(b.position.components(), &b.items);
+            self.boat_removed(&b);
+        }
+    }
+
    /// None means a canceled hit; Some records whether an accepted hit destroyed it.
    pub(super) fn hurt_boat_result(
        &mut self,
@@ -1788,6 +1864,7 @@ impl Game<'_> {
            self.eject_boat_mobs(i, true);
            let id = self.boats[i].id;
            self.release_vehicle_container(id);
+            self.unpack_boat_loot(i, false);
            let b = self.boats.remove(i);
            // `AbstractChestBoat.remove` spills the chest through
            // `Containers.dropContents` for every destroying removal reason
@@ -202,7 +202,7 @@ impl Game<'_> {
            }
            // SuggestCommand's insertText does nothing on a book; a server's
            // text never opens a file.
-            ClickEvent::SuggestCommand(_) | ClickEvent::OpenFile(_) => {}
+            ClickEvent::SuggestCommand(_) | ClickEvent::OpenFile(_) | ClickEvent::Profiler(_) => {}
        }
    }
    /// `WritableBookItem.use` / `WrittenBookItem.use` (`Player.openItemGui`).
@@ -54,6 +54,9 @@ fn game() -> Game<'static> {
            .chunks
            .insert((x, 0), Arc::new(Chunk::empty(x, 0)));
    }
+    for x in 0..2 {
+        game.load_ticking_neighbourhood(x, 0);
+    }
    assert!(game.run_command("fill 0 99 0 31 99 15 stone"));
    game.player = Some(PlayerMotion::new(game.motion, Vec3::new(4.5, 100.0, 6.5)).unwrap());
    let net = NetConfig {
@@ -33,6 +33,18 @@ pub(super) fn chat_tree(
        None => horizon_client::command::vanilla::game_dispatcher(),
    }
 }
+/// The arguments of a typed `/profiler` the client answers itself: only when the chat tree's `profiler` is Horizon's, else the server or mod that owns the name runs it.
+fn horizon_profiler_args<'a>(
+    message: &'a str,
+    server_tree: Option<&horizon_client::command::Dispatcher>,
+) -> Option<&'a str> {
+    let args = message
+        .strip_prefix('/')
+        .and_then(super::profile_capture::profiler_args)?;
+    server_tree
+        .is_none_or(|tree| tree.has_horizon_profiler())
+        .then_some(args)
+}
 use winit::{
    event::KeyEvent,
    keyboard::{KeyCode, PhysicalKey},
@@ -155,7 +167,7 @@ impl Game<'_> {
            Some(tree) => tree,
            None => horizon_client::command::vanilla::game_dispatcher(),
        };
-        with_studio_commands(&with_native_commands(base, &names))
+        with_studio_commands(&with_native_commands(base, &names)).with_profiler()
    }
 }

@@ -1403,6 +1415,12 @@ impl Game<'_> {
            return;
        }
        self.ui.chat.add_recent(&message);
+        if let Some(args) =
+            horizon_profiler_args(&message, self.remote.as_ref().map(|r| &r.chat_tree))
+        {
+            self.profiler_chat(args);
+            return;
+        }
        // On a server (single player's own included) the server runs it,
        // unless a client mod owns the command.
        if self.remote.is_some() {
@@ -1530,6 +1548,14 @@ impl Game<'_> {
                }
            }
            Some(ClickEvent::RunCommand(command)) => self.click_command(&command),
+            Some(ClickEvent::Profiler(command)) => {
+                if let Some(args) = command
+                    .strip_prefix('/')
+                    .and_then(super::profile_capture::profiler_args)
+                {
+                    self.profiler_chat(args);
+                }
+            }
            // Screen.defaultHandleGameClickEvent: the dialog opens over the
            // screen, and closes back to it.
            Some(ClickEvent::ShowDialog(dialog)) => self.show_dialog_ref(&dialog),
@@ -2100,6 +2126,29 @@ const LINK_COPY: usize = 1;
 mod tests {
    use super::*;

+    #[test]
+    fn a_typed_profiler_is_the_clients_unless_the_server_owns_the_name() {
+        let vanilla = horizon_client::command::vanilla::game_dispatcher();
+        let ours = vanilla.with_profiler();
+        assert_eq!(
+            super::horizon_profiler_args("/profiler share", Some(&ours)),
+            Some(" share")
+        );
+        assert_eq!(super::horizon_profiler_args("/profiler", None), Some(""));
+        assert_eq!(
+            super::horizon_profiler_args("/profilers", Some(&ours)),
+            None
+        );
+        let mut server = vanilla.clone();
+        let node = server.literal(0, "profiler");
+        server.executes(node, "server:profiler");
+        let theirs = server.with_profiler();
+        assert_eq!(
+            super::horizon_profiler_args("/profiler share", Some(&theirs)),
+            None
+        );
+    }
+
    /// A mod's text reaches the chat box as typing would leave it: emoji and
    /// accents stay, control characters, DEL and the section sign go.
    #[test]
@@ -4,6 +4,7 @@ mod admin;
 pub(super) mod compute;
 mod data;
 mod display_names;
+mod target_position;
 pub(super) use data::place_summoned;
 mod effects;
 pub(super) mod execute;
@@ -310,7 +311,7 @@ impl Game<'_> {
        self.command_source = outer;
        ok
    }
-    fn syntax_failure(&mut self, e: &CommandError, command: &str) {
+    pub(in crate::game) fn syntax_failure(&mut self, e: &CommandError, command: &str) {
        self.command_failure(e.message.clone());
        let Some(input) = &e.input else { return };
        let cursor = e.cursor.min(input.len());
@@ -451,9 +452,7 @@ impl Game<'_> {
        // the server's own source, "Server".
        let who = match self.command_source.and_then(|s| s.entity) {
            Some(entity) => self.target_name(entity),
-            None if self.console_broadcast.is_some() => {
-                Text::literal(if self.rcon_source { "Rcon" } else { "Server" }.to_owned())
-            }
+            None if self.console_broadcast.is_some() => self.server_name(),
            None => self.player_display_name(),
        };
        let line = Text::translate("chat.type.admin", &[who, message])
@@ -538,118 +537,6 @@ impl Game<'_> {
        conn.and_then(|c| self.command_guest(c))
            .map_or(self.dim, |g| Dim::from_id(&g.dimension))
    }
-    pub(super) fn target_position(&self, t: Target) -> Option<[f64; 3]> {
-        match t {
-            Target::Player => self
-                .player
-                .as_ref()
-                .map(|p| [p.position.x, p.position.y, p.position.z]),
-            Target::Guest(conn) => self.command_guest(conn).map(|g| g.position),
-            Target::Mob(id) => self
-                .mobs
-                .iter()
-                .find(|m| m.id == id)
-                .map(|m| [m.position.x, m.position.y, m.position.z]),
-            Target::Item(id) => self
-                .dropped
-                .iter()
-                .find(|i| i.id == id)
-                .map(|i| [i.position.x, i.position.y, i.position.z]),
-            Target::Orb(id) => self
-                .orbs
-                .iter()
-                .find(|o| o.id == id)
-                .map(|o| [o.position.x, o.position.y, o.position.z]),
-            Target::Projectile(id) => self
-                .creatures
-                .projectiles
-                .iter()
-                .find(|a| a.id == id)
-                .map(|a| [a.position.x, a.position.y, a.position.z]),
-            Target::Stand(id) => self
-                .armor_stands
-                .iter()
-                .find(|a| a.id == id)
-                .map(|a| [a.position.x, a.position.y, a.position.z]),
-            Target::Frame(id) => self.item_frames.iter().find(|f| f.id == id).map(|f| {
-                let (lo, hi) = f.bounds();
-                [
-                    (lo[0] + hi[0]) / 2.0,
-                    (lo[1] + hi[1]) / 2.0,
-                    (lo[2] + hi[2]) / 2.0,
-                ]
-            }),
-            Target::Painting(id) => self.paintings.iter().find(|p| p.id == id).map(|p| {
-                let (lo, hi) = p.bounds();
-                [
-                    (lo[0] + hi[0]) / 2.0,
-                    (lo[1] + hi[1]) / 2.0,
-                    (lo[2] + hi[2]) / 2.0,
-                ]
-            }),
-            Target::Boat(id) => self
-                .boats
-                .iter()
-                .find(|b| b.id == id)
-                .map(|b| [b.position.x, b.position.y, b.position.z]),
-            Target::Cart(id) => self
-                .carts
-                .iter()
-                .find(|c| c.id == id)
-                .map(|c| [c.position.x, c.position.y, c.position.z]),
-            Target::Other(id) => self
-                .others
-                .iter()
-                .find(|o| o.id == id)
-                .map(|o| [o.position.x, o.position.y, o.position.z]),
-            Target::Crystal(id) => self
-                .crystals
-                .iter()
-                .find(|c| c.id == id)
-                .map(|c| [c.position.x, c.position.y, c.position.z]),
-            Target::Dragon(id) => self
-                .dragon
-                .as_ref()
-                .filter(|d| d.id == id)
-                .map(|d| [d.position.x, d.position.y, d.position.z]),
-            Target::Cushion(id) => self
-                .cushions
-                .iter()
-                .find(|c| c.id == id)
-                .map(|c| [c.position.x, c.position.y, c.position.z]),
-            Target::Tnt(id) => self
-                .tnts
-                .iter()
-                .find(|t| t.id == id)
-                .map(|t| [t.position.x, t.position.y, t.position.z]),
-            Target::Falling(id) => self
-                .falling
-                .iter()
-                .find(|f| f.id == id)
-                .map(|f| [f.position.x, f.position.y, f.position.z]),
-            Target::Rocket(id) => self
-                .rockets
-                .iter()
-                .find(|r| r.id == id)
-                .map(|r| [r.position.x, r.position.y, r.position.z]),
-            Target::Cloud(id) => self.breath_clouds.iter().find(|c| c.id == id).map(|c| c.at),
-            Target::Trident(id) => self
-                .tridents
-                .iter()
-                .find(|t| t.id == id)
-                .map(|t| [t.position.x, t.position.y, t.position.z]),
-            Target::Fangs(id) => self.fangs.list.iter().find(|f| f.id == id).map(|f| f.pos),
-            Target::Spawner(id) => self
-                .ominous_spawners
-                .iter()
-                .find(|s| s.id == id)
-                .map(|s| s.position),
-            Target::Knot(id) => self.natural_knot(id).map(|fence| {
-                let p = horizon_client::mobs::leash::knot_state(fence).position;
-                [p.x, p.y, p.z]
-            }),
-        }
-    }
    pub(super) fn target_type(&self, t: Target) -> String {
        match t {
            Target::Player | Target::Guest(_) => "minecraft:player".into(),
@@ -1851,7 +1738,7 @@ impl Game<'_> {
            }
            Target::Crystal(id) => {
                if let Some(c) = self.crystals.iter_mut().find(|c| c.id == id) {
-                    c.position = v;
+                    (c.position, c.fall.0) = (v, true); // performTeleport: setOnGround(true)
                }
            }
            Target::Dragon(id) => {
@@ -1862,6 +1749,8 @@ impl Game<'_> {
            }
            Target::Tnt(id) => {
                if let Some(t) = self.tnts.iter_mut().find(|t| t.id == id) {
+                    // `PrimedTnt.teleport` includes same-level command teleports.
+                    t.used_portal = true;
                    t.position = v;
                    t.previous = v;
                    if let Some(r) = rotation {
@@ -2487,17 +2376,7 @@ impl Game<'_> {
                self.item_frames.retain(|f| f.id != id);
            }
            Target::Painting(id) => self.paintings.retain(|p| p.id != id),
-            Target::Boat(id) => {
-                // AbstractBoat.remove: a killed boat drops its lead.
-                if let Some(i) = self.boats.iter().position(|b| b.id == id) {
-                    self.release_vehicle_container(id);
-                    let b = self.boats.remove(i);
-                    // AbstractChestBoat.remove, after the live menu writes
-                    // back its slots.
-                    self.drop_vehicle_contents(b.position.components(), &b.items);
-                    self.boat_removed(&b);
-                }
-            }
+            Target::Boat(id) => self.kill_boat(id),
            Target::Cart(id) => {
                self.release_vehicle_container(id);
                if let Some(i) = self.carts.iter().position(|c| c.id == id) {
@@ -2645,14 +2524,9 @@ impl Game<'_> {
                    self.next_entity += 1;
                    let at = Vec3::new(pos[0], pos[1], pos[2]);
                    let drawn = self.world.random.next_int_bound(100_000).unwrap_or(0);
-                    self.crystals.push(super::dragon::Crystal {
-                        id: self.next_entity,
-                        position: at,
-                        show_bottom: true,
-                        time: super::dragon::Crystal::start_time(at, drawn, self.clock.still()),
-                        beam: None,
-                        invulnerable: false,
-                    });
+                    let time = super::dragon::Crystal::start_time(at, drawn, self.clock.still());
+                    let crystal = super::dragon::Crystal::new(self.next_entity, at, true, time);
+                    self.crystals.push(crystal);
                    // tryAddFreshEntityWithPassengers refused: ERROR_DUPLICATE_UUID.
                    if !self.native_joins_flush(false, self.next_entity) {
                        return Err(err("commands.summon.failed.uuid", &[]));
@@ -4422,7 +4296,7 @@ impl Game<'_> {
                                .map(|cart| cart.command.name())
                        })
                    })
-                    .unwrap_or_else(|| Text::literal("Server")),
+                    .unwrap_or_else(|| self.server_name()),
            },
            None => self.player_display_name(),
        };
@@ -697,6 +697,27 @@ impl Game<'_> {
                self.carts[i] = cart;
                set_key(&mut tag, "UUID", Tag::IntArray(uuid.to_vec()));
            }
+            Target::Painting(id) => {
+                // Painting.readAdditionalSaveData over HangingEntity's: the
+                // facing, the block it hangs on and a known variant
+                // (`VariantUtils.readVariant(..).ifPresent`: an unknown or
+                // unreadable one keeps the painting's).
+                let uuid = self.uuid_for(id);
+                let (pos, facing) =
+                    entity_nbt::painting_placement_from_nbt(&tag).ok_or_else(stale)?;
+                let known = entity_nbt::painting_from_nbt(&tag)
+                    .and_then(|(_, _, v)| self.painting_variants.get(&v?).cloned());
+                let p = self
+                    .paintings
+                    .iter_mut()
+                    .find(|p| p.id == id)
+                    .ok_or_else(stale)?;
+                (p.pos, p.facing) = (pos, facing);
+                if let Some(v) = known {
+                    (p.variant, p.width, p.height) = (v.id, v.width, v.height);
+                }
+                set_key(&mut tag, "UUID", Tag::IntArray(uuid.to_vec()));
+            }
            Target::Other(id) => {
                let uuid = self.uuid_for(id);
                let marker = self
@@ -748,6 +769,7 @@ impl Game<'_> {
        | Target::Item(id)
        | Target::Stand(id)
        | Target::Frame(id)
+        | Target::Painting(id)
        | Target::Boat(id)
        | Target::Cart(id)
        | Target::Tnt(id)
@@ -1545,7 +1567,7 @@ impl Game<'_> {
        let before = self.next_entity;
        let mut tag = tag;
        crate::game::persist::mark_fresh(&mut tag);
-        self.world.loaded_entities.push((key, vec![tag]));
+        self.world.queue_entity_nbt(key, vec![tag]);
        self.spawn_loaded_entities();
        waiting.append(&mut self.world.loaded_entities);
        self.world.loaded_entities = waiting;
@@ -61,6 +61,12 @@ impl Game<'_> {
            .unwrap_or(Target::Player)
    }

+    /// The name of the server's own source: "Rcon" for a command an RCON client sent
+    /// (`RconConsoleSource`), "Server" otherwise (`MinecraftServer.createCommandSourceStack`).
+    pub(in crate::game) fn server_name(&self) -> Text {
+        Text::literal(if self.rcon_source { "Rcon" } else { "Server" })
+    }
+
    /// `PlayerList.getPlayerByName`: names are not case sensitive. Horizon:
    /// on a server where a mod gave players nicknames
    /// (`native_set_nickname`), a name no player has finds the player going
@@ -0,0 +1,116 @@
+use super::{Game, Target};
+
+impl Game<'_> {
+    pub(in crate::game) fn target_position(&self, t: Target) -> Option<[f64; 3]> {
+        match t {
+            Target::Player => self
+                .player
+                .as_ref()
+                .map(|p| [p.position.x, p.position.y, p.position.z]),
+            Target::Guest(conn) => self.command_guest(conn).map(|g| g.position),
+            Target::Mob(id) => self
+                .mobs
+                .iter()
+                .find(|m| m.id == id)
+                .map(|m| [m.position.x, m.position.y, m.position.z]),
+            Target::Item(id) => self
+                .dropped
+                .iter()
+                .find(|i| i.id == id)
+                .map(|i| [i.position.x, i.position.y, i.position.z]),
+            Target::Orb(id) => self
+                .orbs
+                .iter()
+                .find(|o| o.id == id)
+                .map(|o| [o.position.x, o.position.y, o.position.z]),
+            Target::Projectile(id) => self
+                .creatures
+                .projectiles
+                .iter()
+                .find(|a| a.id == id)
+                .map(|a| [a.position.x, a.position.y, a.position.z]),
+            Target::Stand(id) => self
+                .armor_stands
+                .iter()
+                .find(|a| a.id == id)
+                .map(|a| [a.position.x, a.position.y, a.position.z]),
+            Target::Frame(id) => self.item_frames.iter().find(|f| f.id == id).map(|f| {
+                let (lo, hi) = f.bounds();
+                [
+                    (lo[0] + hi[0]) / 2.0,
+                    (lo[1] + hi[1]) / 2.0,
+                    (lo[2] + hi[2]) / 2.0,
+                ]
+            }),
+            Target::Painting(id) => self.paintings.iter().find(|p| p.id == id).map(|p| {
+                let (lo, hi) = p.bounds();
+                [
+                    (lo[0] + hi[0]) / 2.0,
+                    (lo[1] + hi[1]) / 2.0,
+                    (lo[2] + hi[2]) / 2.0,
+                ]
+            }),
+            Target::Boat(id) => self
+                .boats
+                .iter()
+                .find(|b| b.id == id)
+                .map(|b| [b.position.x, b.position.y, b.position.z]),
+            Target::Cart(id) => self
+                .carts
+                .iter()
+                .find(|c| c.id == id)
+                .map(|c| [c.position.x, c.position.y, c.position.z]),
+            Target::Other(id) => self
+                .others
+                .iter()
+                .find(|o| o.id == id)
+                .map(|o| [o.position.x, o.position.y, o.position.z]),
+            Target::Crystal(id) => self
+                .crystals
+                .iter()
+                .find(|c| c.id == id)
+                .map(|c| [c.position.x, c.position.y, c.position.z]),
+            Target::Dragon(id) => self
+                .dragon
+                .as_ref()
+                .filter(|d| d.id == id)
+                .map(|d| [d.position.x, d.position.y, d.position.z]),
+            Target::Cushion(id) => self
+                .cushions
+                .iter()
+                .find(|c| c.id == id)
+                .map(|c| [c.position.x, c.position.y, c.position.z]),
+            Target::Tnt(id) => self
+                .tnts
+                .iter()
+                .find(|t| t.id == id)
+                .map(|t| [t.position.x, t.position.y, t.position.z]),
+            Target::Falling(id) => self
+                .falling
+                .iter()
+                .find(|f| f.id == id)
+                .map(|f| [f.position.x, f.position.y, f.position.z]),
+            Target::Rocket(id) => self
+                .rockets
+                .iter()
+                .find(|r| r.id == id)
+                .map(|r| [r.position.x, r.position.y, r.position.z]),
+            Target::Cloud(id) => self.breath_clouds.iter().find(|c| c.id == id).map(|c| c.at),
+            Target::Trident(id) => self
+                .tridents
+                .iter()
+                .find(|t| t.id == id)
+                .map(|t| [t.position.x, t.position.y, t.position.z]),
+            Target::Fangs(id) => self.fangs.list.iter().find(|f| f.id == id).map(|f| f.pos),
+            Target::Spawner(id) => self
+                .ominous_spawners
+                .iter()
+                .find(|s| s.id == id)
+                .map(|s| s.position),
+            Target::Knot(id) => self.natural_knot(id).map(|fence| {
+                let p = horizon_client::mobs::leash::knot_state(fence).position;
+                [p.x, p.y, p.z]
+            }),
+        }
+    }
+}
@@ -1,6 +1,7 @@
 //! Commands from the control socket (`horizon-ctl`), run on the game thread.
 use super::event_loop::EventLoopCtl;
 use super::{Game, Screen};
+use horizon_client::gfx::pack_timing;
 use horizon_client::held::Source;
 use horizon_client::{Result, items::ItemStack};
 use horizon_core::geometry::Vec3;
@@ -59,8 +60,9 @@ const HELP: &[&str] = &[
    "chat-log [N]                   the newest N chat messages (default 10)",
    "options [PAGE]                 open the options (video sound controls keybinds mouse chat accessibility language font packs mods graphics graphics-advanced graphics-hdr video-vanilla)",
    "stats [reset] [raw]            frame-time summary since the last reset (raw: every frame time too)",
+    "profile [client|server] start|stop|status|mark NAME  capture the performance of the window and, in single player, its server thread to reports/ (horizon-ctl profile --help)",
    "narration                      the narrator's status and the last messages it was asked to say",
-    "bench SECONDS                  reset stats, wait, then reply with the summary",
+    "bench SECONDS [raw]            reset stats, wait, then reply with the summary (raw: every frame time too)",
    "fly X1 Y1 Z1 X2 Y2 Z2 SECONDS [PITCH [raw]]  fly the camera along a line at constant speed, then reply with the frame summary (raw: every frame time too)",
    "open WORLD [SEED] [creative]   open or create a world from the title screen",
    "save                           save the world",
@@ -125,9 +127,7 @@ impl Game<'_> {
            summary["tick_ms"] = (flight.tick_ms.iter().sum::<f32>() / n).into();
            summary["tick_ms_max"] = flight.tick_ms.iter().copied().fold(0.0, f32::max).into();
            if flight.raw {
-                summary["frame_ms"] = self.frame_stats.frame_millis().into();
-                summary["cpu_ms"] = self.frame_stats.cpu_millis().into();
-                summary["gpu_ms"] = self.frame_stats.gpu_millis().into();
+                self.add_raw_series(&mut summary);
            }
            let _ = flight.reply.send(summary.to_string());
        }
@@ -167,6 +167,14 @@ impl Game<'_> {
                    .collect(),
            );
        }
+        if let Some(r) = self.renderer.as_ref().filter(|r| r.pass_detail())
+            && let Some(support) = r.pass_detail_support()
+            && let Value::Object(detail) =
+                pack_timing::detail_json(&r.own_pass_parts(), &r.own_pass_counters(), support)
+            && let Some(summary) = summary.as_object_mut()
+        {
+            summary.extend(detail);
+        }
        self.add_async_occlusion_stats(&mut summary);
        summary
    }
@@ -177,6 +185,23 @@ impl Game<'_> {
        }
    }

+    /// Adds the allocations since the last rendered frame to the frame stats; the first frame has no mark.
+    pub(super) fn record_frame_allocs(&mut self) {
+        use horizon_threads::alloc_count::{here, process};
+        let now = (here(), process());
+        if let Some((window, all)) = self.alloc_mark.replace(now) {
+            self.frame_stats
+                .record_allocs(now.0.since(window), now.1.since(all), Instant::now());
+        }
+    }
+    /// Every frame's times, and its allocations in builds that count (`raw`).
+    fn add_raw_series(&self, summary: &mut Value) {
+        self.frame_stats.add_series(summary);
+        if horizon_threads::alloc_count::ON {
+            summary["alloc_count"] = self.frame_stats.alloc_counts().into();
+            summary["alloc_bytes"] = self.frame_stats.alloc_bytes().into();
+        }
+    }
    fn reset_frame_stats(&mut self) {
        self.frame_stats.reset();
        if let Some(culler) = &self.async_occlusion_culler {
@@ -184,16 +209,21 @@ impl Game<'_> {
        }
    }
    pub(super) fn poll_control(&mut self, event_loop: &dyn EventLoopCtl) {
-        if let Some((deadline, reply)) = self.pending_bench.take() {
+        if let Some((deadline, reply, raw)) = self.pending_bench.take() {
            if Instant::now() >= deadline {
-                let _ = reply.send(self.summary_with_passes().to_string());
+                let mut summary = self.summary_with_passes();
+                if raw {
+                    self.add_raw_series(&mut summary);
+                }
+                let _ = reply.send(summary.to_string());
            } else {
-                self.pending_bench = Some((deadline, reply));
+                self.pending_bench = Some((deadline, reply, raw));
            }
        }
        horizon_client::widgets::end_frame(self.frames);
        self.narrate_screen();
        self.poll_repro(event_loop);
+        self.poll_profile();
        self.advance_agent();
        for request in self.ui_wait.ready() {
            self.answer(request, event_loop);
@@ -391,12 +421,21 @@ impl Game<'_> {
        if let Some(value) = self.repro_command(&words, line, reply)? {
            return Ok(value);
        }
+        if words[0] == "profile" {
+            return self.profile_command(&words[1..], reply);
+        }
+        if words[0] == "trace" {
+            return self.trace_command(&words[1..], reply);
+        }
        if let Some(value) = self.saves_control(&words, line, reply)? {
            return Ok(value);
        }
        if let Some(value) = self.options_control(&words, line)? {
            return Ok(Some(value));
        }
+        if let Some(value) = self.lan_op_control(&words)? {
+            return Ok(Some(value));
+        }
        if let Some(value) = self.lan_control(&words)? {
            return Ok(Some(value));
        }
@@ -461,35 +500,17 @@ impl Game<'_> {
                Ok(Some(json!({ "ok": true, "cull": r.section_cull() })))
            }
            "gpu-passes" => {
-                match words.get(1).copied() {
-                    None => {}
-                    Some("on") => self.gpu_passes = true,
-                    Some("off") => self.gpu_passes = false,
-                    Some(other) => return Err(format!("unknown gpu pass mode {other}").into()),
-                }
-                Ok(Some(json!({ "ok": true, "gpu_passes": self.gpu_passes })))
+                (self.gpu_passes, self.gpu_pass_detail) = gpu_pass_switches(
+                    words.get(1).copied(),
+                    (self.gpu_passes, self.gpu_pass_detail),
+                )?;
+                let support = self.renderer.as_ref().and_then(|r| r.pass_detail_support());
+                Ok(Some(gpu_passes_reply(
+                    self.gpu_passes,
+                    self.gpu_pass_detail,
+                    support,
+                )))
            }
-            // Every thread's spans as a timeline Perfetto opens (`spans::trace`).
-            "trace" => match words.get(1).copied() {
-                None => Ok(Some(
-                    json!({ "ok": true, "tracing": horizon_client::spans::trace::on() }),
-                )),
-                Some("stop") => Ok(Some(
-                    json!({ "ok": true, "events": horizon_client::spans::trace::stop() }),
-                )),
-                Some(file) => {
-                    let seconds = match words.get(2) {
-                        None => None,
-                        Some(s) => Some(
-                            s.parse::<u32>()
-                                .map_err(|_| "trace [FILE [SECONDS] | stop]")?,
-                        ),
-                    };
-                    horizon_client::spans::trace::start(std::path::Path::new(file), seconds)
-                        .map_err(|e| format!("trace {file}: {e}"))?;
-                    Ok(Some(json!({ "ok": true, "tracing": true, "file": file })))
-                }
-            },
            "render-capture" => match words.get(1).copied() {
                None => {
                    let r = self.renderer.as_ref().ok_or("no renderer")?;
@@ -579,7 +600,7 @@ impl Game<'_> {
            "sculk" => Ok(Some(self.sculk_command(&words)?)),
            "hello" => Ok(Some(hello())),
            "status" => Ok(Some(self.control_status())),
-            "memory" => Ok(Some(self.memory_report())),
+            "memory" => Ok(Some(self.memory_value())),
            "stall" => {
                let millis: u64 = arg(1)?.parse()?;
                if millis > 5000 {
@@ -1188,9 +1209,7 @@ impl Game<'_> {
            "stats" => {
                let mut summary = self.summary_with_passes();
                if words[1..].contains(&"raw") {
-                    summary["frame_ms"] = self.frame_stats.frame_millis().into();
-                    summary["cpu_ms"] = self.frame_stats.cpu_millis().into();
-                    summary["gpu_ms"] = self.frame_stats.gpu_millis().into();
+                    self.add_raw_series(&mut summary);
                }
                if words[1..].contains(&"reset") {
                    self.reset_frame_stats();
@@ -1210,6 +1229,7 @@ impl Game<'_> {
                self.pending_bench = Some((
                    Instant::now() + Duration::from_secs_f64(seconds),
                    reply.clone(),
+                    words[2..].contains(&"raw"),
                ));
                Ok(None)
            }
@@ -1773,6 +1793,35 @@ fn key_code(name: &str) -> Option<KeyCode> {
    })
 }

+/// The (times, detail) switches `gpu-passes [on|off|detail]` leaves, given the current ones.
+fn gpu_pass_switches(word: Option<&str>, now: (bool, bool)) -> Result<(bool, bool)> {
+    match word {
+        None => Ok(now),
+        Some("on") => Ok((true, false)),
+        Some("detail") => Ok((true, true)),
+        Some("off") => Ok((false, false)),
+        Some(other) => Err(format!("unknown gpu pass mode {other}").into()),
+    }
+}
+
+/// The `gpu-passes` reply: the switches and what detail can show on this device.
+fn gpu_passes_reply(
+    passes: bool,
+    detail: bool,
+    support: Option<pack_timing::DetailSupport>,
+) -> Value {
+    let shown = support.map(pack_timing::support_json);
+    let field = |key: &str, none: Value| shown.as_ref().map_or(none, |s| s[key].clone());
+    json!({
+        "ok": true,
+        "gpu_passes": passes,
+        "detail": detail,
+        "parts_mode": field("parts_mode", Value::Null),
+        "counters": field("counters", json!(false)),
+        "fragment_unit": field("fragment_unit", Value::Null),
+    })
+}
+
 /// The title's own screens (not one opened over it, as Options is) take the
 /// text: the world name, the seed, a server's address.
 pub(super) fn title_owns_text(screen: &Screen, title_up: bool) -> bool {
@@ -1810,6 +1859,39 @@ mod tests {
        assert_eq!(names.len(), features.len(), "a group is named twice");
    }

+    #[test]
+    fn gpu_passes_detail_replies_detail_and_on_turns_it_off_again() {
+        let support = pack_timing::DetailSupport {
+            parts: pack_timing::PartsMode::SeparatePasses,
+            encoder_stamps: false,
+            counters: true,
+            fragment_unit: Some(pack_timing::FragmentUnit::Quad),
+        };
+        let (passes, detail) = gpu_pass_switches(Some("detail"), (false, false)).unwrap();
+        let reply = gpu_passes_reply(passes, detail, Some(support));
+        assert_eq!(reply["detail"], true);
+        assert_eq!(reply["gpu_passes"], true);
+        assert_eq!(reply["parts_mode"], "separate_passes");
+        assert_eq!(reply["counters"], true);
+        assert_eq!(reply["fragment_unit"], "quad");
+        let (passes, detail) = gpu_pass_switches(Some("on"), (passes, detail)).unwrap();
+        let reply = gpu_passes_reply(passes, detail, None);
+        assert_eq!(
+            (reply["gpu_passes"].as_bool(), reply["detail"].as_bool()),
+            (Some(true), Some(false))
+        );
+        assert_eq!(
+            (reply["parts_mode"].is_null(), reply["counters"].as_bool()),
+            (true, Some(false))
+        );
+        assert_eq!(
+            gpu_pass_switches(Some("off"), (true, true)).unwrap(),
+            (false, false)
+        );
+        assert_eq!(gpu_pass_switches(None, (true, true)).unwrap(), (true, true));
+        assert!(gpu_pass_switches(Some("nope"), (false, false)).is_err());
+    }
+
    #[test]
    fn taps_and_ups_always_release_their_key() {
        for line in ["key shift tap", "key shift up", "key  Shift  up"] {
@@ -1825,4 +1907,50 @@ mod tests {
            assert_eq!(released_modifier(line), None, "{line}");
        }
    }
+
+    #[test]
+    fn a_benchmark_profile_only_goes_with_a_benchmark() {
+        let parse = |args: &[&str]| {
+            super::super::Options::parse(args.iter().map(|a| a.to_string())).map(|o| o.unwrap())
+        };
+        assert!(
+            parse(&["--benchmark", "village", "--profile"])
+                .unwrap()
+                .benchmark_profile
+        );
+        assert!(
+            !parse(&["--benchmark", "village"])
+                .unwrap()
+                .benchmark_profile
+        );
+        assert!(parse(&["--profile"]).is_err());
+    }
+
+    #[test]
+    fn a_benchmark_set_only_goes_with_the_trip() {
+        let parse = |args: &[&str]| {
+            super::super::Options::parse(args.iter().map(|a| a.to_string())).map(|o| o.unwrap())
+        };
+        let set = parse(&["--benchmark", "travel", "--benchmark-set", "gpu-culling=on"]).unwrap();
+        assert_eq!(set.benchmark_set, Some(("gpu-culling".into(), "on".into())));
+        let before = parse(&["--benchmark-set", "gpu-culling=on", "--benchmark", "travel"]);
+        assert!(before.is_ok());
+        for args in [
+            &[
+                "--benchmark",
+                "standard",
+                "--benchmark-set",
+                "gpu-culling=on",
+            ][..],
+            &["--benchmark-set", "gpu-culling=on"],
+            &[
+                "--benchmark",
+                "travel",
+                "--benchmark-set",
+                "gpu-culling=auto",
+            ],
+        ] {
+            assert!(parse(args).is_err(), "{args:?}");
+        }
+    }
 }
@@ -1080,7 +1080,7 @@ impl Game<'_> {
            max_entity_cramming: self.ui.rules.int("max_entity_cramming"),
            dimension_type: self.dimension_type(),
            world_seed: self.level.seed,
-            sea_level: if self.dim == Dim::Nether { 32 } else { 63 },
+            sea_level: horizon_world::level::sea_level_of(self.level_key()),
            teams: std::sync::Arc::new(self.mob_teams()),
            items: Some(self.items()),
            lid_openers: &self.lid_openers,
@@ -1280,10 +1280,9 @@ impl Game<'_> {
                    .is_some()
                    .then_some(self.level.player_uuid)
                    .flatten(),
-                mods: round.listening() || !horizon_client::mod_api::mods().is_empty(),
                ticking: &|| Box::new(self.entity_ticking_area()),
            };
-            let mut group = match islands.plan(&mobs, &snapshot, &turns) {
+            let mut group = match islands.plan(&mobs, &snapshot, &turns, &start) {
                Some(plan) => islands.run(plan, mobs.into(), snapshot, start, &mut turns, &shared),
                None => {
                    let mut group = mob_group::Group::new(mobs.into(), snapshot, start);
@@ -1878,10 +1877,9 @@ impl Game<'_> {
        for item in stacks {
            // Every death drop is its own ItemEntity, and the drop entity's
            // own random (not the level's) gives it the constructor's
-            // horizontal push (its motion otherwise stays [0, 0.2, 0] and
-            // the drops land stacked at the mob's centre, without disturbing
-            // the level random that the orbs' merge ids and block ticks read
-            // next).
+            // horizontal push (its motion otherwise stays [0, 0.2, 0] and the
+            // drops land stacked at the mob's centre, without disturbing the
+            // level random that the orbs' merge ids and block ticks read next).
            self.spawn_item_own(item, pos, 10);
        }
        // LivingEntity.dropExperience: a mod may change the mob's experience
@@ -1921,8 +1919,9 @@ impl Game<'_> {
                        self.spawn_item_own(item, pos, 10);
                    }
                }
+                drops::Drop::Aged(s, age) => self.spawn_item_aged(from_loot(&s), pos, age),
                drops::Drop::Orb(value) if !consumed => self.spawn_orbs(pos, value as u32),
-                drops::Drop::Item(_) | drops::Drop::Stack(_) | drops::Drop::Orb(_) => {}
+                _ => {}
            }
        }
    }
@@ -3234,11 +3233,7 @@ impl Game<'_> {
                MobEvent::DolphinTreasure { mob } => {
                    // ServerLevel.findNearestMapStructure(#dolphin_located, 50).
                    let Some(at) = self.mobs.iter().find(|m| m.id == mob).map(|m| {
-                        [
-                            m.position.x.floor() as i32,
-                            m.position.y.floor() as i32,
-                            m.position.z.floor() as i32,
-                        ]
+                        [m.position.x, m.position.y, m.position.z].map(|v| v.floor() as i32)
                    }) else {
                        continue;
                    };
@@ -3249,7 +3244,11 @@ impl Game<'_> {
                        .filter(|_| !names.is_empty())
                        .and_then(|t| t.locate(&names, at, 50));
                    if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) {
-                        m.extra.home = found.map(|(_, p)| p);
+                        m.extra.home = found.as_ref().map(|(_, p)| *p);
+                    }
+                    // DolphinSwimToTreasureGoal.start: entity event 38 once it has a treasure.
+                    if found.is_some() {
+                        self.mob_event_particles(mob, 38);
                    }
                }
                MobEvent::EffectPlayer {
@@ -9051,6 +9050,7 @@ mod h169_glide_travel_tests {
                    .unwrap();
            }
        }
+        game.load_ticking_neighbourhood(0, 0);
        game.player = Some(PlayerMotion::new(game.motion, Vec3::new(2.5, 200.0, 2.5)).unwrap());
        game.creative = true;
        assert!(game.run_command("fill 0 199 0 31 199 31 stone"));
@@ -64,6 +64,9 @@ pub(super) struct Group<M: MobSlot> {
    pub corpses: Vec<Mob>,
    pub gone: Vec<Gone>,
    pub guest_events: Vec<(u32, u32, MobEvent)>,
+    /// The mod hooks its turns kept for the join, with each turn's place in the whole list (a
+    /// group of the parallel tick with mods loaded: `native_client_hooks::Deferred`).
+    pub deferred: Vec<(usize, horizon_client::native_client_hooks::Deferred)>,
 }

 /// What decides each turn besides the group, read at the turn as the serial loop reads it.
@@ -77,7 +80,7 @@ pub(super) struct Turns<'t, 'w> {
    /// The one player's position, when the level has one: every mob's nearest.
    pub single_player: Option<Option<Vec3>>,
    /// Whether a mod canceled a mob's tick.
-    pub canceled: &'t dyn Fn(u32) -> bool,
+    pub canceled: &'t (dyn Fn(u32) -> bool + Sync),
    /// `getCurrentDifficultyAt` a position.
    pub difficulty: &'t (dyn Fn([f64; 3]) -> LocalDifficulty + Sync),
    /// The last chunk's difficulty: mobs come in runs of one chunk.
@@ -137,6 +140,7 @@ impl<M: MobSlot> Group<M> {
            corpses: Vec::new(),
            gone: Vec::new(),
            guest_events: Vec::new(),
+            deferred: Vec::new(),
        }
    }

@@ -173,7 +177,17 @@ impl<M: MobSlot> Group<M> {
                foreign.reader.set(at);
            }
            if let Some(foreign) = foreign {
-                foreign.in_seed_order(at, || self.turn(i, turns, shared));
+                foreign.in_seed_order(at, || {
+                    if foreign.defers {
+                        let ((), kept) =
+                            horizon_client::native_client_hooks::deferring_turn(|| {
+                                self.turn(i, turns, shared);
+                            });
+                        self.deferred.extend(kept.into_iter().map(|d| (at, d)));
+                    } else {
+                        self.turn(i, turns, shared);
+                    }
+                });
            } else {
                self.turn(i, turns, shared);
            }
@@ -333,9 +347,7 @@ impl<M: MobSlot> Group<M> {
        };
        w.controlling_player_movement = controlling_player_movement;
        self.ticked.insert(self.mobs[i].mob().id);
-        // `horizon-report`'s cost by mob type (tick_profile.rs).
-        let sampled =
-            super::super::tick_profile::start().map(|t| (t, self.mobs[i].mob().kind.clone()));
+        let sampled = super::super::tick_profile::start_mob(&self.mobs[i].mob().kind);
        let kept = horizon_client::mobs::riders::tick(
            &mut self.mobs,
            i,
@@ -343,9 +355,7 @@ impl<M: MobSlot> Group<M> {
            &mut self.random,
            &mut self.events,
        );
-        if let Some((started, kind)) = sampled {
-            super::super::tick_profile::add(shared.level_id, &kind, started);
-        }
+        super::super::tick_profile::end_mob(shared.level_id, sampled);
        let m = self.mobs[i].mob_mut();
        if seen_guest.is_none() {
            self.player = w.player;
@@ -367,7 +377,10 @@ impl<M: MobSlot> Group<M> {
                shared.guest_ids,
                self.player.as_ref(),
            );
-            if let Some((player, mob)) = named {
+            // A grouped turn runs while no mod hooks the change (`horizon_mod_api_gen::mob_turn`).
+            if let Some((player, mob)) = named
+                && !horizon_client::native_client_hooks::deferring()
+            {
                let kind = super::super::native_hooks::mob_kind(m);
                let mut cancel = false;
                Game::native_living_change_target(
@@ -5,9 +5,14 @@ use super::super::{
 };
 use horizon_client::{mobs::Species, scoreboard::teams_allow_damage};
 use horizon_core::geometry::Vec3;
+use horizon_protocol::packets::play::{Clientbound, GameEvent};
+
+/// `ClientboundGameEventPacket.PUFFER_FISH_STING`.
+const PUFFER_FISH_STING: u8 = 9;

 impl Game<'_> {
-    /// `Pufferfish.playerTouch`: accepted player damage, then poison with this fish as source.
+    /// `Pufferfish.playerTouch`: accepted player damage, the sting game event, then poison with
+    /// this fish as source.
    pub(in crate::game) fn touch_pufferfish(&mut self) {
        if self.remote.is_some() || self.spectator() {
            return;
@@ -46,10 +51,11 @@ impl Game<'_> {
                    m.extra.size,
                    [m.position.x, m.position.y, m.position.z],
                    self.mob_entity(m),
+                    m.silent,
                )
            })
            .collect();
-        for (id, puff, at, source) in touching {
+        for (id, puff, at, source, silent) in touching {
            if !self.hurt_player_from(
                (1 + puff) as f32,
                Some(at),
@@ -58,6 +64,10 @@ impl Game<'_> {
            ) {
                continue;
            }
+            // `if (!this.isSilent())` inside the `hurtServer` branch: before the poison.
+            if !silent {
+                self.puffer_fish_sting();
+            }
            let changes = self.potions.effects.changes;
            self.give_player_effect("minecraft:poison", 60 * puff, 0);
            if self.potions.effects.changes != changes {
@@ -65,4 +75,17 @@ impl Game<'_> {
            }
        }
    }
+    /// `ServerPlayer.connection.send(ClientboundGameEventPacket(PUFFER_FISH_STING, 0.0F))`: the
+    /// stung player's own client plays it (`ClientPacketListener.handleGameEvent`). A server has
+    /// no player of its own, so the packet is the only way to reach it.
+    fn puffer_fish_sting(&mut self) {
+        self.guest_packets.push(Clientbound::GameEvent(GameEvent {
+            event: PUFFER_FISH_STING,
+            param: 0.0,
+        }));
+    }
 }
+
+#[cfg(test)]
+#[path = "pufferfish_sting_tests.rs"]
+mod pufferfish_sting_tests;
@@ -0,0 +1,95 @@
+//! `Pufferfish.playerTouch`: the sting game event (`ClientboundGameEventPacket.PUFFER_FISH_STING`)
+//! goes out only inside the `hurtServer` branch, and only when the fish is not
+//! silent; the poison follows it.
+use crate::game::{Audio, Game, Options, Progress, Settings, execution_role, load_resources};
+use horizon_client::mobs::Mob;
+use horizon_client::motion::PlayerMotion;
+use horizon_core::geometry::Vec3;
+use horizon_protocol::packets::play::Clientbound;
+
+/// A game whose window player touches one puffed (state 2) pufferfish. The
+/// server acts for the guest `lan_acting`: `playerTouch` runs there, and the
+/// event it sends reaches that player's own client.
+fn game_with(silent: bool) -> Game<'static> {
+    let root = std::path::PathBuf::from(
+        std::env::var_os("HORIZON_TEST_RESOURCES")
+            .expect("set HORIZON_TEST_RESOURCES to prepared resources"),
+    );
+    let settings = Settings::default();
+    let loaded = load_resources(
+        root.clone(),
+        None,
+        &root,
+        &settings,
+        std::time::Instant::now(),
+        false,
+        false,
+        &Progress::new(),
+        &mut |_, _| unreachable!(),
+    )
+    .unwrap();
+    let mut options = Options::parse(std::iter::empty()).unwrap().unwrap();
+    options.resources = root.clone();
+    options.execution_role = execution_role::ExecutionRole::IntegratedServer;
+    let res: &'static _ = Box::leak(Box::new(loaded.resources));
+    let mut game = Game::new(
+        res,
+        loaded.pack,
+        loaded.gui.unwrap(),
+        options,
+        settings,
+        Audio::silent(&root),
+        None,
+    )
+    .unwrap();
+    game.creative = false;
+    game.lan_acting = Some(7);
+    game.player = Some(PlayerMotion::new(game.motion, Vec3::new(8.5, 66.0, 8.5)).unwrap());
+    let kind = game.res.mob_types()["minecraft:pufferfish"].clone();
+    let mut fish = Mob::new(9001, kind, Vec3::new(8.5, 66.0, 8.5), 0.0);
+    fish.extra.size = 2;
+    fish.silent = silent;
+    game.mobs.push(fish);
+    game
+}
+
+/// The game events the stung player's client was sent, as `(event, parameter)`.
+fn stings(game: &Game<'_>) -> Vec<(u8, f32)> {
+    game.guest_packets
+        .iter()
+        .filter_map(|packet| match packet {
+            Clientbound::GameEvent(e) => Some((e.event, e.param)),
+            _ => None,
+        })
+        .collect()
+}
+
+fn health(game: &Game<'_>) -> f32 {
+    game.player.as_ref().unwrap().health.health()
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn the_sting_event_goes_out_once_per_accepted_hit() {
+    let mut g = game_with(false);
+    g.touch_pufferfish();
+    assert_eq!(health(&g), 17.0, "1 + PuffState 2 of damage landed");
+    assert_eq!(stings(&g), vec![(9, 0.0)], "PUFFER_FISH_STING, parameter 0");
+    let poison = g.potions.effects.get("poison").expect("poisoned");
+    assert_eq!((poison.duration, poison.amplifier), (120, 0));
+    // A second touch inside the hurt cooldown is refused (`hurtServer` is
+    // false): no damage and no event.
+    g.touch_pufferfish();
+    assert_eq!(health(&g), 17.0, "the cooldown refused the second hit");
+    assert_eq!(stings(&g).len(), 1, "a refused hit sends nothing");
+}
+
+#[test]
+#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
+fn a_silent_fish_damages_and_poisons_without_the_sting() {
+    let mut g = game_with(true);
+    g.touch_pufferfish();
+    assert_eq!(health(&g), 17.0, "the damage still lands");
+    assert!(g.potions.effects.get("poison").is_some(), "the poison too");
+    assert!(stings(&g).is_empty(), "a silent fish sends no event");
+}
@@ -174,6 +174,19 @@ impl Game<'_> {
                    if self.debug && !own_lines.is_empty() {
                        d.group("Horizon passes", own_lines);
                    }
+                    let detail_lines = self.renderer.as_ref().map_or_else(Vec::new, |r| {
+                        let support = r.pass_detail_support().filter(|_| r.pass_detail());
+                        support.map_or_else(Vec::new, |support| {
+                            overlay::pass_detail_lines(
+                                &r.own_pass_parts(),
+                                &r.own_pass_counters(),
+                                support,
+                            )
+                        })
+                    });
+                    if self.debug && !detail_lines.is_empty() {
+                        d.group("Horizon pass detail", detail_lines);
+                    }
                }
                "tps" => self.debug_tps_line(d),
                // DebugEntryChunkGeneration, where the world is generated
@@ -21,6 +21,7 @@ use horizon_client::{
    },
    text::Text,
 };
+use horizon_perf_format::v1::{StopReason, Trigger};
 use horizon_protocol::text::translatable;
 use horizon_world::nbt::{JavaString, Tag};
 use std::{
@@ -37,7 +38,7 @@ use std::{
 pub(super) mod events;
 mod management;
 mod predicate_graph;
-mod report;
+pub(super) mod report;
 mod status;
 mod transfer;

@@ -307,6 +308,17 @@ fn overload_warning(behind: Duration, tick: Duration) -> String {
    )
 }

+/// `ServerGamePacketListenerImpl.tick`'s idle kick: a player whose last action is more than
+/// `minutes` (`player-idle-timeout`, none when 0 or less) behind, counted here in ticks, is kicked,
+/// unless the End poem is showing (`ServerPlayer.wonGame`): its client sends no action until it
+/// asks to respawn.
+fn idles_out(idle_ticks: u64, minutes: i32, won_game: bool) -> bool {
+    let Ok(minutes @ 1..) = u64::try_from(minutes) else {
+        return false;
+    };
+    !won_game && idle_ticks > minutes * 1200
+}
+
 /// Log4j's console pattern: `[HH:mm:ss] [thread/LEVEL]: message`.
 pub(super) fn log(level: &str, message: &str) {
    log_from("Server thread", level, message);
@@ -527,6 +539,28 @@ fn parse_whitelist_bypass(text: &str) -> std::result::Result<Vec<String>, String
    Ok(out)
 }
 impl Lists {
+    /// The console's `/ban` of one player (`BanPlayerCommands.banPlayers`): whether they are banned now.
+    /// One banned already (`isBanned`) is left as they are, their first reason kept.
+    fn ban(&mut self, user: &NameAndId, reason: Option<String>) -> bool {
+        !self.bans.contains(user)
+            && self.bans.add(BanEntry::new(
+                user.clone(),
+                Some("Server".into()),
+                None,
+                reason,
+            ))
+    }
+
+    /// The console's `/ban-ip` (`BanIpCommands.banIp`): whether the address is banned now. One banned
+    /// already (`isBanned`) is left as it is.
+    fn ban_ip(&mut self, ip: &str, reason: Option<String>) -> bool {
+        let ip = ip.to_owned();
+        !self.ip_bans.contains(&ip)
+            && self
+                .ip_bans
+                .add(BanEntry::new(ip, Some("Server".into()), None, reason))
+    }
+
    fn load() -> Self {
        let mut l = Self {
            ops: OpList::new("ops.json"),
@@ -658,9 +692,7 @@ const LEGACY_PRESET_NAMES: [(&str, horizon_client::save::WorldPreset); 2] = [

 /// server.properties' line for `server.toml`'s `max_view_distance` (horizon-server writes it).
 const FAR_PROPERTY: &str = "horizon-max-view-distance";
-/// A dedicated server logs a tick slower than this, in milliseconds, with
-/// its spans, unless `HORIZON_SPIKES` names another threshold: five ticks'
-/// worth, a stall players feel as rubber-banding.
+/// A tick slower than this, in milliseconds, enters the slow ring (five ticks' worth, a stall players feel) unless `HORIZON_SPIKES` names another.
 pub(super) const SLOW_TICK_MS: f32 = 250.0;
 /// `MinecraftServer.OVERLOADED_WARNING_INTERVAL_NANOS` plus 100 ticks: the
 /// "Can't keep up!" warning comes at most this often.
@@ -806,9 +838,19 @@ struct ServerState {
    op_level: i32,
    /// `horizon-report`: the ticks being recorded.
    report: Option<report::Recording>,
+    /// When the running capture takes its next memory snapshot, and how many it has taken.
+    memory_due: Option<(f64, u32)>,
+    /// The always-on health history and slow ring, and the `.hzperf` a report writes from them.
+    perf: horizon_client::server_perf::ServerPerf,
+    /// The perf clock's zero: the tick loop's start.
+    perf_epoch: Instant,
+    /// The Horizon switches a capture records.
+    horizon: horizon_perf_format::v1::HorizonOptions,
    /// View and simulation distance, and the player limit, for the report.
    view: (u32, u32),
    max_players: usize,
+    /// `network-compression-threshold`, for the capture's settings.
+    compression: i32,
    /// The mutable `gamemode` server property (`DedicatedServer.gameMode`).
    game_mode: i32,
    /// The mutable `force-gamemode` server property (`DedicatedServer.forceGameMode`).
@@ -855,6 +897,28 @@ fn auto_save(state: &ServerState) -> bool {
    state.lists.lock().unwrap().autosave
 }

+/// `MinecraftServer.tickServer`'s pause-when-empty count. `pause_after` is its
+/// `pauseWhenEmptySeconds() * 20`; while that is above 0, a tick with no player and no
+/// `/tick sprint` running (`ServerTickRateManager.isSprinting`) adds one to `empty_ticks`, and any
+/// other tick sets it back to 0. A `/pregen` task keeps the server busy as a player would: paused,
+/// nothing would post-process its chunks. Returns whether the server is paused this tick.
+fn count_empty_tick(
+    empty_ticks: &mut i32,
+    pause_after: i32,
+    players: usize,
+    pregen: bool,
+    sprinting: bool,
+) -> bool {
+    if pause_after > 0 {
+        if players == 0 && !pregen && !sprinting {
+            *empty_ticks += 1;
+        } else {
+            *empty_ticks = 0;
+        }
+    }
+    pause_after > 0 && *empty_ticks >= pause_after
+}
+
 /// `MinecraftServer.setAutoSave`: enable or disable periodic saves and report whether it changed.
 pub(super) fn set_auto_save(lists: &Mutex<Lists>, enabled: bool) -> bool {
    let mut l = lists.lock().unwrap();
@@ -1039,9 +1103,17 @@ impl Game<'_> {
        // now rather than at the first tick (reading parses functions; it runs none), and a broken
        // predicate graph stops the start before anything listens (a partial check: predicate_graph.rs).
        self.ensure_datapacks();
-        if let Err(error) = predicate_graph::check(&self.fns.store.predicates) {
+        let store = &self.fns.store;
+        let tag = |id: &str| {
+            let (ns, path) = id.split_once(':').unwrap_or(("minecraft", id));
+            store
+                .files
+                .contains_key(&format!("tags/{ns}:predicate/{path}"))
+        };
+        if let Err(error) = predicate_graph::check(&store.predicates, tag) {
            let level = match error {
-                predicate_graph::GraphError::Unbound(_) => "ERROR",
+                predicate_graph::GraphError::Unbound(_)
+                | predicate_graph::GraphError::UnboundTags(_) => "ERROR",
                predicate_graph::GraphError::Recursive(_) => "WARN",
            };
            for line in error.lines() {
@@ -1235,6 +1307,7 @@ impl Game<'_> {
        }
        self.sync_ops(&lists);
        let anticheat = load_anticheat();
+        let anticheat_on = anticheat.enabled;
        let chat_filter = load_chat_filter();
        self.set_pvp_legacy_rules(load_combat());
        // Horizon's far ring (docs/hosting.md): server.toml's `max_view_distance`.
@@ -1292,12 +1365,44 @@ impl Game<'_> {
            game_mode: props.game_mode,
            force_game_mode: props.force_game_mode,
            report: None,
+            memory_due: None,
+            perf: horizon_client::server_perf::ServerPerf::new(
+                0.0,
+                self.options.spikes.unwrap_or(SLOW_TICK_MS),
+            ),
+            perf_epoch: Instant::now(),
+            horizon: horizon_client::server_perf::horizon_options(
+                if self.lan.as_ref().is_some_and(|h| h.hub.far.is_some()) {
+                    far as u32
+                } else {
+                    0
+                },
+                horizon_client::lod_net::distance_property(
+                    props.raw.get(horizon_client::lod_net::PROPERTY),
+                ),
+                anticheat_on,
+            ),
+            compression: props.network_compression_threshold,
            view: (
                props.view_distance.clamp(2, 32) as u32,
                props.simulation_distance.clamp(2, 32) as u32,
            ),
            max_players: props.max_players.max(0) as usize,
        };
+        horizon_client::server_perf::warm_hardware();
+        if let Some(file) = std::env::var_os("HORIZON_TRACE").filter(|f| !f.is_empty()) {
+            self.record_report(
+                &mut state,
+                &report::Plan {
+                    seconds: report::MAX_SECONDS,
+                    samples: false,
+                    timeline: true,
+                    file: Some(file.into()),
+                    trigger: Trigger::Env,
+                    sampler: Default::default(),
+                },
+            );
+        }
        let mut next = Instant::now();
        // The panic that ended the tick loop, when one did.
        let mut crashed: Option<String> = None;
@@ -1329,16 +1434,13 @@ impl Game<'_> {
            // Vanilla reads pauseWhenEmptySeconds on every tick, so management changes take effect
            // without restarting the server.
            let pause_after = state.pause_when_empty_seconds.wrapping_mul(20);
-            if pause_after > 0 {
-                // A `/pregen` task keeps the server busy as a player would:
-                // paused, nothing would post-process its chunks.
-                if players == 0 && self.pregen_level().is_none() {
-                    state.empty_ticks += 1;
-                } else {
-                    state.empty_ticks = 0;
-                }
-            }
-            let paused = pause_after > 0 && state.empty_ticks >= pause_after;
+            let paused = count_empty_tick(
+                &mut state.empty_ticks,
+                pause_after,
+                players,
+                self.pregen_level().is_some(),
+                self.clock.sprinting(),
+            );
            state.paused = paused;
            if paused && state.empty_ticks == pause_after {
                log(
@@ -1361,22 +1463,32 @@ impl Game<'_> {
            // MinecraftServer.tickServer: while paused only the connections run.
            // `MinecraftServer.runServer` catches what the tick throws, writes the crash
            // report and still stops the server (saves). A panic here does the same.
-            let ticked =
-                std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                    match &mut state.report {
-                        Some(recording) => {
-                            let sampled = recording.sample_next();
-                            super::tick_profile::set_sampling(sampled);
-                            let ticked =
-                                self.tick_server_spans(paused, |wall, cpu, spans, recorded| {
-                                    recording.add(wall, cpu, spans, recorded, sampled)
-                                });
-                            super::tick_profile::set_sampling(false);
-                            ticked
-                        }
-                        None => self.tick_server_timed(paused),
+            let slow_ms = state.perf.slow_threshold_ms();
+            let capturing = state.perf.capturing();
+            let mut tick_detail = None;
+            let ticked = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                let mut detail = |timing: super::levels::TickTiming| {
+                    if capturing || timing.wall_ms > slow_ms {
+                        tick_detail = Some(horizon_client::server_perf::TickDetail {
+                            cpu_ms: timing.cpu_ms,
+                            spans: timing.raw,
+                        });
                    }
-                }));
+                };
+                match &mut state.report {
+                    Some(recording) => {
+                        let sampled = recording.sample_next();
+                        super::tick_profile::set_sampling(sampled);
+                        let ticked = self.tick_server_spans(paused, |timing| {
+                            recording.add(sampled);
+                            detail(timing)
+                        });
+                        super::tick_profile::set_sampling(false);
+                        ticked
+                    }
+                    None => self.tick_server_spans(paused, detail),
+                }
+            }));
            match ticked {
                Ok(result) => result?,
                Err(payload) => {
@@ -1384,19 +1496,12 @@ impl Game<'_> {
                    break;
                }
            }
-            if state.report.as_ref().is_some_and(report::Recording::done)
-                && let Some(recording) = state.report.take()
-            {
-                self.finish_report(recording, state.view, state.max_players);
-            }
-            if horizon_client::spans::trace::due()
-                && let Some(events) = horizon_client::spans::trace::stop()
-            {
-                log(
-                    "INFO",
-                    &format!("Trace written: {events} events (reports/)"),
-                );
+            if state.report.as_ref().is_some_and(report::Recording::done) {
+                self.finish_perf_capture(&mut state, StopReason::Normal);
            }
+            self.serve_perf_requests(&mut state);
+            let done = report::log_saved(&mut state.perf, false);
+            self.perf_captures_done(done);
            // DedicatedServer.sendLowDiskSpaceWarning: the operators hear of it
            // (no window drains the toasts here).
            if horizon_client::chunk_io::take().low_disk_space
@@ -1412,6 +1517,14 @@ impl Game<'_> {
            }
            // MinecraftServer.tickServer records each tick's time, for /tick query (and the status).
            self.clock.record(tick_start.elapsed());
+            state.perf.tick(
+                state.perf_epoch.elapsed().as_secs_f64(),
+                tick_start.elapsed().as_secs_f32() * 1000.0,
+                tick_detail.take(),
+                || self.perf_world_counts(),
+                || self.wire_bytes(),
+            );
+            self.poll_server_memory_snapshot(&mut state);
            // The far ring's brake, once a second on the average tick.
            if braked.elapsed() >= Duration::from_secs(1)
                && let Some(host) = self.lan.as_mut()
@@ -1437,6 +1550,9 @@ impl Game<'_> {
        if let Some(watchdog) = &watchdog {
            watchdog.running.store(false, Ordering::Relaxed);
        }
+        self.finish_perf_capture(&mut state, StopReason::Shutdown);
+        let done = report::log_saved(&mut state.perf, true);
+        self.perf_captures_done(done);
        match crashed {
            Some(message) => self.stop_after_crash(&message),
            None => self.stop_dedicated(),
@@ -1522,12 +1638,15 @@ impl Game<'_> {
        let Some(host) = self.lan.as_mut() else {
            return;
        };
-        let limit = u64::try_from(minutes).unwrap_or(0) * 1200;
        let idle: Vec<u32> = host
            .hub
            .guests
            .iter()
-            .filter(|g| host.hub.ticks.saturating_sub(g.last_action_tick) > limit)
+            .filter(|g| {
+                let idle_ticks = host.hub.ticks.saturating_sub(g.last_action_tick);
+                let won_game = host.play.get(&g.conn).is_some_and(|play| play.won_game);
+                idles_out(idle_ticks, minutes, won_game)
+            })
            .map(|g| g.conn)
            .collect();
        for conn in idle {
@@ -1636,9 +1755,17 @@ impl Game<'_> {
    /// bound to the overworld, whichever level the last server tick left in
    /// place (the last one ticked, often the nether). Its commands run there
    /// and the level in place is put back afterwards.
+    /// The source is the server's own: no entity, at the world spawn, its feedback heard
+    /// (the console's and an RCON client's always is).
    fn as_console_in_overworld<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T {
        let back = console_level(self.dim).and_then(|dim| self.enter_command_level(dim));
+        let source = super::commands::execute::Source {
+            silent: false,
+            ..self.server_source()
+        };
+        let outer = self.command_source.replace(source);
        let out = self.as_console(f);
+        self.command_source = outer;
        if let Some(back) = back {
            self.enter_command_level(back);
        }
@@ -1671,73 +1798,63 @@ impl Game<'_> {
                state.lists.lock().unwrap().stop = true;
            }
            // Horizon's own, on the console only: a performance report (report.rs).
-            "horizon-report" if rest.first() == Some(&"stop") => match state.report.take() {
-                Some(recording) => {
-                    log("INFO", "Stopping the performance report: writing it now");
-                    self.finish_report(recording, state.view, state.max_players);
-                }
-                None => log("INFO", "No performance report is being recorded"),
-            },
-            "horizon-report" if rest.first() == Some(&"status") => match &state.report {
-                Some(recording) => log("INFO", &recording.status()),
-                None => log("INFO", "No performance report is being recorded"),
-            },
-            "horizon-report" => {
-                let seconds = match rest.first().map(|s| s.parse::<u32>()) {
-                    None => Ok(60),
-                    Some(Ok(s)) if (1..=report::MAX_SECONDS).contains(&s) => Ok(s),
-                    Some(_) => Err(()),
+            "horizon-report" | "horizon-trace" => {
+                let trace = command == "horizon-trace";
+                let parsed = if trace {
+                    report::parse_trace(&rest)
+                } else {
+                    report::parse(&rest)
                };
-                match (seconds, &state.report) {
-                    (Err(()), _) => log(
+                match parsed {
+                    Err(()) if trace => log(
                        "INFO",
                        &format!(
-                            "horizon-report [SECONDS | stop | status]: 1 to {} seconds, 60 by default",
+                            "horizon-trace [SECONDS | stop]: 1 to {} seconds, 30 by default",
                            report::MAX_SECONDS
                        ),
                    ),
-                    (Ok(_), Some(_)) => {
-                        log("INFO", "A performance report is already being recorded")
+                    Err(()) => log(
+                        "INFO",
+                        &format!(
+                            "horizon-report [SECONDS | stop | status] [--no-samples] [--timeline]: 1 to {} seconds, 60 by default",
+                            report::MAX_SECONDS
+                        ),
+                    ),
+                    Ok(report::Command::Stop) if state.report.is_some() => {
+                        log("INFO", "Stopping the performance report: writing it now");
+                        self.finish_perf_capture(state, StopReason::Normal);
                    }
-                    (Ok(seconds), None) => {
-                        state.report = Some(report::Recording::start(seconds, self.wire_bytes()));
+                    Ok(report::Command::Stop) => {
+                        log("INFO", "No performance report is being recorded")
+                    }
+                    Ok(report::Command::Status) => match &state.report {
+                        Some(recording) => log("INFO", &recording.status()),
+                        None => log("INFO", "No performance report is being recorded"),
+                    },
+                    Ok(report::Command::Record {
+                        seconds,
+                        samples,
+                        timeline,
+                    }) if state.report.is_none() => {
+                        self.record_report(
+                            state,
+                            &report::Plan {
+                                seconds,
+                                samples,
+                                timeline,
+                                file: None,
+                                trigger: Trigger::Console,
+                                sampler: Default::default(),
+                            },
+                        );
                        log(
                            "INFO",
                            &format!("Recording a performance report for {seconds} s (reports/)"),
                        );
                    }
-                }
-            }
-            // Horizon's own, on the console only: every thread's spans as a timeline (report.rs).
-            "horizon-trace" if rest.first() == Some(&"stop") => {
-                match horizon_client::spans::trace::stop() {
-                    Some(events) => log("INFO", &format!("Trace stopped: {events} events written")),
-                    None => log("INFO", "No trace is being written"),
-                }
-            }
-            "horizon-trace" => {
-                let seconds = match rest.first().map(|s| s.parse::<u32>()) {
-                    None => Some(30),
-                    Some(Ok(s)) if (1..=report::TRACE_MAX_SECONDS).contains(&s) => Some(s),
-                    Some(_) => None,
-                };
-                match seconds.map(report::start_trace) {
-                    None => log(
-                        "INFO",
-                        &format!(
-                            "horizon-trace [SECONDS | stop]: 1 to {} seconds, 30 by default",
-                            report::TRACE_MAX_SECONDS
-                        ),
-                    ),
-                    Some(Ok(path)) => log(
-                        "INFO",
-                        &format!(
-                            "Writing a trace for {} s to {} (open it in ui.perfetto.dev)",
-                            seconds.unwrap_or_default(),
-                            path.display()
-                        ),
-                    ),
-                    Some(Err(e)) => log("ERROR", &format!("Could not start a trace: {e}")),
+                    Ok(report::Command::Record { .. }) => {
+                        log("INFO", "A performance report is already being recorded")
+                    }
                }
            }
            "save-all" => {
@@ -1866,12 +1983,7 @@ impl Game<'_> {
                    return;
                };
                let reason = (rest.len() > 1).then(|| rest[1..].join(" "));
-                let added = state.lists.lock().unwrap().bans.add(BanEntry::new(
-                    user.clone(),
-                    Some("Server".into()),
-                    None,
-                    reason.clone(),
-                ));
+                let added = state.lists.lock().unwrap().ban(&user, reason.clone());
                if added {
                    self.console_reply(Text::translate(
                        "commands.ban.success",
@@ -1911,12 +2023,7 @@ impl Game<'_> {
                    return;
                };
                let reason = (rest.len() > 1).then(|| rest[1..].join(" "));
-                let added = state.lists.lock().unwrap().ip_bans.add(BanEntry::new(
-                    ip.clone(),
-                    Some("Server".into()),
-                    None,
-                    reason.clone(),
-                ));
+                let added = state.lists.lock().unwrap().ban_ip(&ip, reason.clone());
                if !added {
                    self.console_reply(Text::translate("commands.banip.failed", &[]));
                    return;
@@ -2534,6 +2641,23 @@ mod tests {
        assert!(parse_whitelist_bypass("not-a-uuid-at-all").is_err());
    }

+    /// ServerGamePacketListenerImpl.tick: a player idle past `player-idle-timeout` minutes is kicked,
+    /// unless the End poem is showing (`ServerPlayer.wonGame`), which sends no action.
+    #[test]
+    fn a_player_watching_the_end_credits_is_not_kicked_for_idling() {
+        use super::idles_out;
+        // 5 minutes: 6000 ticks. One more is over the limit.
+        assert!(!idles_out(6000, 5, false));
+        assert!(idles_out(6001, 5, false));
+        assert!(!idles_out(6001, 5, true));
+        assert!(!idles_out(1_000_000, 5, true));
+        // The credits are over (won_game false again): the same idle time kicks.
+        assert!(idles_out(1_000_000, 5, false));
+        // 0 or less: no timeout.
+        assert!(!idles_out(1_000_000, 0, false));
+        assert!(!idles_out(1_000_000, -3, false));
+    }
+
    /// `SaveAllCommand.saveAll`: a save that throws is the `ERROR_FAILED` the
    /// source is told about, not a log line the caller never sees.
    #[test]
@@ -2558,6 +2682,51 @@ mod tests {
        );
    }

+    /// MinecraftServer.tickServer: a tick only counts toward pause-when-empty with no player and
+    /// no `/tick sprint` running (`ServerTickRateManager.isSprinting`); a sprint on an empty server
+    /// keeps the count at 0, so it is never paused, and the count starts again after it.
+    #[test]
+    fn a_sprint_on_an_empty_server_does_not_count_toward_the_pause() {
+        let pause_after = 60 * 20;
+        let mut empty_ticks = 0;
+        // One server tick: (players, a `/pregen` task, a `/tick sprint`) -> paused.
+        let tick = |empty_ticks: &mut i32, players, pregen, sprinting| {
+            super::count_empty_tick(empty_ticks, pause_after, players, pregen, sprinting)
+        };
+        for _ in 0..2000 {
+            assert!(!tick(&mut empty_ticks, 0, false, true));
+        }
+        assert_eq!(empty_ticks, 0);
+        // The sprint ended: 1200 empty ticks later the server pauses, not before.
+        for n in 1..=pause_after {
+            assert_eq!(
+                tick(&mut empty_ticks, 0, false, false),
+                n == pause_after,
+                "tick {n}"
+            );
+        }
+        // A sprint that starts while paused resumes the server at once.
+        assert!(!tick(&mut empty_ticks, 0, false, true));
+        assert_eq!(empty_ticks, 0);
+        // A player, or a `/pregen` task, resets the count too.
+        empty_ticks = 5;
+        assert!(!tick(&mut empty_ticks, 1, false, false));
+        assert_eq!(empty_ticks, 0);
+        empty_ticks = 5;
+        assert!(!tick(&mut empty_ticks, 0, true, false));
+        assert_eq!(empty_ticks, 0);
+        // pause-when-empty-seconds=0 never pauses and leaves the count alone.
+        empty_ticks = 5;
+        assert!(!super::count_empty_tick(
+            &mut empty_ticks,
+            0,
+            0,
+            false,
+            false
+        ));
+        assert_eq!(empty_ticks, 5);
+    }
+
    /// A `panic!("literal")` carries a `&str`, a formatted one a `String`; anything else is
    /// named as unknown, so the crash line is never empty.
    #[test]
@@ -2667,6 +2836,46 @@ mod tests {
        }
    }

+    /// `BanPlayerCommands.banPlayers` skips a player who `isBanned`, and `BanIpCommands.banIp` refuses an
+    /// address that is: the console's `/ban` and `/ban-ip` of one banned already change nothing (the first
+    /// reason stays, and the console hears "Nothing changed"), whatever reason they give.
+    #[test]
+    fn the_console_does_not_ban_again_who_is_banned_already() {
+        use super::{BanList, Lists, NameAndId};
+        let dir = std::env::temp_dir().join(format!("horizon-console-ban-{}", std::process::id()));
+        fs::create_dir_all(&dir).unwrap();
+        let mut lists = Lists {
+            ops: super::OpList::new(dir.join("ops.json")),
+            white: super::WhiteList::new(dir.join("whitelist.json")),
+            bans: BanList::new(dir.join("banned-players.json")),
+            ip_bans: super::IpBanList::new(dir.join("banned-ips.json")),
+            use_whitelist: false,
+            enforce_whitelist: false,
+            op_level: 4,
+            player_idle_timeout: 0,
+            stop: false,
+            autosave: true,
+            whitelist_bypass: Vec::new(),
+        };
+        let alpha = NameAndId {
+            id: 0x5ca1ab1e,
+            name: "Alpha".into(),
+        };
+        assert!(lists.ban(&alpha, Some("cheating".into())));
+        assert!(!lists.ban(&alpha, Some("again".into())));
+        assert!(!lists.ban(&alpha, None));
+        let reason = lists.bans.get(&alpha).and_then(|b| b.reason.clone());
+        assert_eq!(reason.as_deref(), Some("cheating"));
+        assert!(lists.ban_ip("1.2.3.4", Some("spam".into())));
+        assert!(!lists.ban_ip("1.2.3.4", Some("more spam".into())));
+        let reason = lists
+            .ip_bans
+            .get(&"1.2.3.4".to_owned())
+            .and_then(|b| b.reason.clone());
+        assert_eq!(reason.as_deref(), Some("spam"));
+        let _ = fs::remove_dir_all(&dir);
+    }
+
    /// A temporary ban (`/tempban`, the chat filter's) keeps the player out and says when it ends;
    /// once it has ended, or after `/pardon`, they come in.
    #[test]
@@ -2750,3 +2959,85 @@ mod tests {
        fs::remove_dir_all(dir).unwrap();
    }
 }
+
+#[cfg(test)]
+mod console_source_tests {
+    use crate::game::{Audio, Game, Options, Progress, Settings, load_resources};
+    use horizon_client::chunk::Chunk;
+    use horizon_core::position::ChunkPos;
+    use std::sync::Arc;
+
+    /// Runs `command` as the console does and returns whether it worked and every message it printed.
+    fn console(game: &mut Game<'_>, command: &str) -> (bool, String) {
+        game.chat_capture = Some(Vec::new());
+        let ok = game.as_console_in_overworld(|g| g.run_command(command));
+        let said = game.chat_capture.take().unwrap_or_default();
+        let said = said
+            .iter()
+            .map(|t| t.component().to_string())
+            .collect::<Vec<_>>()
+            .join("\n");
+        (ok, said)
+    }
+
+    /// `MinecraftServer.createCommandSourceStack`: the console's source has no entity and is named "Server"
+    /// (an RCON client's, `RconConsoleSource`, "Rcon"): `/me` says so, and `teammsg`, which needs an entity,
+    /// refuses it (`permissions.requires.entity`) instead of running as the player in place.
+    #[test]
+    #[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES and scratch homes/cwd"]
+    fn the_console_runs_as_the_server_not_the_player_in_place() {
+        let root = std::path::PathBuf::from(
+            std::env::var_os("HORIZON_TEST_RESOURCES").expect("prepared resources required"),
+        );
+        let settings = Settings::default();
+        let loaded = load_resources(
+            root.clone(),
+            None,
+            &root,
+            &settings,
+            std::time::Instant::now(),
+            false,
+            true,
+            &Progress::new(),
+            &mut |_, _| unreachable!(),
+        )
+        .unwrap();
+        let mut options = Options::parse(std::iter::empty()).unwrap().unwrap();
+        options.resources = root.clone();
+        options.execution_role = crate::game::execution_role::ExecutionRole::IntegratedServer;
+        let mut game = Game::new(
+            &loaded.resources,
+            loaded.pack,
+            loaded.gui.unwrap(),
+            options,
+            settings,
+            Audio::silent(&root),
+            None,
+        )
+        .unwrap();
+        game.build_registries();
+        game.set_allow_commands(true);
+        game.world
+            .chunks
+            .insert((0, 0), Arc::new(Chunk::empty(0, 0)));
+        game.block_ticks
+            .add_empty_chunk(ChunkPos::new(0, 0))
+            .unwrap();
+        let (ok, said) = console(&mut game, "me waves");
+        assert!(
+            ok && said.contains("chat.type.emote") && said.contains("\"Server\""),
+            "{said}"
+        );
+        game.rcon_source = true;
+        let (ok, said) = console(&mut game, "me waves");
+        assert!(ok && said.contains("\"Rcon\""), "{said}");
+        game.rcon_source = false;
+        let (ok, said) = console(&mut game, "teammsg hi");
+        assert!(
+            !ok && said.contains("permissions.requires.entity"),
+            "{said}"
+        );
+        // The console's source is put back after each line.
+        assert!(game.command_source.is_none());
+    }
+}
@@ -1,13 +1,16 @@
 //! A partial check of the world's predicate graph before a dedicated server is Ready.
 //!
 //! Vanilla refuses to start a world whose packs' predicates reference a predicate no pack defines
-//! (`MappedRegistry.freeze`: "Unbound values in registry"), or reference each other in a cycle
+//! (`MappedRegistry.freeze`: "Unbound values in registry"), name a predicate tag no pack defines
+//! ("Unbound tags in registry"), or reference each other in a cycle
 //! (`ReloadableServerRegistries.validateLootRegistries`: a reference "is recursively called").
 //!
 //! This is new, partial validation, not a port of `RegistryDataLoader` or `ValidationContext`. It
 //! follows a predicate's holders only where the condition codecs hold one: `all_of` and `any_of`
 //! `terms`, and `inverted` `term`. A holder is an identifier (a reference) or an inline condition,
-//! which is followed in the same way. Every other condition type and field, an identifier that does
+//! which is followed in the same way. `terms` is a `HolderSetCodec`: a list of holders, one holder
+//! alone (`compactListCodec`, at `.terms[0]`), or a `#tag`. A tag must be defined; the entries of a
+//! defined tag are not followed. Every other condition type and field, an identifier that does
 //! not parse, and the holders of loot tables, advancements and item modifiers are not checked.
 use horizon_client_core::identifier::parse_identifier;
 use serde_json::Value;
@@ -20,6 +23,8 @@ const REGISTRY: &str = "minecraft:predicate";
 pub(super) enum GraphError {
    /// Referenced ids that no predicate binds.
    Unbound(BTreeSet<String>),
+    /// Predicate tags that a `terms` names and no pack defines.
+    UnboundTags(BTreeSet<String>),
    /// References that re-enter a predicate while it is being validated.
    Recursive(Vec<Recursion>),
 }
@@ -39,6 +44,10 @@ impl GraphError {
                "Unbound values in registry ResourceKey[minecraft:root / {REGISTRY}]: [{}]",
                ids.iter().cloned().collect::<Vec<_>>().join(", ")
            )],
+            GraphError::UnboundTags(ids) => vec![format!(
+                "Unbound tags in registry ResourceKey[minecraft:root / {REGISTRY}]: [{}]",
+                ids.iter().cloned().collect::<Vec<_>>().join(", ")
+            )],
            GraphError::Recursive(found) => found
                .iter()
                .map(|r| {
@@ -62,14 +71,16 @@ fn holders(condition: &Value) -> Vec<(String, &Value)> {
        return Vec::new();
    };
    match ty.as_str() {
-        "minecraft:all_of" | "minecraft:any_of" => condition
-            .get("terms")
-            .and_then(Value::as_array)
-            .into_iter()
-            .flatten()
-            .enumerate()
-            .map(|(i, term)| (format!(".terms[{i}]"), term))
-            .collect(),
+        "minecraft:all_of" | "minecraft:any_of" => match condition.get("terms") {
+            Some(Value::Array(terms)) => terms
+                .iter()
+                .enumerate()
+                .map(|(i, term)| (format!(".terms[{i}]"), term))
+                .collect(),
+            Some(Value::String(tag)) if tag.starts_with('#') => Vec::new(),
+            Some(term) => vec![(".terms[0]".to_owned(), term)],
+            None => Vec::new(),
+        },
        "minecraft:inverted" => condition
            .get("term")
            .map(|term| vec![(".term".to_owned(), term)])
@@ -78,12 +89,22 @@ fn holders(condition: &Value) -> Vec<(String, &Value)> {
    }
 }

-/// Every reference a condition holds, inline conditions included.
-fn references(condition: &Value, out: &mut Vec<String>) {
+/// The predicate tag an `all_of` or `any_of` names as its `terms` (`#ns:path`).
+fn tag(condition: &Value) -> Option<String> {
+    let ty = parse_identifier(condition.get("type")?.as_str()?)?;
+    if !matches!(ty.as_str(), "minecraft:all_of" | "minecraft:any_of") {
+        return None;
+    }
+    parse_identifier(condition.get("terms")?.as_str()?.strip_prefix('#')?)
+}
+
+/// Every reference and tag a condition holds, inline conditions included.
+fn references(condition: &Value, out: &mut Vec<String>, tags: &mut Vec<String>) {
+    tags.extend(tag(condition));
    for (_, holder) in holders(condition) {
        match holder {
            Value::String(name) => out.extend(parse_identifier(name)),
-            Value::Object(_) => references(holder, out),
+            Value::Object(_) => references(holder, out, tags),
            _ => {}
        }
    }
@@ -125,12 +146,17 @@ fn walk<'v>(
    }
 }

-/// The world's predicates (by normalized id, after pack precedence): missing references first, as
-/// the registry freezes before anything is validated, then recursive ones.
-pub(super) fn check(predicates: &BTreeMap<String, Value>) -> Result<(), GraphError> {
+/// The world's predicates (by normalized id, after pack precedence) and whether a pack defines a
+/// predicate tag: missing references first, then missing tags, as the registry freezes before
+/// anything is validated, then recursive references.
+pub(super) fn check(
+    predicates: &BTreeMap<String, Value>,
+    has_tag: impl Fn(&str) -> bool,
+) -> Result<(), GraphError> {
    let mut referenced = Vec::new();
+    let mut tags = Vec::new();
    for condition in predicates.values() {
-        references(condition, &mut referenced);
+        references(condition, &mut referenced, &mut tags);
    }
    let unbound: BTreeSet<String> = referenced
        .into_iter()
@@ -139,6 +165,10 @@ pub(super) fn check(predicates: &BTreeMap<String, Value>) -> Result<(), GraphErr
    if !unbound.is_empty() {
        return Err(GraphError::Unbound(unbound));
    }
+    let unbound: BTreeSet<String> = tags.into_iter().filter(|id| !has_tag(id)).collect();
+    if !unbound.is_empty() {
+        return Err(GraphError::UnboundTags(unbound));
+    }
    let mut found = Vec::new();
    for (id, condition) in predicates {
        let mut stack = vec![id.as_str()];
@@ -193,7 +223,7 @@ mod tests {
            // An identifier that does not parse is not checked here.
            ("a:v", json!({"type": "inverted", "term": "Not An Id"})),
        ]);
-        assert_eq!(check(&predicates), Ok(()));
+        assert_eq!(check(&predicates, |_| false), Ok(()));
    }

    #[test]
@@ -205,7 +235,7 @@ mod tests {
            ),
            ("a:c", json!({"type": "inverted", "term": "a:c"})),
        ]);
-        let error = check(&predicates).unwrap_err();
+        let error = check(&predicates, |_| false).unwrap_err();
        assert_eq!(
            error,
            GraphError::Unbound(["a:gone".to_owned(), "b:none".to_owned()].into())
@@ -234,7 +264,7 @@ mod tests {
                json!({"type": "any_of", "terms": [{"type": "inverted", "term": "prg:self"}]}),
            ),
        ]);
-        let mut lines = check(&predicates).unwrap_err().lines();
+        let mut lines = check(&predicates, |_| false).unwrap_err().lines();
        lines.sort();
        // The two cycle lines are the ones vanilla 26.3 logged for this pack.
        assert_eq!(
@@ -246,4 +276,74 @@ mod tests {
            ]
        );
    }
+
+    #[test]
+    fn a_lone_terms_holder_is_terms_0_and_a_tag_must_be_defined() {
+        let target = json!({"type": "minecraft:all_of", "terms": []});
+        // Vanilla 26.3 starts a world whose `terms` is one bound holder alone.
+        let valid = graph(&[
+            ("prg:target", target.clone()),
+            ("prg:ref", json!({"type": "all_of", "terms": "prg:target"})),
+            (
+                "prg:inline",
+                json!({"type": "any_of", "terms": {"type": "inverted", "term": "prg:target"}}),
+            ),
+            (
+                "prg:tagged",
+                json!({"type": "any_of", "terms": "#prg:some"}),
+            ),
+        ]);
+        assert_eq!(check(&valid, |tag| tag == "prg:some"), Ok(()));
+        let missing = graph(&[
+            ("prg:target", target.clone()),
+            (
+                "prg:ref",
+                json!({"type": "minecraft:all_of", "terms": "prg:missing"}),
+            ),
+            (
+                "prg:tagged",
+                json!({"type": "all_of", "terms": "#prg:none"}),
+            ),
+        ]);
+        // Missing values first, then missing tags: the lines vanilla 26.3 logged for each.
+        assert_eq!(
+            check(&missing, |_| false).unwrap_err().lines(),
+            [
+                "Unbound values in registry ResourceKey[minecraft:root / minecraft:predicate]: [prg:missing]"
+            ]
+        );
+        let tags = graph(&[
+            ("prg:target", target.clone()),
+            (
+                "prg:ref",
+                json!({"type": "minecraft:all_of", "terms": "#prg:none"}),
+            ),
+        ]);
+        assert_eq!(
+            check(&tags, |_| false).unwrap_err().lines(),
+            [
+                "Unbound tags in registry ResourceKey[minecraft:root / minecraft:predicate]: [prg:none]"
+            ]
+        );
+        let cycle = graph(&[
+            ("prg:target", target),
+            (
+                "prg:ref",
+                json!({"type": "minecraft:any_of", "terms": "prg:loop"}),
+            ),
+            (
+                "prg:loop",
+                json!({"type": "minecraft:inverted", "term": "prg:ref"}),
+            ),
+        ]);
+        let mut lines = check(&cycle, |_| false).unwrap_err().lines();
+        lines.sort();
+        assert_eq!(
+            lines,
+            [
+                "Found loot table element validation problem in {prg:loop@minecraft:predicate}.term->{prg:ref@minecraft:predicate}.terms[0]: prg:loop of type minecraft:predicate is recursively called",
+                "Found loot table element validation problem in {prg:ref@minecraft:predicate}.terms[0]->{prg:loop@minecraft:predicate}.term: prg:ref of type minecraft:predicate is recursively called",
+            ]
+        );
+    }
 }
@@ -937,7 +937,7 @@ impl Game<'_> {
                Some(ClickEvent::CopyToClipboard(value)) => Click::CopyToClipboard(value),
                Some(ClickEvent::ShowDialog(dialog)) => Click::ShowDialog(dialog),
                Some(ClickEvent::Custom { id, payload }) => Click::Custom { id, payload },
-                Some(ClickEvent::OpenFile(_)) | None => return Ok(()),
+                Some(ClickEvent::OpenFile(_) | ClickEvent::Profiler(_)) | None => return Ok(()),
            };
            let after = open.dialog.after_action;
            return self.run_dialog_action(Some(click), after);
@@ -982,6 +982,7 @@ impl Game<'_> {
                        items: [stack],
                        ticks: 0,
                        playing: false,
+                        loaded_clock: false,
                    }),
                );
            }
@@ -1442,6 +1443,9 @@ impl Game<'_> {
                ProjectileKind::Egg => "minecraft:egg",
                ProjectileKind::SmallFireball => "minecraft:small_fireball",
                ProjectileKind::WindCharge => "minecraft:wind_charge",
+                ProjectileKind::Potion(_, true) => "minecraft:lingering_potion",
+                ProjectileKind::Potion(..) => "minecraft:splash_potion",
+                ProjectileKind::ExperienceBottle => "minecraft:experience_bottle",
                _ => "minecraft:unknown_projectile",
            };
            let (p, v) = (shot.position, shot.velocity);
@@ -12,7 +12,6 @@ use horizon_client::{
    mobs::{Mob, Species, sulfur_cube},
    particles::{ParticleOptions, ParticleType},
    projectiles::{Projectile, ProjectileKind},
-    random_source,
 };
 // Its old home, for mixin code that names it here.
 pub(super) use horizon_client::mod_api::NativeDispensed;
@@ -1198,9 +1197,9 @@ impl Game<'_> {
            "minecraft:experience_bottle"
            | "minecraft:splash_potion"
            | "minecraft:lingering_potion" => {
-                let mut shot = Projectile::new(ProjectileKind::Snowball, at, None);
-                shot.shoot(&mut random_source::entity(), dir, power, uncertainty);
-                self.launch_thrown(one, at, shot.velocity, None);
+                let mut shot = super::potions::thrown_projectile(one, at, false);
+                shot.shoot_own(dir, power, uncertainty);
+                self.add_projectile(shot);
            }
            _ => {
                let kind = match item.as_str() {
@@ -1267,14 +1266,18 @@ impl Game<'_> {
        self.next_entity += 1;
        let (_, uuid) = horizon_client::mobs::living_random();
        self.persist.uuids.insert(self.next_entity, uuid);
-        let mut stand =
+        let stand =
            horizon_client::entities::ArmorStand::new(self.next_entity, foot, y_rot(facing));
-        // Entity.applyImplicitComponents: a name from an anvil names the stand.
-        if let Some(name) = stack.custom_name() {
-            stand.custom_name = Some(horizon_client::text::Text::literal(name));
-        }
        self.world.modified.insert((front.0 >> 4, front.2 >> 4));
        self.armor_stands.push(stand);
+        // EntityType.appendDefaultStackConfig: the dispenser's yaw first, then
+        // the item's createDefaultStackConfig with no user.
+        self.apply_item_stack_config(
+            super::commands::Target::Stand(self.next_entity),
+            "minecraft:armor_stand",
+            &stack,
+            false,
+        );
        (shrink(stack), CLICK)
    }
    /// A tame donkey, mule or llama in front without a chest gets it.
@@ -1343,7 +1346,7 @@ impl Game<'_> {
        self.boats.push(boat);
        // BoatDispenseItemBehavior: createDefaultStackConfig with no user,
        // then setYRot(direction.toYRot()).
-        self.apply_vehicle_stack_config(super::commands::Target::Boat(id), &kind, &stack, false);
+        self.apply_item_stack_config(super::commands::Target::Boat(id), &kind, &stack, false);
        self.set_boat_yaw(id, yaw);
        if self.serving.is_some() || self.options.dedicated.is_some() {
            let boat = self.boats.last().unwrap();
@@ -1393,12 +1396,7 @@ impl Game<'_> {
        self.carts.push(cart);
        // AbstractMinecart.createMinecart: createDefaultStackConfig with no user.
        let id = self.next_entity;
-        self.apply_vehicle_stack_config(
-            super::commands::Target::Cart(id),
-            kind.id(),
-            &stack,
-            false,
-        );
+        self.apply_item_stack_config(super::commands::Target::Cart(id), kind.id(), &stack, false);
        if self.serving.is_some() || self.options.dedicated.is_some() {
            let cart = self.carts.last().unwrap();
            self.native_vehicle_create(
@@ -191,22 +191,12 @@ pub(super) struct Crystal {
    pub beam: Option<[i32; 3]>,
    /// `setPermanentlyInvulnerable` (respawned spike crystals).
    pub invulnerable: bool,
+    /// `onGround` and `fallDistance`: a crystal never moves itself, so they stay
+    /// as loaded until `/tp` grounds it or a cobweb or powder snow resets the
+    /// fall (`crystal.rs`).
+    pub fall: (bool, f64),
 }
 impl Crystal {
-    /// The start of `time` (the spin and bob) for a crystal at `position`: the random draw
-    /// vanilla makes, or under `HORIZON_STILL` one seeded from the position alone. Which crystal
-    /// gets which draw, and a server's entity ids, follow the order chunks load in, which differs
-    /// between launches; the position is the same in every copy of the world. The draw is made
-    /// either way, so the random stays where it would be.
-    pub(super) fn start_time(position: Vec3, drawn: i32, still: bool) -> i32 {
-        if still {
-            horizon_client::mobs::entity_random(0, position)
-                .next_int_bound(100_000)
-                .unwrap_or(0)
-        } else {
-            drawn
-        }
-    }
    /// `EntityType.END_CRYSTAL`: 2 x 2.
    pub(super) fn bounds(&self) -> Aabb {
        let p = self.position;
@@ -1291,14 +1281,8 @@ impl Game<'_> {
            let time = Crystal::start_time(at, drawn, self.clock.still());
            // EndCrystal's constructor takes an id from the entity counter.
            self.next_entity += 1;
-            self.crystals.push(Crystal {
-                id: self.next_entity,
-                position: at,
-                show_bottom: true,
-                time,
-                beam: None,
-                invulnerable: false,
-            });
+            self.crystals
+                .push(Crystal::new(self.next_entity, at, true, time));
            self.world
                .modified
                .insert((at.x.floor() as i32 >> 4, at.z.floor() as i32 >> 4));
@@ -1328,6 +1312,7 @@ impl Game<'_> {
            .flatten();
        for i in 0..self.crystals.len() {
            self.crystals[i].time += 1;
+            self.crystal_block_effects(i);
            let p = self.crystals[i].position;
            let b = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32];
            if let Some(fire) = fire
@@ -3666,7 +3651,7 @@ impl Crystal {
            self.position,
            Vec3::ZERO,
            [0.0, 0.0],
-            (false, 0.0),
+            self.fall,
            uuid,
            raw,
        );
@@ -3694,6 +3679,7 @@ impl Crystal {
                _ => None,
            },
            invulnerable: horizon_client::entity_nbt::flag(tag, "Invulnerable"),
+            fall: horizon_client::entity_nbt::ground_from_nbt(tag),
        })
    }
 }
@@ -3916,14 +3902,8 @@ impl Game<'_> {
        // EndCrystal's constructor takes an id from the entity counter, so
        // the crystal is an entity a command can name (`@e[type=end_crystal]`).
        self.next_entity += 1;
-        self.crystals.push(Crystal {
-            id: self.next_entity,
-            position: at,
-            show_bottom: false,
-            time,
-            beam: None,
-            invulnerable: false,
-        });
+        self.crystals
+            .push(Crystal::new(self.next_entity, at, false, time));
        // EndCrystalItem.useOn: ENTITY_PLACE at the block above, by the player.
        self.post_block_game_event("minecraft:entity_place", above, self.sculk_actor(), None);
        self.world.modified.insert((above[0] >> 4, above[2] >> 4));
@@ -4219,12 +4199,9 @@ impl Game<'_> {
        let drawn = self.world.random.next_int_bound(100_000).unwrap_or(0);
        let time = Crystal::start_time(at, drawn, self.clock.still());
        self.crystals.push(Crystal {
-            id: 0,
-            position: at,
-            show_bottom: true,
-            time,
            beam: Some([0, 128, 0]),
            invulnerable: true,
+            ..Crystal::new(0, at, true, time)
        });
        let _ = self.set_state_named([cx, h, cz], "minecraft:bedrock", &[]);
        let _ = self.set_state_named([cx, h + 1, cz], "minecraft:fire", &[]);
@@ -4769,6 +4746,7 @@ impl Game<'_> {
    }
 }

+mod crystal;
 mod death_render;
 use death_render::{dissolve_color, dissolve_mask, dragon_rays};

@@ -5733,6 +5711,7 @@ mod dragon_fireball_spawn_tests {
                    .insert((x, z), Arc::new(Chunk::empty(x, z)));
            }
        }
+        game.load_ticking_neighbourhood(0, 0);
        assert!(game.run_command("forceload add 0 0"));
        game
    }