Merge branch 'split/cosmetics-names' into split/cosmetics-draw

# Conflicts:
#	crates/horizon-client/src/game/creatures.rs
#	crates/horizon-hooks/src/lib.rs

Cargo.lock

@@ -1401,9 +1401,7 @@ dependencies = [
 name = "horizon-bench"
 version = "0.1.0"
 dependencies = [
- "horizon-platform",
  "horizon-telemetry",
- "log",
  "serde",
  "serde_json",
 ]
@@ -1441,6 +1439,7 @@ dependencies = [
  "glam",
  "horizon-anticheat",
  "horizon-assets",
+ "horizon-bench",
  "horizon-chat-filter",
  "horizon-client-core",
  "horizon-client-input",
@@ -1462,7 +1461,6 @@ dependencies = [
  "horizon-server-files",
  "horizon-shader-api",
  "horizon-shaders",
- "horizon-system",
  "horizon-telemetry",
  "horizon-theme",
  "horizon-threads",
@@ -1524,6 +1522,7 @@ dependencies = [
  "glam",
  "horizon-anticheat",
  "horizon-assets",
+ "horizon-bench",
  "horizon-chat-filter",
  "horizon-client-core",
  "horizon-client-input",
@@ -1794,12 +1793,10 @@ dependencies = [
 name = "horizon-official"
 version = "0.1.0"
 dependencies = [
- "horizon-bench",
  "horizon-friends",
  "horizon-game",
  "horizon-heartbeat",
  "horizon-platform",
- "horizon-telemetry",
  "log",
  "winresource",
 ]
@@ -1808,8 +1805,8 @@ dependencies = [
 name = "horizon-optifine"
 version = "0.1.0"
 dependencies = [
+ "horizon-bench",
  "horizon-core",
- "horizon-system",
  "log",
  "regex",
 ]
@@ -1973,7 +1970,6 @@ dependencies = [
  "getrandom 0.3.4",
  "horizon-addresses",
  "horizon-platform",
- "log",
  "ruzstd",
  "serde",
  "serde_json",

crates/horizon-bench/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "horizon-bench"
 version = "0.1.0"
-edition.workspace = true
+edition = "2021"
 rust-version.workspace = true
 license = "MIT"
 description = "The benchmark report format (docs/benchmark-report.md), shared by the game, the launcher and the upload"
@@ -11,11 +11,3 @@ 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 game's part (`game`): the hooks it plugs into and the probes, from the platform's API.
-horizon-platform = { path = "../horizon-platform", optional = true }
-log = { version = "0.4", optional = true }
-
-[features]
-# The game's `--benchmark` driver, started through the platform's hooks. The official executable
-# turns it on.
-game = ["dep:horizon-platform", "dep:log"]

crates/horizon-bench/src/hardware.rs

@@ -1,7 +1,6 @@
 //! The machine a report was measured on. CPU, RAM and OS are detected here; the GPU and the display
 //! 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 serde::{Deserialize, Serialize};
 
@@ -69,12 +68,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: 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: ram_bytes().map(|b| b >> 20),
             storage: None,
             form: probes.form,
             gpu: None,
@@ -110,16 +109,84 @@ fn probes() -> Probes {
     }
 }
 
+/// The one-minute load average: above about the number of threads the machine was busy.
+pub fn load_average() -> Option<f64> {
+    if cfg!(target_os = "macos") {
+        // "{ 1.23 1.10 1.00 }"
+        output("sysctl", &["-n", "vm.loadavg"])?
+            .trim_start_matches('{')
+            .split_whitespace()
+            .next()?
+            .parse()
+            .ok()
+    } else {
+        std::fs::read_to_string("/proc/loadavg")
+            .ok()?
+            .split_whitespace()
+            .next()?
+            .parse()
+            .ok()
+    }
+}
+
 /// `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()
 }
 
+/// Resident memory of a process, in bytes (macOS, Linux).
+pub fn rss_bytes(pid: u32) -> Option<u64> {
+    if cfg!(target_os = "macos") {
+        return output("ps", &["-o", "rss=", "-p", &pid.to_string()])?
+            .parse::<u64>()
+            .ok()
+            .map(|kb| kb * 1024);
+    }
+    let status = std::fs::read_to_string(format!("/proc/{pid}/status")).ok()?;
+    let line = status.lines().find(|l| l.starts_with("VmRSS:"))?;
+    line.split_whitespace()
+        .nth(1)?
+        .parse::<u64>()
+        .ok()
+        .map(|kb| kb * 1024)
+}
+
+/// CPU time a process has used, user and system, in seconds (macOS, Linux).
+pub fn cpu_seconds(pid: u32) -> Option<f64> {
+    if cfg!(target_os = "macos") {
+        // "[[dd-]hh:]mm:ss.cc"
+        let time = output("ps", &["-o", "time=", "-p", &pid.to_string()])?;
+        let (rest, days) = match time.split_once('-') {
+            Some((d, rest)) => (rest.to_owned(), d.parse::<f64>().ok()?),
+            None => (time, 0.0),
+        };
+        let seconds = rest.split(':').try_fold(0.0, |acc, part| {
+            part.parse::<f64>().ok().map(|v| acc * 60.0 + v)
+        })?;
+        return Some(days * 86_400.0 + seconds);
+    }
+    // utime and stime, fields 14 and 15, in clock ticks (100 per second on Linux).
+    let stat = std::fs::read_to_string(format!("/proc/{pid}/stat")).ok()?;
+    let fields: Vec<&str> = stat.rsplit_once(')')?.1.split_whitespace().collect();
+    let ticks: f64 = fields.get(11)?.parse::<f64>().ok()? + fields.get(12)?.parse::<f64>().ok()?;
+    Some(ticks / 100.0)
+}
+
 #[cfg(target_os = "macos")]
 fn os_version() -> Option<String> {
     output("sw_vers", &["-productVersion"])
 }
 
+#[cfg(target_os = "macos")]
+fn cpu() -> Option<String> {
+    output("sysctl", &["-n", "machdep.cpu.brand_string"])
+}
+
+#[cfg(target_os = "macos")]
+fn ram_bytes() -> Option<u64> {
+    output("sysctl", &["-n", "hw.memsize"])?.parse().ok()
+}
+
 #[cfg(target_os = "linux")]
 fn os_version() -> Option<String> {
     let release = std::fs::read_to_string("/etc/os-release").ok()?;
@@ -132,6 +199,22 @@ fn os_version() -> Option<String> {
     })
 }
 
+#[cfg(target_os = "linux")]
+fn cpu() -> Option<String> {
+    let info = std::fs::read_to_string("/proc/cpuinfo").ok()?;
+    // x86 names the CPU per core; arm64 only gives the core's implementer and part.
+    horizon_telemetry::system::linux_cpu_name(&info)
+}
+
+#[cfg(target_os = "linux")]
+fn ram_bytes() -> Option<u64> {
+    let info = std::fs::read_to_string("/proc/meminfo").ok()?;
+    let kb = key_value(&info, "MemTotal", ':')?
+        .trim_end_matches("kB")
+        .trim();
+    kb.parse::<u64>().ok().map(|kb| kb * 1024)
+}
+
 #[cfg(target_os = "linux")]
 fn key_value<'a>(text: &'a str, key: &str, sep: char) -> Option<&'a str> {
     text.lines().find_map(|line| {
@@ -145,11 +228,39 @@ fn os_version() -> Option<String> {
     horizon_telemetry::system::windows_version()
 }
 
+#[cfg(target_os = "windows")]
+fn cpu() -> Option<String> {
+    horizon_telemetry::system::windows_cpu()
+}
+
+#[cfg(target_os = "windows")]
+fn ram_bytes() -> Option<u64> {
+    let out = output(
+        "powershell",
+        &[
+            "-NoProfile",
+            "-Command",
+            "(Get-CimInstance Win32_ComputerSystem).TotalPhysicalMemory",
+        ],
+    )?;
+    out.parse().ok()
+}
+
 #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
 fn os_version() -> Option<String> {
     None
 }
 
+#[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+fn cpu() -> Option<String> {
+    None
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+fn ram_bytes() -> Option<u64> {
+    None
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -163,6 +274,9 @@ mod tests {
             assert!(hw.cpu.is_some(), "{hw:?}");
             assert!(hw.ram_mb.unwrap() > 256, "{hw:?}");
             assert!(hw.os_version.is_some(), "{hw:?}");
+            assert!(load_average().is_some());
+            assert!(rss_bytes(std::process::id()).unwrap() > 1 << 20);
+            assert!(cpu_seconds(std::process::id()).unwrap() >= 0.0);
         }
     }
 

crates/horizon-bench/src/lib.rs

@@ -11,13 +11,9 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use serde::{Deserialize, Serialize};
 
-#[cfg(feature = "game")]
-pub mod game;
 mod hardware;
 
-pub use hardware::{Display, Gpu, Hardware, power_source};
-/// The process probes, from the platform (`horizon-system`).
-pub use horizon_telemetry::system::{cpu_seconds, load_average, rss_bytes};
+pub use hardware::{cpu_seconds, load_average, power_source, rss_bytes, Display, Gpu, Hardware};
 
 pub const FORMAT: &str = "horizon-benchmark-report";
 pub const VERSION: u32 = 1;

crates/horizon-client-lib/Cargo.toml

@@ -71,8 +71,9 @@ mio = { version = "1.2.4", features = ["os-poll", "net"] }
 # Shared chunk frames are found by one keyed 128-bit hash of their body (lan/conn.rs SharedFrames).
 xxhash-rust = { version = "0.8.19", features = ["xxh3"] }
 horizon-theme = { path = "../horizon-theme" }
-# The official server's address (multiplayer.rs) until it moves to the Horizon layer.
+# Opt-in data collection: the game keeps, the launcher sends (docs/telemetry.md).
 horizon-telemetry = { path = "../horizon-telemetry", default-features = false }
+horizon-bench = { path = "../horizon-bench" }
 crc32fast = "1"
 zip = { version = "9.1.3", default-features = false, features = ["deflate"] }
 # Controllers (evdev + libudev on Linux, IOKit on macOS, Windows.Gaming.Input); the `controllers` feature.

crates/horizon-client-render/Cargo.toml

@@ -7,8 +7,7 @@ rust-version.workspace = true
 description = "The client's world data, rendering and screens: chunks, meshing, light, streaming, the renderer, the HUD, menus and settings; no gameplay"
 
 [dependencies]
-# The crates above the engine: their settings stores (docs/layers.md, "Platform registries"),
-# and the hooks that hear each crash (`crash.rs`).
+# The settings stores of the crates above the engine (docs/layers.md, "Platform registries").
 horizon-hooks = { path = "../horizon-hooks" }
 horizon-cosmetics = { path = "../horizon-cosmetics" }
 # The GUI atlas's pixels, kept compressed once uploaded (hud.rs `pack_pixels`).

crates/horizon-client-render/src/crash.rs

@@ -204,23 +204,6 @@ impl Report {
     }
 }
 
-/// The renderer's adapter ([`crate::gfx::adapter`]), for the hooks above the engine.
-pub fn gpu() -> Option<horizon_hooks::Gpu> {
-    crate::gfx::adapter().map(|a| horizon_hooks::Gpu {
-        name: a.name,
-        vendor: a.vendor,
-        kind: a.kind,
-        driver: a.driver,
-        backend: a.backend,
-    })
-}
-
-/// The build, for what leaves the machine: the release (`v0.2.3`), or `dev <crate version>` for a
-/// build from source.
-pub fn build() -> String {
-    release_tag().unwrap_or_else(|| format!("dev {}", env!("CARGO_PKG_VERSION")))
-}
-
 /// The release this binary is (`v0.2.3`); a nightly's label (`Nightly 2026-10-28 · 0c02067`); for a
 /// release from before 0.2, its tag and the client's crate version; for a build from source, that
 /// version alone.
@@ -400,20 +383,19 @@ fn thread_name(side: &str) -> String {
 /// promise to launchers (docs/api/launch.md), so it never changes within a line of that API.
 pub const SAVED_LINE: &str = "Horizon: crash report saved to ";
 
-/// The hooks above the engine hear the report before it is saved (`Hooks::crashed`; Horizon's
-/// opt-in telemetry keeps it). They run inside the crash handler: they must not panic or block.
-fn tell_hooks(home: &Path, report: &Report) {
-    let version = build();
-    let gpu = gpu();
-    horizon_hooks::engine::crashed(&horizon_hooks::Crash {
-        home,
-        version: &version,
-        error: &report.error,
-        stack: &report.stack,
-        thread: &report.thread,
-        details: &report.details,
-        gpu: gpu.as_ref(),
-    });
+/// What runs on each report before it is saved ([`on_report`]).
+pub type ReportHook = fn(&Path, &Report);
+
+static REPORT_HOOKS: std::sync::RwLock<Vec<ReportHook>> = std::sync::RwLock::new(Vec::new());
+
+/// Runs `hook` with every crash report, before it is saved: the game folder and the report. An
+/// extension point for what lives above the engine (Horizon's opt-in telemetry keeps the
+/// report). A hook runs inside the crash handler: it must not panic or block.
+pub fn on_report(hook: ReportHook) {
+    REPORT_HOOKS
+        .write()
+        .unwrap_or_else(|e| e.into_inner())
+        .push(hook);
 }
 
 /// Writes the report and tells where it is; the log gets the error too.
@@ -436,7 +418,13 @@ fn deliver(home: &Path, report: Report) -> Option<PathBuf> {
         ),
     );
     crate::logging::flush();
-    tell_hooks(home, &report);
+    for hook in REPORT_HOOKS
+        .read()
+        .unwrap_or_else(|e| e.into_inner())
+        .iter()
+    {
+        hook(home, &report);
+    }
     // A player of a shared game folder (`--player-dir`) finds the report beside its own log.
     match report.save(crate::logging::player_dir_override().unwrap_or(home)) {
         Ok(path) => {

crates/horizon-client-render/src/fog.rs

@@ -231,8 +231,8 @@ pub struct FogInputs<'a> {
     /// `GameRenderer.nightVisionScale` while Night Vision is on without
     /// Darkness, else 0 (`FogRenderer.computeFogColor`'s brightenFactor).
     pub night_vision: f32,
-    /// The packs' `environment` fog settings (Polytone's).
-    pub environment: crate::pack_palette::Environment,
+    /// The packs' Polytone `environment` fog settings.
+    pub environment: horizon_polytone::colors::Environment,
 }
 
 /// `FogRenderer.setupFog` + `computeFogColor`.
@@ -581,7 +581,7 @@ mod tests {
         let tables = FogTables {
             water_fog_end: vec![1.0],
         };
-        let environment = crate::pack_palette::Environment {
+        let environment = horizon_polytone::colors::Environment {
             powder_snow_fog: Some(0xFF0000),
             blindness_fog_distance: 40.0,
             water_fog_brightening: 0.0,
@@ -613,7 +613,7 @@ mod tests {
     }
     fn inputs_with<'a>(
         input: &FogInputs<'a>,
-        environment: crate::pack_palette::Environment,
+        environment: horizon_polytone::colors::Environment,
     ) -> FogInputs<'a> {
         FogInputs {
             environment,

crates/horizon-client-render/src/gfx.rs

@@ -239,7 +239,6 @@ mod reuse;
 mod stars;
 mod surface_setup;
 use surface_setup::{AdapterChoice, AdapterFailure, open_adapter, pick_adapter, set_up_surface};
-mod off_page;
 pub mod submit;
 mod sunrise_fan;
 mod timing;
@@ -251,7 +250,6 @@ mod wgsl_prefix;
 mod world_post;
 pub mod world_primitives;
 mod world_warp;
-use off_page::move_off_page;
 
 /// A section's instance: its camera-relative origin and, in `w`, the step of
 /// its fixed-point UVs (`terrain.wgsl`'s `terrain_uv`).
@@ -728,6 +726,62 @@ impl Part {
         }
     }
 }
+/// `Renderer::compact_arena`'s and `shrink_translucent`'s moves: what the meshes
+/// hold on `page` of `arena` (`part`) goes to its other pages in video memory,
+/// until the next range would pass `budget` bytes (it keeps what is left; the
+/// first range moves whatever its size, so none keeps the page closed), the
+/// copies into `encoder`, the ranges' flat draw ids (`flat`) and, in the
+/// section arena, GPU culling's records (`records`) along. False when the other
+/// pages have no room left.
+fn move_off_page<'a>(
+    arena: &mut arena::Arena,
+    encoder: &mut wgpu::CommandEncoder,
+    mut flat: Option<(&mut flat::Flat, &wgpu::Device, &mut upload::Uploads)>,
+    mut records: Option<&mut gpu_culling::Records>,
+    meshes: impl Iterator<Item = &'a mut SectionGpu>,
+    page: u32,
+    part: Part,
+    budget: &mut u64,
+) -> bool {
+    debug_assert!(
+        records.is_none() || matches!(part, Part::Section { .. }),
+        "records follow the section arena's ranges"
+    );
+    let mut moved = false;
+    for s in meshes {
+        // Nothing of a mesh here: split, one without solid quads (its (0, 0) is no
+        // range of page 0); in the other arenas, one without translucent quads.
+        let Some((_, start, vertices)) = part.of(s).filter(|r| r.0 == page) else {
+            continue;
+        };
+        let bytes = vertices * arena.stride();
+        if moved && bytes > *budget {
+            break;
+        }
+        let Some(to) = arena.alloc_moved(vertices) else {
+            return false;
+        };
+        arena.copy(encoder, (page, start), to, vertices);
+        arena.release(page, start, vertices);
+        if let (Some((flat, device, uploads)), Some(id)) = (&mut flat, s.flat_id) {
+            let key = match part {
+                Part::Translucent => to.0 + flat::TRANSLUCENT_KEYS,
+                _ => to.0,
+            };
+            flat.place(device, encoder, uploads, id, key, to.1, vertices);
+        }
+        part.set(s, to);
+        // Its solid quads start the range in either layout.
+        if let (Part::Section { .. }, Some(records), Some(id)) =
+            (part, records.as_deref_mut(), s.gpu_id)
+        {
+            records.relocate(id, to.0, u64::from(s.solid_base()));
+        }
+        *budget = budget.saturating_sub(bytes);
+        moved = true;
+    }
+    true
+}
 /// Starts moving a page of a large arena far larger than its ranges in use
 /// (`Arena::oversized`) into a new page of the size they get (`Arena::open_page`),
 /// for `Renderer::shrink_translucent`: the page closes and `move_off_page` empties
@@ -10062,11 +10116,7 @@ impl Renderer {
         let pack_reads_world = pack_post || native_post;
         laps.lap("r_uploads");
         // Phase 2 of occlusion culling draws over the depth, and a shader pack or TAA reads it.
-        // Post effects (a resource pack's chains, `use_depth_buffer`) read the world's depth
-        // after the world pass, as `GameRenderer.render` hands them the main target's.
-        let post_reads_depth = !frame.title && !frame.post_effects.effects.is_empty();
         let keep_depth = pack_reads_world
-            || post_reads_depth
             || (taa && self.world_post.taa)
             || oit_on
             || native_render::render_needs().world_depth
@@ -13664,7 +13714,6 @@ mod tests {
             Some(Reported {
                 paper_white: 240,
                 peak: 998,
-                peak_guessed: true,
             })
         );
         assert_eq!(
@@ -13672,7 +13721,6 @@ mod tests {
             Some(Reported {
                 paper_white: 480,
                 peak: 480,
-                peak_guessed: true,
             })
         );
         // White above the calibrated peak (a Samsung QD-OLED's 380, the slider at 456).
@@ -13681,7 +13729,6 @@ mod tests {
             Some(Reported {
                 paper_white: 456,
                 peak: 456,
-                peak_guessed: true,
             })
         );
         assert_eq!(os_reported(&info(Some(1000.0), None)), None);
@@ -15372,9 +15419,11 @@ fn log_os_reported(reported: Option<crate::graphics::Reported>) {
         None => "Horizon renderer: the system doesn't report the display's luminance".into(),
     });
 }
-/// What the OS reports in absolute nits, HDR output's scale (Windows: DXGI's SDR white level,
-/// the brightness slider's, as Paper White, and its `MaxLuminance`, mostly the display's EDID
-/// guess, as Peak Brightness), kept within the settings' ranges. The player's values win.
+/// What the OS reports in absolute nits (Windows: DXGI's `MaxLuminance` and the SDR
+/// white level the brightness slider sets), which is HDR output's scale there: SDR
+/// white is Paper White, the display's peak is Peak Brightness. Both are kept within
+/// the settings' ranges. The OS's figures often come from the display's EDID and may
+/// run optimistic; the player's own value always wins.
 fn os_reported(info: &wgpu::DisplayHdrInfo) -> Option<crate::graphics::Reported> {
     let luminance = info.luminance?;
     let usable = |n: f32| n.is_finite() && n > 0.0;
@@ -15386,7 +15435,6 @@ fn os_reported(info: &wgpu::DisplayHdrInfo) -> Option<crate::graphics::Reported>
         // Windows' SDR brightness slider can set white above the reported peak (480 against
         // a calibrated 380): the highlights then stay at white instead of dropping below it.
         peak: (peak.round() as u32).clamp(200, 10_000).max(paper_white),
-        peak_guessed: true,
     })
 }
 
@@ -15422,7 +15470,6 @@ fn reported(l: horizon_hdr::wayland::Luminances) -> crate::graphics::Reported {
     crate::graphics::Reported {
         paper_white: 203,
         peak: peak.clamp(200, 10_000),
-        peak_guessed: false,
     }
 }
 

crates/horizon-client-render/src/gfx/off_page.rs

@@ -1,59 +0,0 @@
-//! `move_off_page`, moved out of `gfx.rs` unchanged.
-use super::*;
-
-/// `Renderer::compact_arena`'s and `shrink_translucent`'s moves: what the meshes
-/// hold on `page` of `arena` (`part`) goes to its other pages in video memory,
-/// until the next range would pass `budget` bytes (it keeps what is left; the
-/// first range moves whatever its size, so none keeps the page closed), the
-/// copies into `encoder`, the ranges' flat draw ids (`flat`) and, in the
-/// section arena, GPU culling's records (`records`) along. False when the other
-/// pages have no room left.
-pub(super) fn move_off_page<'a>(
-    arena: &mut arena::Arena,
-    encoder: &mut wgpu::CommandEncoder,
-    mut flat: Option<(&mut flat::Flat, &wgpu::Device, &mut upload::Uploads)>,
-    mut records: Option<&mut gpu_culling::Records>,
-    meshes: impl Iterator<Item = &'a mut SectionGpu>,
-    page: u32,
-    part: Part,
-    budget: &mut u64,
-) -> bool {
-    debug_assert!(
-        records.is_none() || matches!(part, Part::Section { .. }),
-        "records follow the section arena's ranges"
-    );
-    let mut moved = false;
-    for s in meshes {
-        // Nothing of a mesh here: split, one without solid quads (its (0, 0) is no
-        // range of page 0); in the other arenas, one without translucent quads.
-        let Some((_, start, vertices)) = part.of(s).filter(|r| r.0 == page) else {
-            continue;
-        };
-        let bytes = vertices * arena.stride();
-        if moved && bytes > *budget {
-            break;
-        }
-        let Some(to) = arena.alloc_moved(vertices) else {
-            return false;
-        };
-        arena.copy(encoder, (page, start), to, vertices);
-        arena.release(page, start, vertices);
-        if let (Some((flat, device, uploads)), Some(id)) = (&mut flat, s.flat_id) {
-            let key = match part {
-                Part::Translucent => to.0 + flat::TRANSLUCENT_KEYS,
-                _ => to.0,
-            };
-            flat.place(device, encoder, uploads, id, key, to.1, vertices);
-        }
-        part.set(s, to);
-        // Its solid quads start the range in either layout.
-        if let (Part::Section { .. }, Some(records), Some(id)) =
-            (part, records.as_deref_mut(), s.gpu_id)
-        {
-            records.relocate(id, to.0, u64::from(s.solid_base()));
-        }
-        *budget = budget.saturating_sub(bytes);
-        moved = true;
-    }
-    true
-}

crates/horizon-client-render/src/gfx/output.rs

@@ -300,7 +300,6 @@ pub(crate) mod tests {
                 luminance: Some(Reported {
                     paper_white: 400,
                     peak: 1000,
-                    peak_guessed: false,
                 }),
                 hdr: system,
             },
@@ -651,7 +650,6 @@ pub(crate) mod tests {
         window_reading.luminance = Some(Reported {
             paper_white: 300,
             peak: 800,
-            peak_guessed: false,
         });
         assert_eq!(window_output(window_reading).nits[..2], [300.0, 800.0]);
         assert_eq!(

crates/horizon-client-render/src/gfx/output_apply.rs

@@ -549,7 +549,6 @@ mod tests {
         reading.luminance = Some(Reported {
             paper_white: 250,
             peak: 600,
-            peak_guessed: false,
         });
         // 150 nits under the reported paper white of 250: 0.6 of it.
         settings.hdr_ui_nits = 150;
@@ -585,7 +584,6 @@ mod tests {
             reading.luminance = Some(Reported {
                 paper_white,
                 peak: 1000,
-                peak_guessed: false,
             });
             let next = candidate(&settings, caps, reading, &published);
             let again = commit(&mut swapchain, &published, next, caps, &mut rejected);
@@ -731,7 +729,6 @@ mod tests {
                 luminance: (hdr == Some(true)).then_some(Reported {
                     paper_white: 300,
                     peak: 800,
-                    peak_guessed: false,
                 }),
                 hdr,
             };

crates/horizon-client-render/src/graphics.rs

@@ -30,22 +30,6 @@ fn marker_driver(text: &str) -> &str {
 pub struct Reported {
     pub paper_white: u32,
     pub peak: u32,
-    /// The peak is the display's own claim (DXGI's `MaxLuminance`, mostly its EDID figure),
-    /// which often runs high: Auto still uses it, but the HDR page asks to calibrate.
-    pub peak_guessed: bool,
-}
-
-/// Whether HDR is set up for the display, and whether the player kept the system's setup.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum HdrSetup {
-    /// The system says nothing: the player calibrates.
-    Unknown,
-    /// The system says, but only guesses the peak: the player calibrates.
-    Guessed,
-    /// Peak Brightness and Paper White follow the system.
-    Automatic,
-    /// The system said, and the player changed them anyway.
-    Changed,
 }
 
 /// The top of Peak Brightness's scale: `peak_nits_at(PEAK_STEPS)` is PQ's 10 000 nits.
@@ -1223,15 +1207,6 @@ impl Graphics {
             n => n,
         }
     }
-    /// How HDR is set up for the display the system `reported`.
-    pub fn hdr_setup(&self, reported: Option<Reported>) -> HdrSetup {
-        match reported {
-            None => HdrSetup::Unknown,
-            Some(_) if self.hdr_peak != 0 || self.hdr_paper_white != 0 => HdrSetup::Changed,
-            Some(r) if r.peak_guessed => HdrSetup::Guessed,
-            Some(_) => HdrSetup::Automatic,
-        }
-    }
     /// The black level, in nits. Not the system's: files from before saved 0 for that
     /// (Auto), and a reported black would lift every display's shadows by default.
     pub fn black_level_nits(&self) -> f32 {
@@ -1345,7 +1320,6 @@ mod tests {
         let reported = Some(Reported {
             paper_white: 300,
             peak: 1000,
-            peak_guessed: false,
         });
         assert_eq!(g.ui_nits(reported), 300);
         g.hdr_paper_white = 120;
@@ -1354,33 +1328,6 @@ mod tests {
         assert_eq!((g.ui_nits(None), g.ui_nits(reported)), (400, 400));
     }
 
-    #[test]
-    fn hdr_setup_asks_to_calibrate_where_the_peak_is_guessed() {
-        let wayland = Reported {
-            paper_white: 203,
-            peak: 1015,
-            peak_guessed: false,
-        };
-        let windows = Reported {
-            paper_white: 400,
-            peak: 1000,
-            peak_guessed: true,
-        };
-        let mut g = Graphics::default();
-        assert_eq!(g.hdr_setup(None), HdrSetup::Unknown);
-        assert_eq!(g.hdr_setup(Some(wayland)), HdrSetup::Automatic);
-        assert_eq!(g.hdr_setup(Some(windows)), HdrSetup::Guessed);
-        // Auto still takes the guess, over the 1000-nit default.
-        assert_eq!(g.peak_nits(Some(windows)), 1000);
-        assert_eq!(g.paper_white_nits(Some(windows)), 400);
-        for (peak, paper_white) in [(800, 0), (0, 240)] {
-            (g.hdr_peak, g.hdr_paper_white) = (peak, paper_white);
-            assert_eq!(g.hdr_setup(Some(windows)), HdrSetup::Changed);
-            assert_eq!(g.hdr_setup(Some(wayland)), HdrSetup::Changed);
-            assert_eq!(g.hdr_setup(None), HdrSetup::Unknown);
-        }
-    }
-
     #[test]
     fn hdr_modes_keep_boolean_files_and_round_trip_auto() {
         assert_eq!(Graphics::parse("").hdr, HdrMode::Off);

crates/horizon-client-render/src/graphics_ui.rs

@@ -8,8 +8,7 @@ use crate::{
     gfx::EffectiveOutput,
     graphics::{
         EntityCullingMode, FarDetail, FrameGeneration, GpuCullingMode, GraphicsApi, HdrMode,
-        HdrSetup as Setup, LeafCullingMode, Overlay, Pacing, ParticleCullingMode, PresentMode,
-        Preset, Upscaling,
+        LeafCullingMode, Overlay, Pacing, ParticleCullingMode, PresentMode, Preset, Upscaling,
     },
     graphics_style::Cost,
     lang,
@@ -676,9 +675,28 @@ const LOD_STEPS: [u32; 24] = [
     crate::lod::MAX_CHUNKS,
 ];
 
+/// Whether the system set HDR up for the display, and whether the player kept it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Setup {
+    /// The system says nothing: the player calibrates.
+    Unknown,
+    /// Peak Brightness and Paper White follow the system.
+    Automatic,
+    /// The system said, and the player changed them anyway.
+    Changed,
+}
 /// `out`: the output of the renderer the settings are shown for, with what its display reports.
 fn setup(s: &Settings, out: &EffectiveOutput) -> Setup {
-    s.horizon.hdr_setup(out.reported)
+    setup_of(&s.horizon, out.reported.is_some())
+}
+fn setup_of(g: &crate::graphics::Graphics, reported: bool) -> Setup {
+    if !reported {
+        Setup::Unknown
+    } else if g.hdr_peak == 0 && g.hdr_paper_white == 0 {
+        Setup::Automatic
+    } else {
+        Setup::Changed
+    }
 }
 /// What the HDR page says while HDR output is held back on this window's graphics driver
 /// (`EffectiveOutput::held`): picking a mode tries again (`H::cycle`).
@@ -696,19 +714,13 @@ fn description(
         (Item::Horizon(H::HdrCalibrate), Setup::Unknown) => {
             "Your display didn't say how bright it gets: calibrate to set it up."
         }
-        (Item::Horizon(H::HdrCalibrate), Setup::Guessed) => {
-            "Your display's reported peak is often too high: calibrate to set it up."
-        }
         (Item::Horizon(H::HdrCalibrate), Setup::Automatic) => {
             "Already set up for your display. Only calibrate if HDR looks wrong."
         }
         (Item::Horizon(H::HdrCalibrate), Setup::Changed) => {
             "Puts Peak Brightness and Paper White back to your display's setup."
         }
-        // A guessed peak's Auto is what calibration replaced; paper white is the player's own.
-        (Item::Horizon(h @ (H::HdrPeak | H::HdrPaperWhite)), Setup::Automatic | Setup::Changed)
-            if h == H::HdrPaperWhite || out.reported.is_some_and(|r| !r.peak_guessed) =>
-        {
+        (Item::Horizon(H::HdrPeak | H::HdrPaperWhite), Setup::Automatic | Setup::Changed) => {
             "Set up for your display. Leave on Auto unless it looks wrong."
         }
         (Item::Horizon(H::GpuCulling), _) if s.horizon.gpu_culling == GpuCullingMode::Auto => {
@@ -932,7 +944,7 @@ impl H {
             H::FrameGeneration => labelled("Frame Generation", g.frame_generation.label()),
             H::Hdr => labelled("HDR", g.hdr.label()),
             H::HdrCalibrate => Text::literal(lang::get(match setup(s, out) {
-                Setup::Unknown | Setup::Guessed => "Calibrate...",
+                Setup::Unknown => "Calibrate...",
                 Setup::Automatic => "Calibrate Anyway...",
                 Setup::Changed => "Use Automatic Setup",
             })),

crates/horizon-client-render/src/graphics_ui_hdr_tests.rs

@@ -120,86 +120,14 @@ fn auto_levels_and_setup_read_their_own_renderers_report() {
     assert_eq!(label(H::HdrCalibrate, &silent), "Calibrate...");
 }
 
-/// The setup rows' label and description for each kind of report: none, a compositor's
-/// (Wayland), and Windows', whose peak is the display's own guess.
 #[test]
-fn the_setup_rows_ask_to_calibrate_unless_the_system_set_the_display_up() {
-    let trusted = offering(true, Some(true));
-    let mut guessed = trusted;
-    guessed.reported = guessed.reported.map(|r| crate::graphics::Reported {
-        peak_guessed: true,
-        ..r
-    });
-    let rows = |s: &Settings, out: &EffectiveOutput| {
-        [H::HdrCalibrate, H::HdrPeak, H::HdrPaperWhite].map(|h| {
-            let item = Item::Horizon(h);
-            (item.label(s, out).plain(), description(item, s, out, "-"))
-        })
-    };
-    let calibrate = "Calibrate...";
-    let set_up = "Set up for your display. Leave on Auto unless it looks wrong.";
-    let mut s = Settings::default();
-    s.horizon.hdr = HdrMode::On;
-    let none = (
-        calibrate.into(),
-        "Your display didn't say how bright it gets: calibrate to set it up.",
-    );
-    assert_eq!(
-        rows(&s, &NONE),
-        [
-            none.clone(),
-            ("Peak Brightness: Auto (1000)".into(), "-"),
-            ("Paper White: Auto (203)".into(), "-"),
-        ]
-    );
-    assert_eq!(
-        rows(&s, &guessed),
-        [
-            (
-                calibrate.into(),
-                "Your display's reported peak is often too high: calibrate to set it up."
-            ),
-            ("Peak Brightness: Auto (1000)".into(), "-"),
-            ("Paper White: Auto (400)".into(), "-"),
-        ]
-    );
-    assert_eq!(
-        rows(&s, &trusted),
-        [
-            (
-                "Calibrate Anyway...".into(),
-                "Already set up for your display. Only calibrate if HDR looks wrong."
-            ),
-            ("Peak Brightness: Auto (1000)".into(), set_up),
-            ("Paper White: Auto (400)".into(), set_up),
-        ]
-    );
-    // Calibrated or set by hand, either report offers its automatic setup back.
-    s.horizon.hdr_peak = 800;
-    // Peak's Auto stays a guess on Windows: only Paper White is said to be set up there.
-    let changed = |peak| {
-        [
-            (
-                "Use Automatic Setup".into(),
-                "Puts Peak Brightness and Paper White back to your display's setup.",
-            ),
-            ("Peak Brightness: 800".into(), peak),
-            ("Paper White: Auto (400)".into(), set_up),
-        ]
-    };
-    assert_eq!(rows(&s, &guessed), changed("-"));
-    assert_eq!(rows(&s, &trusted), changed(set_up));
-    assert_eq!(rows(&s, &NONE)[0], none);
-    let mut ui = ui();
-    ui.screen.output = guessed;
-    let at = |[x, y, ..]: [f32; 4]| (x + 8.0, y + 4.0);
-    let calibrate = row(&mut ui, &s, Item::Horizon(H::HdrCalibrate));
-    assert_eq!(press(&mut ui, &mut s, at(calibrate)), [CLICK, CHANGED]);
-    assert_eq!((s.horizon.hdr_peak, s.horizon.hdr_paper_white), (0, 0));
-    assert_eq!(
-        press(&mut ui, &mut s, at(calibrate)),
-        [CLICK, Output::Push(OptionsPage::HdrCalibration)]
-    );
+fn hdr_setup_follows_what_the_system_reported() {
+    let mut g = crate::graphics::Graphics::default();
+    assert_eq!(setup_of(&g, false), Setup::Unknown);
+    assert_eq!(setup_of(&g, true), Setup::Automatic);
+    g.hdr_paper_white = 80;
+    assert_eq!(setup_of(&g, true), Setup::Changed);
+    assert_eq!(setup_of(&g, false), Setup::Unknown);
 }
 
 /// UI Brightness reads as Paper White does, in nits apart from it: Auto shows the paper white

crates/horizon-client-render/src/lib.rs

@@ -67,6 +67,7 @@ mod jei_sprites;
 pub mod jigsaw_block;
 pub mod keypad;
 pub mod terrain_model;
+pub use horizon_polytone::colors as polytone_colors;
 pub use horizon_polytone::creative_tabs as polytone_creative_tabs;
 pub use horizon_world::json_folder;
 pub mod level_loading;

crates/horizon-client-render/src/lod.rs

@@ -2593,7 +2593,8 @@ impl Lod {
         self.returned_at = std::time::Instant::now();
         let nodes = &self.plan.nodes;
         self.mesh_samples.retain(|key| nodes.contains(key));
-        // Queued tiles the view left are not sampled; a running one is dropped (`finish_sample`).
+        // Queued tiles the view left are not sampled (a running one is
+        // dropped when it finishes, `finish_sample`).
         drop_queued_samples(&self.shared, &mut self.pending, |key| {
             self.plan.nodes.contains(key)
         });
@@ -2679,7 +2680,6 @@ impl Lod {
             }
             if let Some((columns, mask)) = self.kept.take(&key) {
                 self.ready.insert(key, columns);
-                self.sync_sample(key);
                 if let Some(mask) = mask {
                     self.detail_masks.insert(key, mask);
                 }

crates/horizon-client-render/src/pack_formats/colors.rs

@@ -1,67 +0,0 @@
-//! Polytone's custom colours (`horizon_polytone::colors`, `colors.json` or `color.properties`)
-//! as the engine's pack colours ([`crate::pack_palette::PackColors`]).
-use std::path::Path;
-
-use horizon_polytone::colors::PackColors;
-
-use crate::block_entity_render::DYES;
-use crate::pack_palette::{self, Environment};
-
-/// The colours of every namespace's file under the pack overlay at `root`.
-pub fn read(root: &Path) -> pack_palette::PackColors {
-    let colors = PackColors::read(root);
-    let by_dye = |f: &dyn Fn(&str) -> Option<u32>| std::array::from_fn(|i| f(DYES[i].0));
-    let env = colors.env;
-    pack_palette::PackColors {
-        dye_diffuse: by_dye(&|name| colors.dye(name, "diffuse")),
-        dye_text: by_dye(&|name| colors.dye(name, "text")),
-        sheep: by_dye(&|name| colors.sheep(name)),
-        redstone: std::array::from_fn(|i| colors.redstone(i as u8)),
-        effects: colors.effects(),
-        entity_shadows: colors.entity_shadows(),
-        xp_bar: colors.xp_bar(),
-        env: Environment {
-            powder_snow_fog: env.powder_snow_fog,
-            blindness_fog_distance: env.blindness_fog_distance,
-            darkness_fog_distance: env.darkness_fog_distance,
-            boss_fog_distance: env.boss_fog_distance,
-            water_fog_brightening: env.water_fog_brightening,
-            water_fog_brightening_time: env.water_fog_brightening_time,
-            horizon_height: env.horizon_height,
-        },
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::pack_palette::{diffuse, redstone, sheep_wool, text};
-
-    #[test]
-    fn a_pack_recolours_only_what_it_names() {
-        // Dyes no other test draws: the table is process-wide.
-        let dir = std::env::temp_dir().join(format!("pack-dyes-{}", std::process::id()));
-        let polytone = dir.join("assets/obs/polytone");
-        std::fs::create_dir_all(&polytone).unwrap();
-        std::fs::write(
-            polytone.join("colors.json"),
-            r#"{"dye": {"cyan": {"diffuse": "00ff00", "text": "0000ff"}}, "sheep": {"pink": "2040ff"}, "redstone": {"7": "0x123456"}}"#,
-        )
-        .unwrap();
-        crate::pack_palette::set(&read(&dir));
-        let (cyan, pink, purple) = (9, 6, 10);
-        assert_eq!(diffuse(cyan), 0x00ff00);
-        assert_eq!(text(cyan), 0x0000ff);
-        assert_eq!(sheep_wool(pink as u8), 0x2040ff);
-        // Wool reads vanilla's dye, not the pack's diffuse: 75% of 0x169C9C.
-        assert_eq!(sheep_wool(cyan as u8), 0x107575);
-        assert_eq!(diffuse(purple), 0x8932B8);
-        assert_eq!(text(purple), 0xA020F0);
-        assert_eq!((redstone(7), redstone(15)), (Some(0x123456), None));
-        crate::pack_palette::set(&Default::default());
-        assert_eq!(redstone(7), None);
-        assert_eq!(diffuse(cyan), 0x169C9C);
-        assert_eq!(sheep_wool(pink as u8), 0xB6687F);
-        std::fs::remove_dir_all(&dir).ok();
-    }
-}

crates/horizon-client-render/src/pack_formats/item_bars.rs

@@ -1,146 +0,0 @@
-//! Polytone's item modifiers' durability bar colours, on the engine's
-//! [`crate::pack_palette::ItemBars`].
-use std::path::Path;
-use std::sync::Arc;
-
-/// An item modifier's `bar_color` of the `damage` type: a row of colours picked by the stack's
-/// damage, the first pixel undamaged, the last at full damage (measured on the real mod).
-struct DamageBar {
-    targets: horizon_polytone::Targets,
-    row: Vec<u32>,
-}
-
-/// The packs' damage bars, the last read first.
-struct Bars(Vec<DamageBar>);
-
-impl crate::pack_palette::ItemBars for Bars {
-    fn color(&self, item: &str, damage: f32) -> Option<u32> {
-        let bar = self
-            .0
-            .iter()
-            .rev()
-            .find(|b| b.targets.matches(item, |_| false))?;
-        let last = (bar.row.len() - 1) as f32;
-        Some(bar.row[(damage.clamp(0.0, 1.0) * last).round() as usize])
-    }
-}
-
-/// Reads the packs' item modifiers' durability bar colours under a pack overlay root: an
-/// `<item>_bar.png` alone, or a json whose `bar_color` is `damage` with its `<name>_bar.png` (or
-/// `<name>.png`) beside it. Colormap ids and inline colormaps aren't read. `None` without any.
-pub fn read(root: &Path) -> Option<Arc<dyn crate::pack_palette::ItemBars>> {
-    let mut bars = Vec::new();
-    for namespace in std::fs::read_dir(root.join("assets"))
-        .into_iter()
-        .flatten()
-        .flatten()
-    {
-        let base = namespace.path().join("polytone/item_modifiers");
-        let mut stack = vec![base.clone()];
-        while let Some(dir) = stack.pop() {
-            for entry in std::fs::read_dir(&dir).into_iter().flatten().flatten() {
-                let path = entry.path();
-                if path.is_dir() {
-                    stack.push(path);
-                } else if let Some(bar) = item_bar(root, &base, &path) {
-                    bars.push(bar);
-                }
-            }
-        }
-    }
-    (!bars.is_empty()).then(|| Arc::new(Bars(bars)) as _)
-}
-
-fn item_bar(root: &Path, base: &Path, path: &Path) -> Option<DamageBar> {
-    let name = path.file_name()?.to_str()?;
-    let row = |png: &Path| {
-        let (width, _, rgba) = crate::sprites::read_rgba(png).ok()?;
-        let row: Vec<u32> = rgba[..width as usize * 4]
-            .as_chunks::<4>()
-            .0
-            .iter()
-            .map(|p| u32::from(p[0]) << 16 | u32::from(p[1]) << 8 | u32::from(p[2]))
-            .collect();
-        (!row.is_empty()).then_some(row)
-    };
-    if let Some(stem) = name.strip_suffix("_bar.png") {
-        // A json of the same name owns its png.
-        if path.with_file_name(format!("{stem}.json")).exists() {
-            return None;
-        }
-        let relative = path.parent()?.strip_prefix(base).ok()?.join(stem);
-        let namespace = base.parent()?.parent()?.file_name()?.to_str()?;
-        let id = format!("{namespace}:{}", relative.to_str()?.replace('\\', "/"));
-        let targets = horizon_polytone::Targets::parse(None, Some(&id)).ok()?;
-        return Some(DamageBar {
-            targets,
-            row: row(path)?,
-        });
-    }
-    let stem = name.strip_suffix(".json")?;
-    let json: serde_json::Value = horizon_world::json_file::read(path).ok()?;
-    if json.get("bar_color")?.as_str()? != "damage" {
-        return None;
-    }
-    let png = [format!("{stem}_bar.png"), format!("{stem}.png")]
-        .into_iter()
-        .map(|png| path.with_file_name(png))
-        .find(|png| png.exists())?;
-    let relative = path.strip_prefix(root).unwrap_or(path).to_string_lossy();
-    let implicit = horizon_polytone::implicit_id(&relative, "item_modifiers");
-    let targets =
-        horizon_polytone::Targets::parse(json.get("targets"), implicit.as_deref()).ok()?;
-    Some(DamageBar {
-        targets,
-        row: row(&png)?,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn png_row(path: &Path, pixels: &[[u8; 3]]) {
-        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
-        let file = std::fs::File::create(path).unwrap();
-        let mut encoder = png::Encoder::new(file, pixels.len() as u32, 1);
-        encoder.set_color(png::ColorType::Rgba);
-        let data: Vec<u8> = pixels
-            .iter()
-            .flat_map(|p| [p[0], p[1], p[2], 255])
-            .collect();
-        encoder
-            .write_header()
-            .unwrap()
-            .write_image_data(&data)
-            .unwrap();
-    }
-
-    #[test]
-    fn a_damage_bar_picks_its_pixel_by_the_stacks_damage() {
-        let dir = std::env::temp_dir().join(format!("pack-bars-{}", std::process::id()));
-        let modifiers = dir.join("assets/minecraft/polytone/item_modifiers");
-        let rgby = [[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 0]];
-        png_row(&modifiers.join("diamond_pickaxe_bar.png"), &rgby);
-        std::fs::write(
-            modifiers.join("tools.json"),
-            r#"{"targets": ["minecraft:iron_axe"], "bar_color": "damage"}"#,
-        )
-        .unwrap();
-        png_row(&modifiers.join("tools_bar.png"), &[[1, 2, 3], [4, 5, 6]]);
-        let bars = read(&dir).unwrap();
-        // The real mod: damage 200 of 1561 shows the first pixel, 1400 the last.
-        assert_eq!(
-            bars.color("minecraft:diamond_pickaxe", 200.0 / 1561.0),
-            Some(0xFF0000)
-        );
-        assert_eq!(
-            bars.color("minecraft:diamond_pickaxe", 1400.0 / 1561.0),
-            Some(0xFFFF00)
-        );
-        assert_eq!(bars.color("minecraft:iron_axe", 0.9), Some(0x040506));
-        assert_eq!(bars.color("minecraft:diamond_shovel", 0.5), None);
-        assert!(read(&dir.join("none")).is_none());
-        std::fs::remove_dir_all(&dir).ok();
-    }
-}

crates/horizon-client-render/src/pack_formats/mod.rs

@@ -3,9 +3,7 @@
 //! crate until the platform's executable installs it: it uses only the crate's public API, so it
 //! moves to a platform crate unchanged, and nothing else in the crate names it.
 
-mod colors;
 mod custom_sky;
-mod item_bars;
 
 use std::path::Path;
 use std::sync::Arc;
@@ -16,18 +14,10 @@ use crate::pack_hooks::PackFormats;
 pub struct Formats;
 
 impl PackFormats for Formats {
-    fn colors(&self, root: &Path) -> Option<crate::pack_palette::PackColors> {
-        Some(colors::read(root))
-    }
-
     fn custom_sky(&self, root: &Path) -> Option<Arc<dyn crate::custom_sky::SkyLayers>> {
         let sky = custom_sky::CustomSky::load(root);
         (!sky.is_empty()).then(|| Arc::new(sky) as _)
     }
-
-    fn item_bars(&self, root: &Path) -> Option<Arc<dyn crate::pack_palette::ItemBars>> {
-        item_bars::read(root)
-    }
 }
 
 /// Installs these formats ([`crate::pack_hooks::install`]); the game does at startup.

crates/horizon-client-render/src/pack_hooks.rs

@@ -10,20 +10,10 @@ use std::sync::{Arc, OnceLock};
 /// What the pack formats beyond vanilla's add to a pack. Each method reads one overlay of a pack
 /// (its folder at `root`); the default is "nothing in this format".
 pub trait PackFormats: Send + Sync {
-    /// The colours the overlay replaces where vanilla hardcodes them.
-    fn colors(&self, _root: &Path) -> Option<crate::pack_palette::PackColors> {
-        None
-    }
-
     /// The sky layers the overlay draws over the vanilla sky, if it has any.
     fn custom_sky(&self, _root: &Path) -> Option<Arc<dyn crate::custom_sky::SkyLayers>> {
         None
     }
-
-    /// The durability bar colours the overlay sets by item, if any.
-    fn item_bars(&self, _root: &Path) -> Option<Arc<dyn crate::pack_palette::ItemBars>> {
-        None
-    }
 }
 
 /// No format beyond vanilla's.

crates/horizon-client-render/src/pack_palette.rs

@@ -1,87 +1,14 @@
-//! The colours a pack replaces where vanilla hardcodes them (Polytone's `colors.json`, read by the
-//! platform's pack formats, [`crate::pack_hooks`]): dye, sheep and redstone colours, for drawing
-//! only (the pack recolours collars, tropical fish, banners, wool, sign text and redstone wire and
-//! dust, while gameplay keeps vanilla's `DyeColor`), mob effect colours, the experience number's,
-//! entity shadows, the effect fogs' settings and durability bar colours. Lock-free: the draw paths
-//! and the mesher's workers read the dye, sheep and redstone tables per face.
+//! Polytone's dye, sheep and redstone colours (`dye.<name>.diffuse|text`, `sheep.<name>`,
+//! `redstone.<power>`), for drawing only: the pack recolours collars, tropical fish, banners, wool,
+//! sign text and redstone wire and dust, while gameplay (crafting, item data, the beacon) keeps
+//! vanilla's `DyeColor`. Lock-free: the draw paths and the mesher's workers read it per face.
 use std::path::Path;
+use std::sync::RwLock;
 use std::sync::atomic::{AtomicU64, Ordering::Relaxed};
-use std::sync::{Arc, RwLock};
 
 use crate::block_entity_render::DYES;
 use crate::signs::DYE_TEXT;
-
-/// The fog settings vanilla hardcodes, as the packs set them (vanilla's by default).
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Environment {
-    /// The fog colour inside powder snow (RGB).
-    pub powder_snow_fog: Option<u32>,
-    /// The fog ends of Blindness (5), Darkness (15) and bosses that add world fog (96).
-    pub blindness_fog_distance: f32,
-    pub darkness_fog_distance: f32,
-    pub boss_fog_distance: f32,
-    /// How much the underwater fog colour washes out (1 vanilla, 0 none).
-    pub water_fog_brightening: f32,
-    /// The ticks under water it takes (vanilla's 600).
-    pub water_fog_brightening_time: f32,
-    /// Below it the sky draws its dark disc (vanilla's 63; flat worlds keep their floor).
-    pub horizon_height: f32,
-}
-
-impl Default for Environment {
-    fn default() -> Self {
-        Self {
-            powder_snow_fog: None,
-            blindness_fog_distance: 5.0,
-            darkness_fog_distance: 15.0,
-            boss_fog_distance: 96.0,
-            water_fog_brightening: 1.0,
-            water_fog_brightening_time: 600.0,
-            horizon_height: 63.0,
-        }
-    }
-}
-
-/// The packs' colours; `None` (and the defaults) where they keep vanilla's.
-#[derive(Clone, Debug, PartialEq)]
-pub struct PackColors {
-    /// By dye id (`DyeColor` order): `getTextureDiffuseColor`, `getTextColor`, the sheep's wool.
-    pub dye_diffuse: [Option<u32>; 16],
-    pub dye_text: [Option<u32>; 16],
-    pub sheep: [Option<u32>; 16],
-    /// `RedStoneWireBlock.COLORS` by power.
-    pub redstone: [Option<u32>; 16],
-    /// Mob effects' colours, by effect id without vanilla's namespace.
-    pub effects: Vec<(String, u32)>,
-    /// False hides every entity's round shadow, whatever the video option says.
-    pub entity_shadows: bool,
-    /// The experience level number's colour and outline.
-    pub xp_bar: [Option<u32>; 2],
-    /// The effect fogs' settings: the fog reads them every frame.
-    pub env: Environment,
-}
-
-impl Default for PackColors {
-    fn default() -> Self {
-        Self {
-            dye_diffuse: [None; 16],
-            dye_text: [None; 16],
-            sheep: [None; 16],
-            redstone: [None; 16],
-            effects: Vec::new(),
-            entity_shadows: true,
-            xp_bar: [None; 2],
-            env: Environment::default(),
-        }
-    }
-}
-
-impl PackColors {
-    /// Whether entities draw their round shadow, as far as the packs say.
-    pub fn entity_shadows(&self) -> bool {
-        self.entity_shadows
-    }
-}
+use horizon_polytone::colors::PackColors;
 
 /// 0 is unset, else `1 << 32 | rgb`.
 static DIFFUSE: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
@@ -89,30 +16,6 @@ static TEXT: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
 static SHEEP: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
 static REDSTONE: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
 
-/// The colours of the pack overlay at `root`, from the installed pack formats; their dye, sheep
-/// and redstone colours go to the draw paths' tables ([`set`]).
-pub fn read(root: &Path) -> PackColors {
-    let formats = crate::pack_hooks::formats();
-    let colors = formats.colors(root).unwrap_or_default();
-    set(&colors);
-    *ITEM_BARS.write().unwrap_or_else(|e| e.into_inner()) = formats.item_bars(root);
-    colors
-}
-
-/// The packs' durability bar colours by item (Polytone's item modifiers' `bar_color`).
-pub trait ItemBars: Send + Sync {
-    /// The bar colour (RGB) of `item` at this damage (0 to 1), when a pack sets one.
-    fn color(&self, item: &str, damage: f32) -> Option<u32>;
-}
-
-static ITEM_BARS: RwLock<Option<Arc<dyn ItemBars>>> = RwLock::new(None);
-
-/// A pack's durability bar colour (RGB) for an item at this damage (0 to 1).
-pub fn item_bar_color(item: &str, damage: f32) -> Option<u32> {
-    let bars = ITEM_BARS.read().unwrap_or_else(|e| e.into_inner());
-    bars.as_ref()?.color(item, damage)
-}
-
 /// Takes the colours of the packs just loaded (vanilla's where they set none).
 pub fn set(colors: &PackColors) {
     let store = |table: &[AtomicU64; 16], i: usize, color: Option<u32>| {
@@ -121,39 +24,129 @@ pub fn set(colors: &PackColors) {
             Relaxed,
         );
     };
-    for i in 0..16 {
-        store(&DIFFUSE, i, colors.dye_diffuse[i]);
-        store(&TEXT, i, colors.dye_text[i]);
-        store(&SHEEP, i, colors.sheep[i]);
-        store(&REDSTONE, i, colors.redstone[i]);
+    for (i, (name, _)) in DYES.iter().enumerate() {
+        store(&DIFFUSE, i, colors.dye(name, "diffuse"));
+        store(&TEXT, i, colors.dye(name, "text"));
+        store(&SHEEP, i, colors.sheep(name));
+        store(&REDSTONE, i, colors.redstone(i as u8));
     }
 }
 
-fn get(table: &[AtomicU64; 16], i: usize) -> Option<u32> {
+/// An item modifier's `bar_color` of the `damage` type: a row of colours picked by the stack's
+/// damage, the first pixel undamaged, the last at full damage (measured on the real mod).
+struct DamageBar {
+    targets: horizon_polytone::Targets,
+    row: Vec<u32>,
+}
+static ITEM_BARS: RwLock<Vec<DamageBar>> = RwLock::new(Vec::new());
+
+/// Reads the packs' item modifiers' durability bar colours under a pack overlay root: an
+/// `<item>_bar.png` alone, or a json whose `bar_color` is `damage` with its `<name>_bar.png` (or
+/// `<name>.png`) beside it. Colormap ids and inline colormaps aren't read.
+pub fn set_item_bars(root: &Path) {
+    let mut bars = Vec::new();
+    for namespace in std::fs::read_dir(root.join("assets"))
+        .into_iter()
+        .flatten()
+        .flatten()
+    {
+        let base = namespace.path().join("polytone/item_modifiers");
+        let mut stack = vec![base.clone()];
+        while let Some(dir) = stack.pop() {
+            for entry in std::fs::read_dir(&dir).into_iter().flatten().flatten() {
+                let path = entry.path();
+                if path.is_dir() {
+                    stack.push(path);
+                } else if let Some(bar) = item_bar(root, &base, &path) {
+                    bars.push(bar);
+                }
+            }
+        }
+    }
+    *ITEM_BARS.write().unwrap_or_else(|e| e.into_inner()) = bars;
+}
+
+fn item_bar(root: &Path, base: &Path, path: &Path) -> Option<DamageBar> {
+    let name = path.file_name()?.to_str()?;
+    let row = |png: &Path| {
+        let (width, _, rgba) = crate::sprites::read_rgba(png).ok()?;
+        let row: Vec<u32> = rgba[..width as usize * 4]
+            .as_chunks::<4>()
+            .0
+            .iter()
+            .map(|p| u32::from(p[0]) << 16 | u32::from(p[1]) << 8 | u32::from(p[2]))
+            .collect();
+        (!row.is_empty()).then_some(row)
+    };
+    if let Some(stem) = name.strip_suffix("_bar.png") {
+        // A json of the same name owns its png.
+        if path.with_file_name(format!("{stem}.json")).exists() {
+            return None;
+        }
+        let relative = path.parent()?.strip_prefix(base).ok()?.join(stem);
+        let namespace = base.parent()?.parent()?.file_name()?.to_str()?;
+        let id = format!("{namespace}:{}", relative.to_str()?.replace('\\', "/"));
+        let targets = horizon_polytone::Targets::parse(None, Some(&id)).ok()?;
+        return Some(DamageBar {
+            targets,
+            row: row(path)?,
+        });
+    }
+    let stem = name.strip_suffix(".json")?;
+    let json: serde_json::Value = horizon_world::json_file::read(path).ok()?;
+    if json.get("bar_color")?.as_str()? != "damage" {
+        return None;
+    }
+    let png = [format!("{stem}_bar.png"), format!("{stem}.png")]
+        .into_iter()
+        .map(|png| path.with_file_name(png))
+        .find(|png| png.exists())?;
+    let relative = path.strip_prefix(root).unwrap_or(path).to_string_lossy();
+    let implicit = horizon_polytone::implicit_id(&relative, "item_modifiers");
+    let targets =
+        horizon_polytone::Targets::parse(json.get("targets"), implicit.as_deref()).ok()?;
+    Some(DamageBar {
+        targets,
+        row: row(&png)?,
+    })
+}
+
+/// A pack's durability bar colour (RGB) for an item at this damage (0 to 1).
+pub fn item_bar_color(item: &str, damage: f32) -> Option<u32> {
+    let bars = ITEM_BARS.read().unwrap_or_else(|e| e.into_inner());
+    let bar = bars
+        .iter()
+        .rev()
+        .find(|b| b.targets.matches(item, |_| false))?;
+    let last = (bar.row.len() - 1) as f32;
+    Some(bar.row[(damage.clamp(0.0, 1.0) * last).round() as usize])
+}
+
+fn read(table: &[AtomicU64; 16], i: usize) -> Option<u32> {
     let v = table[i & 15].load(Relaxed);
     (v != 0).then_some(v as u32)
 }
 
 /// `DyeColor.getTextureDiffuseColor` (RGB) as the packs draw it.
 pub fn diffuse(dye: usize) -> u32 {
-    get(&DIFFUSE, dye).unwrap_or(DYES[dye & 15].1)
+    read(&DIFFUSE, dye).unwrap_or(DYES[dye & 15].1)
 }
 
 /// `DyeColor.getTextColor` (RGB) as the packs draw it.
 pub fn text(dye: usize) -> u32 {
-    get(&TEXT, dye).unwrap_or(DYE_TEXT[dye & 15].1)
+    read(&TEXT, dye).unwrap_or(DYE_TEXT[dye & 15].1)
 }
 
 /// A pack's `RedStoneWireBlock.COLORS` entry for this power (RGB), when it sets one.
 pub fn redstone(power: u8) -> Option<u32> {
-    get(&REDSTONE, usize::from(power))
+    read(&REDSTONE, usize::from(power))
 }
 
 /// `ColorLerper.Type.SHEEP` wool colour: a pack's `sheep.<name>`, else white 0xE6E6E6 and the
 /// others 75% of vanilla's dye (a pack's `dye.*.diffuse` doesn't reach wool).
 pub fn sheep_wool(dye: u8) -> u32 {
     let i = usize::from(dye & 15);
-    if let Some(color) = get(&SHEEP, i) {
+    if let Some(color) = read(&SHEEP, i) {
         return color;
     }
     if i == 0 {
@@ -163,3 +156,81 @@ pub fn sheep_wool(dye: u8) -> u32 {
     let f = |c: u32| ((c as f32 * 0.75).floor() as u32).min(255);
     f(src >> 16 & 255) << 16 | f(src >> 8 & 255) << 8 | f(src & 255)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_pack_recolours_only_what_it_names() {
+        // Dyes no other test draws: the table is process-wide.
+        let dir = std::env::temp_dir().join(format!("pack-dyes-{}", std::process::id()));
+        let polytone = dir.join("assets/obs/polytone");
+        std::fs::create_dir_all(&polytone).unwrap();
+        std::fs::write(
+            polytone.join("colors.json"),
+            r#"{"dye": {"cyan": {"diffuse": "00ff00", "text": "0000ff"}}, "sheep": {"pink": "2040ff"}, "redstone": {"7": "0x123456"}}"#,
+        )
+        .unwrap();
+        set(&PackColors::read(&dir));
+        let (cyan, pink, purple) = (9, 6, 10);
+        assert_eq!(diffuse(cyan), 0x00ff00);
+        assert_eq!(text(cyan), 0x0000ff);
+        assert_eq!(sheep_wool(pink as u8), 0x2040ff);
+        // Wool reads vanilla's dye, not the pack's diffuse: 75% of 0x169C9C.
+        assert_eq!(sheep_wool(cyan as u8), 0x107575);
+        assert_eq!(diffuse(purple), 0x8932B8);
+        assert_eq!(text(purple), 0xA020F0);
+        assert_eq!((redstone(7), redstone(15)), (Some(0x123456), None));
+        set(&PackColors::default());
+        assert_eq!(redstone(7), None);
+        assert_eq!(diffuse(cyan), 0x169C9C);
+        assert_eq!(sheep_wool(pink as u8), 0xB6687F);
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    fn png_row(path: &Path, pixels: &[[u8; 3]]) {
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        let file = std::fs::File::create(path).unwrap();
+        let mut encoder = png::Encoder::new(file, pixels.len() as u32, 1);
+        encoder.set_color(png::ColorType::Rgba);
+        let data: Vec<u8> = pixels
+            .iter()
+            .flat_map(|p| [p[0], p[1], p[2], 255])
+            .collect();
+        encoder
+            .write_header()
+            .unwrap()
+            .write_image_data(&data)
+            .unwrap();
+    }
+
+    #[test]
+    fn a_damage_bar_picks_its_pixel_by_the_stacks_damage() {
+        let dir = std::env::temp_dir().join(format!("pack-bars-{}", std::process::id()));
+        let modifiers = dir.join("assets/minecraft/polytone/item_modifiers");
+        let rgby = [[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 0]];
+        png_row(&modifiers.join("diamond_pickaxe_bar.png"), &rgby);
+        std::fs::write(
+            modifiers.join("tools.json"),
+            r#"{"targets": ["minecraft:iron_axe"], "bar_color": "damage"}"#,
+        )
+        .unwrap();
+        png_row(&modifiers.join("tools_bar.png"), &[[1, 2, 3], [4, 5, 6]]);
+        set_item_bars(&dir);
+        // The real mod: damage 200 of 1561 shows the first pixel, 1400 the last.
+        assert_eq!(
+            item_bar_color("minecraft:diamond_pickaxe", 200.0 / 1561.0),
+            Some(0xFF0000)
+        );
+        assert_eq!(
+            item_bar_color("minecraft:diamond_pickaxe", 1400.0 / 1561.0),
+            Some(0xFFFF00)
+        );
+        assert_eq!(item_bar_color("minecraft:iron_axe", 0.9), Some(0x040506));
+        assert_eq!(item_bar_color("minecraft:diamond_shovel", 0.5), None);
+        set_item_bars(&dir.join("none"));
+        assert_eq!(item_bar_color("minecraft:diamond_pickaxe", 0.5), None);
+        std::fs::remove_dir_all(&dir).ok();
+    }
+}

crates/horizon-client-render/src/settings.rs

@@ -337,6 +337,13 @@ impl Settings {
             .and_then(|mode| self.video_modes.iter().position(|m| *m == mode))
             .map_or(-1, |i| i as i32)
     }
+    /// Loads only the crates' settings stores (`horizon_hooks::settings`) from the files next to
+    /// `path`, into the seat whose turn it is (`horizon_hooks::seat`): a splitscreen player whose
+    /// settings were made from P1's rather than loaded.
+    pub fn load_stores(path: &Path) {
+        let dir = path.parent();
+        horizon_hooks::settings::engine::load(&mut |file| fs::read_to_string(dir?.join(file)).ok());
+    }
     pub fn load(path: &Path) -> Self {
         let mut horizon = path
             .parent()

crates/horizon-client-render/src/spans.rs

@@ -51,7 +51,7 @@ pub fn enabled() -> bool {
 }
 /// Record this thread's spans even with spans off, their wall time only (no CPU clock read):
 /// what the render thread's slow frames spent their time in, for the opt-in performance
-/// statistics (`play_session::Session::frame`). The thread takes them every frame ([`take`]).
+/// statistics (`telemetry::Session::frame`). The thread takes them every frame ([`take`]).
 pub fn record_here(on: bool) {
     HERE.with(|h| h.set(on));
 }
@@ -466,7 +466,7 @@ pub mod startup {
             Mutex, OnceLock,
             atomic::{AtomicBool, AtomicU32, Ordering},
         },
-        time::{Duration, Instant},
+        time::Instant,
     };
 
     static ON: AtomicBool = AtomicBool::new(false);
@@ -489,11 +489,6 @@ pub mod startup {
         ON.store(sink.is_some(), Ordering::Relaxed);
     }
 
-    /// The time since the process started ([`init`]'s origin; zero before it).
-    pub fn since_start() -> Duration {
-        ORIGIN.get().map_or(Duration::ZERO, Instant::elapsed)
-    }
-
     /// Whether a trace is being written.
     #[inline]
     pub fn on() -> bool {

crates/horizon-client/Cargo.toml

@@ -68,11 +68,10 @@ log = "0.4"
 chrono = { version = "0.4.42", default-features = false, features = ["clock", "std"] }
 flate2 = { version = "1.1.10", default-features = false, features = ["zlib-rs", "runtime_detection"] }
 horizon-theme = { path = "../horizon-theme" }
-# The official server's address (multiplayer.rs) until it moves to the Horizon layer. Telemetry,
-# the "I'm playing" ping and the benchmark are Horizon parts the official executable registers.
+# Opt-in data collection: the game keeps, the launcher sends (docs/telemetry.md). The
+# anonymous "I'm playing" ping is the Horizon layer's (`horizon-heartbeat`, in the official executable).
 horizon-telemetry = { path = "../horizon-telemetry", default-features = false }
-# The machine and process probes (the dedicated server's performance report).
-horizon-system = { path = "../horizon-system" }
+horizon-bench = { path = "../horizon-bench" }
 crc32fast = "1"
 zip = { version = "9.1.3", default-features = false, features = ["deflate"] }
 # Controllers (evdev + libudev on Linux, IOKit on macOS, Windows.Gaming.Input); the `controllers` feature.

crates/horizon-client/assets/horizon/lang/en_us.json

@@ -441,7 +441,6 @@
   "HDR Calibration %s/%s: %s": "HDR Calibration %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Sets the three below full screen, one test picture at a time.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Your display didn't say how bright it gets: calibrate to set it up.",
-  "Your display's reported peak is often too high: calibrate to set it up.": "Your display's reported peak is often too high: calibrate to set it up.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Already set up for your display. Only calibrate if HDR looks wrong.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Puts Peak Brightness and Paper White back to your display's setup.",
   "Set up for your display. Leave on Auto unless it looks wrong.": "Set up for your display. Leave on Auto unless it looks wrong.",

crates/horizon-client/src/benchmark.rs

@@ -5,54 +5,16 @@
 //!
 //! The scenes, the world (seed 1234, creative) and every step and figure match `tools/perf_bench.py`,
 //! so reports from the two can be compared.
-//!
-//! Behind the `game` feature: the game starts it through the platform's hooks ([`HOOKS`],
-//! `horizon_platform::hooks`), which the official executable registers (`horizon_official::PARTS`).
 
 use std::path::{Path, PathBuf};
 use std::sync::mpsc::{self, Sender};
 use std::thread;
 use std::time::{Duration, Instant};
 
-use horizon_platform::hooks::{self, Hooks};
+use horizon_bench::{App, Frames, Kind, Report};
 use serde_json::Value;
 
-use crate::{App, Frames, Kind, Report};
-
-/// The benchmark's hooks, for `horizon_platform::hooks::register`.
-pub static HOOKS: Benchmark = Benchmark;
-
-/// Runs `--benchmark SCENARIO`.
-pub struct Benchmark;
-
-impl Hooks for Benchmark {
-    fn knows_benchmark(&self, scenario: &str) -> bool {
-        scenes(scenario).is_some()
-    }
-
-    fn benchmark(&self, run: &hooks::Benchmark<'_>, control: hooks::Control) {
-        start(
-            control,
-            Setup {
-                scenario: run.scenario.to_owned(),
-                started: run.started,
-                app: App {
-                    name: "horizon-client".into(),
-                    version: run.version.to_owned(),
-                    commit: option_env!("HORIZON_COMMIT").map(str::to_owned),
-                    mods: Vec::new(),
-                },
-                simulation_distance: run.simulation_distance,
-                vsync: false,
-                fps_cap: None,
-                offscreen: run.offscreen,
-                game_dir: run.game_dir.to_owned(),
-                home: run.home.to_owned(),
-                build: run.build.to_owned(),
-            },
-        );
-    }
-}
+use crate::control::Request;
 
 pub const SEED: i64 = 1234;
 /// The world the benchmark creates under `saves/`, replaced on every run.
@@ -111,18 +73,14 @@ pub struct Setup {
     pub fps_cap: Option<u32>,
     pub offscreen: bool,
     pub game_dir: PathBuf,
-    /// The game's home folder: the telemetry outbox.
-    pub home: PathBuf,
-    /// The build, as an upload names it (`horizon_platform::hooks::Crash::version`).
-    pub build: String,
 }
 
 /// Starts the driver; the game quits when it is done, and the report's path is printed.
-pub fn start(control: hooks::Control, setup: Setup) {
+pub fn start(requests: Sender<Request>, setup: Setup) {
     thread::Builder::new()
         .name("horizon-benchmark".into())
         .spawn(move || {
-            let control = Control(control);
+            let control = Control(requests);
             match run(&control, setup) {
                 Ok(path) => println!("Horizon: benchmark report {}", path.display()),
                 Err(e) => eprintln!("Horizon: benchmark failed: {e}"),
@@ -132,12 +90,21 @@ pub fn start(control: hooks::Control, setup: Setup) {
         .expect("spawn the benchmark thread");
 }
 
-struct Control(hooks::Control);
+struct Control(Sender<Request>);
 
 impl Control {
     fn call(&self, line: &str) -> Result<Value, String> {
+        let (reply, response) = mpsc::channel();
+        self.0
+            .send(Request {
+                line: line.to_owned(),
+                reply,
+            })
+            .map_err(|_| "the game has exited".to_owned())?;
         // Flights and loads reply when they finish.
-        let text = (self.0)(line, LOAD_LIMIT).ok_or_else(|| format!("{line}: no reply"))?;
+        let text = response
+            .recv_timeout(LOAD_LIMIT)
+            .map_err(|_| format!("{line}: no reply"))?;
         let value: Value = serde_json::from_str(&text).map_err(|e| e.to_string())?;
         match value.get("error").and_then(Value::as_str) {
             Some(e) => Err(format!("{line}: {e}")),
@@ -187,8 +154,8 @@ fn run(control: &Control, setup: Setup) -> Result<PathBuf, String> {
         scenes(&setup.scenario).ok_or_else(|| format!("unknown scenario {}", setup.scenario))?;
     let mut report = Report::new(Kind::Game, setup.app.clone());
     let pid = std::process::id();
-    report.conditions.load_avg_1m = crate::load_average();
-    report.conditions.power = crate::power_source().map(str::to_owned);
+    report.conditions.load_avg_1m = horizon_bench::load_average();
+    report.conditions.power = horizon_bench::power_source().map(str::to_owned);
     let rss = RssSampler::start(pid);
 
     let title = poll(control, LOAD_LIMIT, |s| {
@@ -196,7 +163,7 @@ fn run(control: &Control, setup: Setup) -> Result<PathBuf, String> {
     })?;
     report.metric("startup.title_ms", &[ms(setup.started.elapsed())]);
     let renderer = &title["renderer"];
-    report.hardware.gpu = Some(crate::Gpu {
+    report.hardware.gpu = Some(horizon_bench::Gpu {
         name: text(&renderer["gpu"]),
         vendor: match text(&renderer["vendor"]) {
             // Metal reports no vendor ID.
@@ -209,7 +176,7 @@ fn run(control: &Control, setup: Setup) -> Result<PathBuf, String> {
         vram_mb: None,
     });
     if let Some(gpu) = report.hardware.gpu.as_mut() {
-        let vendor = horizon_platform::system::gpu_vendor(&gpu.name, 0);
+        let vendor = horizon_telemetry::system::gpu_vendor(&gpu.name, 0);
         let vendor = if gpu.vendor.is_empty() {
             vendor
         } else {
@@ -217,10 +184,11 @@ fn run(control: &Control, setup: Setup) -> Result<PathBuf, String> {
         }
         .to_owned();
         if gpu.kind.contains("iscrete") {
-            gpu.vram_mb = horizon_platform::system::vram_mb(&vendor);
+            gpu.vram_mb = horizon_telemetry::system::vram_mb(&vendor);
         }
     }
-    report.hardware.storage = horizon_platform::system::storage(&setup.game_dir).map(str::to_owned);
+    report.hardware.storage =
+        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)?;
@@ -343,7 +311,7 @@ fn run(control: &Control, setup: Setup) -> Result<PathBuf, String> {
     if let Ok(meta) = std::env::current_exe().and_then(std::fs::metadata) {
         report.metric("game.binary_bytes", &[meta.len() as f64]);
     }
-    keep_for_upload(&setup.home, &setup.build, &report);
+    crate::telemetry::keep_benchmark(&crate::logging::game_home(), &report);
     report
         .write_to(&setup.game_dir.join("benchmarks"))
         .map_err(|e| e.to_string())
@@ -488,7 +456,7 @@ impl RssSampler {
             while let Err(mpsc::RecvTimeoutError::Timeout) =
                 stopped.recv_timeout(Duration::from_millis(250))
             {
-                samples.extend(crate::rss_bytes(pid).map(|b| (Instant::now(), b)));
+                samples.extend(horizon_bench::rss_bytes(pid).map(|b| (Instant::now(), b)));
             }
             samples
         });
@@ -500,80 +468,10 @@ impl RssSampler {
     }
 }
 
-/// Keeps the report for the launcher to send, if the player allows benchmark uploads: the report
-/// as docs/benchmark-report.md defines it, dated to the day (docs/telemetry.md).
-fn keep_for_upload(home: &Path, build: &str, report: &Report) {
-    use horizon_telemetry::{Item, Payload, Source, outbox};
-    let Ok(data) = serde_json::to_value(report.for_upload()) else {
-        return;
-    };
-    let item = Item::new(Source::Game, build.to_owned(), Payload::Benchmark(data));
-    if let Err(e) = outbox::push(home, &item) {
-        log::warn!("Horizon: could not keep the benchmark report to send: {e}");
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    /// A control line and where its reply goes, as the game's command queue takes them.
-    struct Request {
-        line: String,
-        reply: Sender<String>,
-    }
-
-    /// A control that hands each line to `requests`, as the game does.
-    fn control(requests: Sender<Request>) -> Control {
-        Control(Box::new(move |line, wait| {
-            let (reply, response) = mpsc::channel();
-            let request = Request {
-                line: line.to_owned(),
-                reply,
-            };
-            requests.send(request).ok()?;
-            response.recv_timeout(wait).ok()
-        }))
-    }
-
-    #[test]
-    fn reports_kept_for_upload_need_their_own_consent_and_go_dated_to_the_day() {
-        use horizon_telemetry::{Choices, Consent, outbox};
-        let home = std::env::temp_dir().join(format!(
-            "horizon-client-benchmark-upload-{}",
-            std::process::id()
-        ));
-        let _ = std::fs::remove_dir_all(&home);
-        std::fs::create_dir_all(&home).unwrap();
-        let allow = |choices: Choices| {
-            let mut consent = Consent::load(&home);
-            consent.answer(choices);
-            consent.save(&home).unwrap();
-        };
-        let mut report = Report::new(Kind::Game, Default::default());
-        report.created = "2026-10-15T14:03:27Z".into();
-        report.label = Some("my machine".into());
-        keep_for_upload(&home, "0.2.31", &report);
-        allow(Choices {
-            performance: true,
-            ..Choices::NONE
-        });
-        keep_for_upload(&home, "0.2.31", &report);
-        assert!(outbox::pending(&home).is_empty());
-        allow(Choices {
-            benchmarks: true,
-            ..Choices::NONE
-        });
-        keep_for_upload(&home, "0.2.31", &report);
-        let pending = outbox::pending(&home);
-        assert_eq!(pending.len(), 1);
-        let text = serde_json::to_string(&pending[0].1).unwrap();
-        assert!(
-            text.contains("2026-10-15T00:00:00Z") && !text.contains("my machine"),
-            "{text}"
-        );
-    }
-
     #[test]
     fn scenarios() {
         assert_eq!(scenes("standard").unwrap().len(), 4);
@@ -626,7 +524,7 @@ mod tests {
                 }
             }
         });
-        let control = control(tx);
+        let control = Control(tx);
         wait_loaded(&control, |_| true).expect("the scene loads");
         assert!(
             polls.load(std::sync::atomic::Ordering::SeqCst) > LATE,
@@ -658,15 +556,15 @@ mod tests {
                 }
                 lines
             });
-            let hardware = crate::Hardware {
-                gpu: Some(crate::Gpu {
+            let hardware = horizon_bench::Hardware {
+                gpu: Some(horizon_bench::Gpu {
                     backend: backend.into(),
                     ..Default::default()
                 }),
                 ..Default::default()
             };
             let mut report = Report::with_hardware(Kind::Game, App::default(), hardware);
-            let control = control(tx);
+            let control = Control(tx);
             let timed = time_passes(&control, "forest", &mut report).expect("the wait runs");
             drop(control);
             (timed, server.join().unwrap(), report.metrics)

crates/horizon-client/src/client_lib.rs

@@ -21,11 +21,11 @@ pub use horizon_client_render::{
     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,
+    polytone_colors, 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;
@@ -33,6 +33,7 @@ pub mod attribute_updates;
 pub mod auto_jump;
 pub mod banner;
 pub mod beehive;
+pub mod benchmark;
 pub mod block_entity_item;
 pub mod block_pattern;
 pub mod block_transform;
@@ -109,7 +110,6 @@ pub mod osk;
 pub mod patrol;
 pub mod perf_overlay;
 pub mod pick_item;
-pub mod play_session;
 pub mod player_sync;
 pub mod portal_sections;
 pub mod pose;
@@ -139,6 +139,7 @@ pub mod stations;
 pub mod stopwatches;
 pub mod structure_blocks;
 pub mod studio;
+pub mod telemetry;
 pub mod text_display;
 pub mod tick_chunk_membership;
 pub mod ticket_levels;

crates/horizon-client/src/entity_nbt.rs

@@ -2666,9 +2666,9 @@ pub fn mob_from_nbt_with_random(
         m.extra.counter = number(tag.get("still_timeout")).unwrap_or(0) as i32;
     }
     if m.species() == crate::mobs::Species::Shulker {
-        m.extra.variant3 = (number(tag.get("AttachFace")).unwrap_or(0) % 6).unsigned_abs() as u8;
-        m.extra.counter = number(tag.get("Peek")).map_or(0, |v| v as i8 as i32);
-        m.extra.color = number(tag.get("Color")).map_or(16, |v| v as i8 as u8);
+        m.extra.variant3 = number(tag.get("AttachFace")).unwrap_or(0).clamp(0, 5) as u8;
+        m.extra.counter = number(tag.get("Peek")).unwrap_or(0).clamp(0, 100) as i32;
+        m.extra.color = number(tag.get("Color")).map_or(16, |c| c.clamp(0, 16) as u8);
         m.anim.v[0] = m.extra.counter as f32 * 0.01;
         m.anim.vo[0] = m.anim.v[0];
         // Shulker.setPos: square on its block.

crates/horizon-client/src/entry.rs

@@ -20,11 +20,14 @@ pub fn main_with(mods: crate::mod_api::Mods) {
         horizon_client::options_ui::HORIZON_EXTRAS
             .store(false, std::sync::atomic::Ordering::Relaxed);
     }
-    // The process's start, for the startup trace and the start's milestones.
-    horizon_client::spans::startup::init(std::time::Instant::now());
-    // Crates above the engine registered their hooks before this (horizon-official's `main`);
-    // none registers after this point.
+    horizon_client::telemetry::mark_start();
+    // Opt-in telemetry keeps each crash report (docs/telemetry.md), whatever the mode.
+    crash::on_report(horizon_client::telemetry::keep_crash);
+    // Crates above the engine registered their hooks before this (horizon-official's `main`),
+    // then the Horizon parts still in this crate; none registers after this point.
+    game::player_hooks::register();
     horizon_hooks::engine::seal();
+    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");

crates/horizon-client/src/game.rs

@@ -373,6 +373,7 @@ mod place_feature_tests;
 mod play_input;
 mod play_keys;
 mod player_equip;
+pub(crate) mod player_hooks;
 mod player_spawn;
 mod pointer_capture;
 #[cfg(test)]
@@ -2028,7 +2029,7 @@ pub struct PackResources {
     /// The packs' Polytone post chains (#11486), when a pack has some.
     polytone_post: Option<Arc<horizon_client::polytone_post::PolytonePost>>,
     /// The packs' Polytone custom colours (`polytone/colors.json`).
-    polytone_colors: Arc<horizon_client::pack_palette::PackColors>,
+    polytone_colors: Arc<horizon_client::polytone_colors::PackColors>,
 }
 /// A quick craft drag as the screen draws it: each dragged slot's count and
 /// whether the slot caps it (None: hidden), and what stays in hand.
@@ -2801,7 +2802,7 @@ struct Game<'a> {
     agent_last: Option<Instant>,
     frame_stats: horizon_client::control::FrameStats,
     /// This play session's frame and tick times, for opt-in performance statistics.
-    perf: horizon_client::play_session::Session,
+    perf: horizon_client::telemetry::Session,
     /// Control replies waiting for a rendered frame or a benchmark deadline.
     pending_screenshot: Option<std::sync::mpsc::Sender<String>>,
     /// `screenshot-sequence` while it runs.
@@ -6142,7 +6143,7 @@ impl Game<'_> {
                     let atlas = &g.gui.atlas;
                     let width = |s: &str| HudBatch::text_width(atlas, s) as i32;
                     let draws = hud_layout::experience_colored(
-                        g.pack.polytone_colors.xp_bar,
+                        g.pack.polytone_colors.xp_bar(),
                         wi,
                         hi,
                         g.experience.progress,
@@ -6475,6 +6476,18 @@ impl Game<'_> {
             self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1);
         }
     }
+    /// `AbstractContainerScreen` keeps `isQuickCrafting` and the drag it
+    /// belongs to on the screen. Horizon keeps both on `Game` (`inv_clicks`,
+    /// `inv_drag`, `last_inv_click`), so they are dropped when the pointer
+    /// changes hands: a screen that opens or closes starts with its own
+    /// state, and a press whose release never reached the screen -- the
+    /// pointer left the window, or the screen closed first -- would
+    /// otherwise leave every later press on every later screen swallowed.
+    pub(super) fn reset_inventory_clicks(&mut self) {
+        self.inv_clicks.cancel_drag();
+        self.inv_drag = None;
+        self.last_inv_click = None;
+    }
     pub(super) fn close_container(&mut self) {
         // `Gui.setScreen` clears the old screen's focus before it goes: the
         // key that closed the container (Tab bound to the inventory) has
@@ -6518,6 +6531,20 @@ impl Game<'_> {
         }
         self.close_ender_chest();
     }
+    /// A sound a menu click made the player play (a bundle's insert or
+    /// remove): `Entity.playSound` at the player.
+    pub(super) fn player_menu_sound(&mut self, sound: &str) {
+        let Some(p) = self.player.as_ref() else {
+            return;
+        };
+        let at = [p.position.x, p.position.y, p.position.z];
+        let (volume, pitch) = if sound == horizon_client::bundle::INSERT_FAIL {
+            (1.0, 1.0)
+        } else {
+            (0.8, 0.8 + self.world.random.next_float() * 0.4)
+        };
+        self.audio.play(sound, Some(at), volume, pitch);
+    }
     /// `Camera.setRotation`: the camera's orientation, turned round in
     /// third-person front view.
     pub(super) fn camera_orientation(&self) -> glam::Quat {
@@ -7466,7 +7493,6 @@ impl Game<'_> {
         self.spawn_phantoms();
         self.tick_advancements();
         self.tick_player_model();
-        self.tick_emotes();
         Ok(())
     }
 
@@ -12635,11 +12661,11 @@ pub fn run_with() -> Result<()> {
         options.spikes = Some(dedicated::SLOW_TICK_MS);
     }
     tick_profile::want_spans(tick_profile::SPANS_SPIKES, options.spikes.is_some());
-    // A hook that wants to know what slow frames spent their time in (a player who allows
-    // performance statistics): this thread, which draws the frames, times its steps (wall time
-    // only).
+    // A player who allows performance statistics also says what their slow frames spent their
+    // time in: this thread, which draws the frames, times its steps (wall time only).
     if options.execution_role.is_client()
-        && horizon_hooks::engine::wants_frame_steps(&horizon_client::logging::game_home())
+        && horizon_telemetry::Consent::load(&horizon_client::logging::game_home())
+            .allows(horizon_telemetry::Kind::Perf)
     {
         horizon_client::spans::record_here(true);
     }
@@ -12664,7 +12690,7 @@ pub fn run_with() -> Result<()> {
     // for a server, a benchmark, a run that quits by itself, a harness's fixture or a run that
     // horizon-ctl drives: those start in a source checkout and wrote the list there.
     if !options.offscreen && !synchronous_startup(&options) {
-        let version = horizon_client::crash::build();
+        let version = horizon_client::telemetry::version();
         horizon_hooks::engine::started(&horizon_hooks::Started::new(&version));
         // horizon-extras: the official server is Horizon's (docs/forking.md).
         #[cfg(feature = "horizon-extras")]

crates/horizon-client/src/game/cosmetics.rs

@@ -20,13 +20,17 @@ use horizon_cosmetics::follow::Follow;
 use horizon_cosmetics::prefs::{self, Others};
 use horizon_cosmetics::trail::{Budget, Emitter};
 use horizon_cosmetics::{Item, Slot};
+use horizon_hooks::players::{
+    Badge, CameraOverride, CameraView, Frame, Gear, Kind, Mark, NameDecoration, PlayerModel,
+    PlayerModels, SpriteStore, Sprites,
+};
 use std::cell::{Cell, RefCell};
-use std::sync::Arc;
 use std::sync::mpsc::{Receiver, channel};
+use std::sync::{Arc, Mutex, PoisonError};
 use std::time::{Duration, Instant};
 
 /// Horizon's mark before a Horizon player's name, over their name tag and in the player list.
-pub(super) const MARK: horizon_client::tab_list::NameMark = &horizon_cosmetics::mark::MARK;
+const MARK: Mark = &horizon_cosmetics::mark::MARK;
 
 /// An item as the renderer takes it.
 struct Baked {
@@ -55,7 +59,8 @@ impl Baked {
 
 #[derive(Default)]
 pub(super) struct Cosmetics {
-    client: Option<horizon_cosmetics::Cosmetics>,
+    /// The hooks' client (`Seat`), taken once it started.
+    client: Option<Arc<horizon_cosmetics::Cosmetics>>,
     /// By the item's address; each entry holds its item, so the address isn't reused.
     baked: RefCell<FxHashMap<usize, Baked>>,
     /// Items drawn whose texture isn't in the atlas yet.
@@ -65,16 +70,6 @@ pub(super) struct Cosmetics {
     poses: RefCell<(Poses, Poses)>,
     /// Item files from a folder (`HORIZON_COSMETICS_LOCAL`): mannequins wear them too.
     local: bool,
-    /// Show my cosmetics on its way to the service.
-    mine: AccountSync,
-    /// Show me as a Horizon player: sent at start, on each change and every hour while on.
-    listed: AccountSync,
-    /// Whether the signed-in account owns a cosmetic.
-    owner: OwnerCheck,
-    /// Which other players play an emote (`horizon_cosmetics::Feed`), started with the client.
-    feed: Option<horizon_cosmetics::Feed>,
-    /// My emote on its way to the service.
-    emote_out: EmoteOut,
     /// Companions, trails and auras.
     fx: RefCell<Fx>,
     /// Emotes: those the wheel offers and the one playing (`cosmetics/emotes.rs`).
@@ -405,17 +400,13 @@ fn slot_image(item: &Item) -> Vec<u8> {
 
 /// Which slots an avatar's gear covers: a helmet or head item hides a hat, an elytra or a cape
 /// what is worn on the back. A name tag style is never drawn on the body.
-fn covered(m: &Mob, slot: Slot) -> bool {
+fn covered(gear: Gear, slot: Slot) -> bool {
     match slot {
-        Slot::Head => m.extra.head.is_some(),
-        Slot::Back => m.cape.is_some() || m.extra.chest.as_deref() == Some("minecraft:elytra"),
+        Slot::Head => gear.head,
+        Slot::Back => gear.back,
         Slot::Shoulder => false,
         // A chestplate, not an elytra.
-        Slot::Torso => m
-            .extra
-            .chest
-            .as_deref()
-            .is_some_and(|c| c != "minecraft:elytra"),
+        Slot::Torso => gear.chest,
         Slot::NameTag | Slot::Emote => true,
         // On no bone: drawn by a pass of their own, never on the body.
         Slot::Companion | Slot::Trail | Slot::Aura => true,
@@ -427,12 +418,12 @@ fn covered(m: &Mob, slot: Slot) -> bool {
 /// (`worn` is None), another player's at "name tags only" or hidden, or every item `covered` (a
 /// helmet over a hat). One max over at most five items, read when the item was parsed.
 fn body_top(
-    extras: &horizon_client::extras::Extras,
+    others: Others,
     own: bool,
     worn: Option<&horizon_cosmetics::Worn>,
     covered: impl Fn(Slot) -> bool,
 ) -> Option<f32> {
-    if !own && extras.effective_others() != Others::Shown {
+    if !own && others != Others::Shown {
         return None;
     }
     worn?
@@ -449,115 +440,424 @@ pub(super) fn enabled() -> bool {
     cfg!(feature = "horizon-extras") && horizon_cosmetics::enabled()
 }
 
+/// What the cosmetics' hooks keep for one splitscreen player (`horizon_hooks::seat`): the
+/// service's client, the emote feed and what the account tells the service.
+#[derive(Default)]
+struct Seat {
+    client: Option<Arc<horizon_cosmetics::Cosmetics>>,
+    /// Item files from a folder (`HORIZON_COSMETICS_LOCAL`).
+    local: bool,
+    /// Show my cosmetics on its way to the service.
+    mine: AccountSync,
+    /// Show me as a Horizon player: sent at start, on each change and every hour while on.
+    listed: AccountSync,
+    /// Whether the signed-in account owns a cosmetic.
+    owner: OwnerCheck,
+    /// Which other players play an emote (`horizon_cosmetics::Feed`), started with the client.
+    feed: Option<horizon_cosmetics::Feed>,
+    /// My emote on its way to the service.
+    emote_out: EmoteOut,
+    /// What the game's settings and the player's emote say (`Game::cosmetics_say`).
+    said: Said,
+    /// Kept between ticks so a tick allocates nothing: the player models in view.
+    models: Vec<PlayerModel>,
+    /// The world is the window's own single-player one (`Frame::solo`).
+    solo: bool,
+    /// Name tag badges' sprites, by the item's address: their id (never reused) and the item,
+    /// held so the address isn't reused while it is there.
+    sprites: FxHashMap<usize, (u64, Arc<Item>)>,
+    last_sprite: u64,
+    /// Sprites drawing missed, put in the atlas next frame.
+    wanted: Vec<u64>,
+}
+
+/// What the game tells the hooks before each call, until the settings move here (spec #14091
+/// step 5a) and the player's emote with them (step 4).
+#[derive(Default)]
+struct Said {
+    mine: bool,
+    listed: bool,
+    /// Other players' cosmetics are shown (not "name tags only", not hidden).
+    others_shown: bool,
+    /// Other players' cosmetics are hidden (not even name tag styles).
+    others_hidden: bool,
+    /// Horizon's mark by Horizon players' names.
+    marks: bool,
+    /// Cosmetics in single player: the signed-in account's on the player's own model.
+    solo: bool,
+    /// My emote pulled the camera back: when it started (the own model's age).
+    pull: Option<f32>,
+    /// My emote while it plays: its id and whether it loops.
+    playing: Option<(String, bool)>,
+    /// A folder's first emote, which mannequins play.
+    first: Option<Arc<Item>>,
+}
+
+/// One [`Seat`] per splitscreen player.
+static SERVICES: Mutex<Vec<Seat>> = Mutex::new(Vec::new());
+
+/// Runs `f` on this seat's [`Seat`]. Never called inside itself.
+fn service<R>(f: impl FnOnce(&mut Seat) -> R) -> R {
+    let seat = horizon_hooks::seat();
+    let mut all = SERVICES.lock().unwrap_or_else(PoisonError::into_inner);
+    if all.len() <= seat {
+        all.resize_with(seat + 1, Seat::default);
+    }
+    f(&mut all[seat])
+}
+
+/// The cosmetics' hooks, registered when [`enabled`].
+pub(super) struct Hooks;
+pub(super) static HOOKS: Hooks = Hooks;
+
+impl horizon_hooks::Hooks for Hooks {
+    fn frame(&self, frame: &Frame, sprites: &mut dyn SpriteStore) {
+        service(|s| {
+            s.solo = frame.solo;
+            s.frame();
+            s.put_sprites(sprites);
+        });
+    }
+
+    fn tick(&self, models: &mut dyn PlayerModels) {
+        service(|s| s.tick(models));
+    }
+
+    fn name_decoration(
+        &self,
+        model: &PlayerModel,
+        sprites: &dyn Sprites,
+    ) -> Option<NameDecoration> {
+        service(|s| s.name_decoration(model, sprites))
+    }
+
+    fn player_mark(&self, uuid: u128) -> Option<Mark> {
+        service(|s| {
+            let client = s.client.as_ref().filter(|_| s.said.marks)?;
+            client.frame().horizon(uuid).then_some(MARK)
+        })
+    }
+
+    /// An emote pulls the camera back: it eases out over the emote's first quarter second.
+    fn camera(&self, own: &CameraView) -> Option<CameraOverride> {
+        let start = service(|s| s.said.pull)?;
+        let t = ((own.age - start) / 5.0).clamp(0.0, 1.0);
+        Some(CameraOverride::new(0.35 + 0.65 * t * t * (3.0 - 2.0 * t)))
+    }
+}
+
+impl Seat {
+    /// Once a frame: starts the service's client on first use, asks whether the account owns a
+    /// cosmetic, and tells the service what the account shows.
+    fn frame(&mut self) {
+        if self.client.is_none() {
+            let (client, local) = Cosmetics::client();
+            self.client = Some(Arc::new(client));
+            self.local = local;
+            // Others' emotes come from the service only (a local folder has no one playing).
+            if !local {
+                self.feed = Some(horizon_cosmetics::Feed::new(http()));
+            }
+        }
+        // Item files from a folder (the art, the bench): shown as to an owner, nothing asked.
+        if self.local {
+            self.owner.owns = true;
+            return;
+        }
+        // Whether the account owns a cosmetic: what the last run learnt, then the service.
+        let o = &mut self.owner;
+        if !o.started {
+            o.started = true;
+            o.owns = account()
+                .is_some_and(|(_, uuid, home)| prefs::owned(&home, &uuid).unwrap_or(false));
+        }
+        if let Some(done) = o.asking.as_ref().and_then(|rx| rx.try_recv().ok()) {
+            o.asking = None;
+            match done {
+                Ok(owns) => (o.owns, o.known, o.retry) = (owns, true, None),
+                Err(_) => o.retry = backoff(o.retry),
+            }
+        }
+        // One sign-in at a time: Mojang keeps one joined server id per account.
+        let due = !o.known && o.retry.is_none_or(|(at, _)| Instant::now() >= at);
+        if due && o.asking.is_none() && self.mine.sending.is_none() && self.listed.sending.is_none()
+        {
+            let (tx, rx) = channel();
+            o.asking = Some(rx);
+            std::thread::Builder::new()
+                .name("Cosmetics account".into())
+                .spawn(move || {
+                    let _ = tx.send(check_owner());
+                })
+                .ok();
+        }
+        // Show my cosmetics: sent once per change of the wish, then retried until confirmed.
+        // Show me as a Horizon player: also said again every hour while on.
+        let every = horizon_cosmetics::account::PRESENCE_EVERY;
+        self.mine.settle(None);
+        self.listed.settle(Some(every));
+        // One sign-in at a time, as for the ownership check above.
+        let busy = self.owner.asking.is_some()
+            || self.mine.sending.is_some()
+            || self.listed.sending.is_some();
+        let said = &self.said;
+        if let Some(done) = self
+            .emote_out
+            .sending
+            .as_ref()
+            .and_then(|rx| rx.try_recv().ok())
+        {
+            self.emote_out.sending = None;
+            match done {
+                Ok(()) => self.emote_out.retry = None,
+                Err(_) => {
+                    self.emote_out.retry = backoff(self.emote_out.retry);
+                    self.emote_out.sent = None;
+                }
+            }
+        }
+        // My emote: only while I show myself as a Horizon player (playing one says so).
+        let playing = said.playing.as_ref();
+        let looping = playing.is_some_and(|(_, looping)| *looping);
+        let wish = playing.map(|(id, _)| id.as_str()).filter(|_| said.listed);
+        let o = &mut self.emote_out;
+        let changed = o.sent.as_ref().map(Option::as_deref) != Some(wish);
+        let again = looping && o.again.is_some_and(|at| Instant::now() >= at);
+        let waited = o.retry.is_none_or(|(at, _)| Instant::now() >= at);
+        // Nothing sent yet and nothing playing: nothing to say (a failed send forgets what
+        // was sent: the service ends a one-shot by itself, a loop within a minute).
+        let quiet = wish.is_none() && o.sent.is_none();
+        let emote_due = !quiet && waited && (changed || again);
+        // One sign-in at a time, the emote's included.
+        if busy || o.sending.is_some() {
+        } else if emote_due {
+            let wish = wish.map(str::to_owned);
+            o.sent = Some(wish.clone());
+            o.again = looping.then(|| Instant::now() + LOOP_AGAIN);
+            let (tx, rx) = channel();
+            o.sending = Some(rx);
+            let kept = o.kept.clone();
+            std::thread::Builder::new()
+                .name("Cosmetics emote".into())
+                .spawn(move || {
+                    let _ = tx.send(send_emote(&kept, wish.as_deref()));
+                })
+                .ok();
+        } else if self.mine.due(said.mine) {
+            self.mine.start(said.mine, send_mine);
+        } else if self.listed.due(said.listed) {
+            self.listed.start(said.listed, send_listed);
+        }
+    }
+
+    /// What goes by `m`'s name: Horizon's mark if they play Horizon (and the mark is on), the
+    /// name tag style they wear if cosmetics are shown for them (name tags only counts), and how
+    /// high what is drawn on their body gets (`body_top`). One look in the cache for all three.
+    fn name_decoration(
+        &mut self,
+        m: &PlayerModel,
+        sprites: &dyn Sprites,
+    ) -> Option<NameDecoration> {
+        let said = &self.said;
+        let own = m.kind == Kind::Own;
+        let styles = if own { said.mine } else { !said.others_hidden };
+        if !(styles || said.marks) {
+            return None;
+        }
+        let uuid = match m.kind {
+            Kind::Own => own_uuid(m.uuid, self.solo, said.solo, || {
+                horizon_client::auth::current().map(|s| s.uuid)
+            }),
+            Kind::Mannequin if self.local => Some(u128::from(m.id)),
+            Kind::Player => m.uuid,
+            _ => None,
+        }?;
+        let mut frame = self.client.as_ref()?.frame();
+        let mark = (said.marks && frame.horizon(uuid)).then_some(MARK);
+        let worn = if styles { frame.worn(uuid) } else { None };
+        drop(frame);
+        let others = if said.others_shown {
+            Others::Shown
+        } else {
+            Others::NameTags
+        };
+        let top = body_top(others, own, worn.as_ref(), |slot| covered(m.gear, slot))
+            .filter(|_| !m.invisible);
+        let badge = worn.and_then(|w| self.badge(&w, sprites));
+        Some(NameDecoration::new(mark, badge, top))
+    }
+
+    /// The name tag style in `worn`: its badge's place in the atlas and its line's colour. None
+    /// until the badge is in the atlas (it is put there next frame).
+    fn badge(&mut self, worn: &horizon_cosmetics::Worn, sprites: &dyn Sprites) -> Option<Badge> {
+        let item = worn.iter().find(|i| i.slot == Slot::NameTag)?;
+        let [r, g, b] = item.tag?.line;
+        let next = self.last_sprite + 1;
+        let (id, _) = *self
+            .sprites
+            .entry(Arc::as_ptr(item) as usize)
+            .or_insert_with(|| (next, item.clone()));
+        self.last_sprite = self.last_sprite.max(id);
+        let Some([u0, v0, u1, v1]) = sprites.get(id) else {
+            if !self.wanted.contains(&id) {
+                self.wanted.push(id);
+            }
+            return None;
+        };
+        // The mark sits in the slot's top left corner.
+        let u1 = u0 + (u1 - u0) * item.texture.width as f32 / 64.0;
+        let v1 = v0 + (v1 - v0) * item.texture.height as f32 / 64.0;
+        Some(Badge::new(
+            [u0, v0, u1, v1],
+            u32::from_be_bytes([0, r, g, b]),
+        ))
+    }
+
+    /// Puts the sprites drawing missed in the atlas; forgets those of items no one wears.
+    fn put_sprites(&mut self, store: &mut dyn SpriteStore) {
+        for id in self.wanted.drain(..) {
+            let item = self.sprites.values().find(|(i, _)| *i == id);
+            if let Some((_, item)) = item.filter(|_| !store.has(id)) {
+                store.put(id, slot_image(item));
+            }
+        }
+        self.sprites
+            .retain(|_, (_, item)| Arc::strong_count(item) > 1);
+    }
+
+    /// Once a tick: names the Horizon players in view to the emote feed and plays what it says
+    /// they play on their models; one that moved ends theirs here at once. Others' emotes show
+    /// with "Other players' cosmetics" on Shown only; otherwise nothing is asked.
+    fn tick(&mut self, models: &mut dyn PlayerModels) {
+        let mut seen = std::mem::take(&mut self.models);
+        seen.clear();
+        models.for_each(&mut |m| {
+            if m.kind != Kind::Own {
+                seen.push(m);
+            }
+        });
+        self.play_others(models, &mut seen);
+        self.models = seen;
+    }
+
+    fn play_others(&self, models: &mut dyn PlayerModels, view: &mut Vec<PlayerModel>) {
+        let shown = self.said.others_shown;
+        // Items from a folder (the art, the bench): every mannequin plays its first emote, again
+        // and again.
+        if self.local && shown {
+            let Some(first) = &self.said.first else {
+                return;
+            };
+            for m in view.iter().filter(|m| m.kind == Kind::Mannequin) {
+                let age = m.age as f32;
+                let now = emotes::pose_playing(models.body_pose(m.id));
+                if now.is_none_or(|p| p.at(age).is_none()) {
+                    let playing = horizon_cosmetics::Playing {
+                        item: first.clone(),
+                        // Out of step, so a crowd doesn't move as one.
+                        start: age - (m.id % 40) as f32,
+                        stop: None,
+                    };
+                    emotes::set_model_playing(models, m.id, Some(playing));
+                }
+            }
+            return;
+        }
+        let (Some(feed), Some(client)) = (&self.feed, &self.client) else {
+            return;
+        };
+        if !shown {
+            feed.ask([]);
+            for m in view.iter() {
+                emotes::set_model_playing(models, m.id, None);
+            }
+            return;
+        }
+        let mut frame = client.frame();
+        view.retain(|m| m.kind == Kind::Player && m.uuid.is_some_and(|u| frame.horizon(u)));
+        drop(frame);
+        feed.ask(view.iter().filter_map(|m| m.uuid));
+        let now = Instant::now();
+        for m in view.iter() {
+            let Some(uuid) = m.uuid else { continue };
+            let seen = feed.playing(uuid);
+            let age = m.age as f32;
+            let mut next = emotes::pose_playing(models.body_pose(m.id)).cloned();
+            match (seen, &mut next) {
+                (Some(seen), Some(p)) if Arc::ptr_eq(&p.item, &seen.item) => {
+                    if m.moved && p.stop.is_none() {
+                        p.stop = Some(age);
+                    }
+                }
+                (Some(seen), slot) if !m.moved => {
+                    let ticks = now.duration_since(seen.started).as_secs_f32() * 20.0;
+                    *slot = Some(horizon_cosmetics::Playing {
+                        item: seen.item,
+                        start: age - ticks,
+                        stop: None,
+                    });
+                }
+                (_, Some(p)) if p.stop.is_none() => p.stop = Some(age),
+                _ => {}
+            }
+            emotes::set_model_playing(models, m.id, next.filter(|p| p.at(age).is_some()));
+        }
+    }
+}
+
 impl Game<'_> {
-    /// Once a frame, before drawing: starts the service's client on first use and puts the
+    /// Hands the hooks what the game's settings and the player's emote say (allocating only when
+    /// the emote changes).
+    pub(super) fn cosmetics_say(&mut self) {
+        if !enabled() {
+            return;
+        }
+        let first = if self.cosmetics.local {
+            service(|s| s.said.first.is_none())
+                .then(|| self.owned_emotes().first().cloned())
+                .flatten()
+        } else {
+            None
+        };
+        let extras = &self.settings.extras;
+        let playing = self.cosmetics.emotes.sending();
+        let pull = self.cosmetics.emotes.pull();
+        service(|s| {
+            let said = &mut s.said;
+            said.mine = extras.cosmetics_mine;
+            said.listed = extras.horizon_listed;
+            said.others_shown = extras.effective_others() == Others::Shown;
+            said.others_hidden = extras.effective_others() == Others::Hidden;
+            said.marks = extras.horizon_marks;
+            said.solo = extras.cosmetics_solo;
+            said.pull = pull;
+            if said.playing.as_ref().map(|(id, l)| (id.as_str(), *l)) != playing {
+                said.playing = playing.map(|(id, l)| (id.to_owned(), l));
+            }
+            if first.is_some() {
+                said.first = first;
+            }
+        });
+    }
+
+    /// Once a frame, after the hooks: takes the service's client for drawing and puts the
     /// textures the last frame wanted into the atlas.
     pub(super) fn cosmetics_frame(&mut self) {
         if !enabled() {
             return;
         }
         let c = &mut self.cosmetics;
-        if c.client.is_none() {
-            let (client, local) = Cosmetics::client();
-            c.client = Some(client);
-            c.local = local;
-            // Others' emotes come from the service only (a local folder has no one playing).
-            if !local {
-                c.feed = Some(horizon_cosmetics::Feed::new(http()));
+        let owns = service(|s| {
+            if c.client.is_none() {
+                c.client = s.client.clone();
+                c.local = s.local;
             }
-        }
+            s.owner.owns
+        });
+        // Read every frame: the settings button shows it, and it is never saved.
+        self.settings.extras.cosmetics_owner = owns;
         c.frame.set(c.frame.get().wrapping_add(1));
         c.fx.get_mut().frame(c.frame.get());
-        // Item files from a folder (the art, the bench): shown as to an owner, nothing asked.
-        if c.local {
-            c.owner.owns = true;
-        } else {
-            // Whether the account owns a cosmetic: what the last run learnt, then the service.
-            let o = &mut c.owner;
-            if !o.started {
-                o.started = true;
-                o.owns = account()
-                    .is_some_and(|(_, uuid, home)| prefs::owned(&home, &uuid).unwrap_or(false));
-            }
-            if let Some(done) = o.asking.as_ref().and_then(|rx| rx.try_recv().ok()) {
-                o.asking = None;
-                match done {
-                    Ok(owns) => (o.owns, o.known, o.retry) = (owns, true, None),
-                    Err(_) => o.retry = backoff(o.retry),
-                }
-            }
-            // One sign-in at a time: Mojang keeps one joined server id per account.
-            let due = !o.known && o.retry.is_none_or(|(at, _)| Instant::now() >= at);
-            if due && o.asking.is_none() && c.mine.sending.is_none() && c.listed.sending.is_none() {
-                let (tx, rx) = channel();
-                o.asking = Some(rx);
-                std::thread::Builder::new()
-                    .name("Cosmetics account".into())
-                    .spawn(move || {
-                        let _ = tx.send(check_owner());
-                    })
-                    .ok();
-            }
-        }
-        // Read every frame: the settings button shows it, and it is never saved.
-        self.settings.extras.cosmetics_owner = c.owner.owns;
-        // Show my cosmetics: sent once per change of the wish, then retried until confirmed.
-        // Show me as a Horizon player: also said again every hour while on.
-        if !c.local {
-            let every = horizon_cosmetics::account::PRESENCE_EVERY;
-            c.mine.settle(None);
-            c.listed.settle(Some(every));
-            // One sign-in at a time, as for the ownership check above.
-            let busy =
-                c.owner.asking.is_some() || c.mine.sending.is_some() || c.listed.sending.is_some();
-            let extras = &self.settings.extras;
-            if let Some(done) = c
-                .emote_out
-                .sending
-                .as_ref()
-                .and_then(|rx| rx.try_recv().ok())
-            {
-                c.emote_out.sending = None;
-                match done {
-                    Ok(()) => c.emote_out.retry = None,
-                    Err(_) => {
-                        c.emote_out.retry = backoff(c.emote_out.retry);
-                        c.emote_out.sent = None;
-                    }
-                }
-            }
-            // My emote: only while I show myself as a Horizon player (playing one says so).
-            let playing = c.emotes.sending();
-            let looping = playing.as_ref().is_some_and(|(_, looping)| *looping);
-            let wish = playing.map(|(id, _)| id).filter(|_| extras.horizon_listed);
-            let o = &mut c.emote_out;
-            let changed = o.sent.as_ref() != Some(&wish);
-            let again = looping && o.again.is_some_and(|at| Instant::now() >= at);
-            let waited = o.retry.is_none_or(|(at, _)| Instant::now() >= at);
-            // Nothing sent yet and nothing playing: nothing to say (a failed send forgets what
-            // was sent: the service ends a one-shot by itself, a loop within a minute).
-            let quiet = wish.is_none() && o.sent.is_none();
-            let emote_due = !quiet && waited && (changed || again);
-            // One sign-in at a time, the emote's included.
-            if busy || o.sending.is_some() {
-            } else if emote_due {
-                o.sent = Some(wish.clone());
-                o.again = looping.then(|| Instant::now() + LOOP_AGAIN);
-                let (tx, rx) = channel();
-                o.sending = Some(rx);
-                let kept = o.kept.clone();
-                std::thread::Builder::new()
-                    .name("Cosmetics emote".into())
-                    .spawn(move || {
-                        let _ = tx.send(send_emote(&kept, wish.as_deref()));
-                    })
-                    .ok();
-            } else if c.mine.due(extras.cosmetics_mine) {
-                c.mine.start(extras.cosmetics_mine, send_mine);
-            } else if c.listed.due(extras.horizon_listed) {
-                c.listed.start(extras.horizon_listed, send_listed);
-            }
-        }
         let uploads = std::mem::take(&mut *c.uploads.borrow_mut());
         for item in uploads {
             let location = format!("cosmetics/{:x}", Arc::as_ptr(&item) as usize);
@@ -572,88 +872,6 @@ impl Game<'_> {
             .retain(|_, b| Arc::strong_count(&b.item) > 1);
     }
 
-    /// Once a tick: names the Horizon players in view to the emote feed and plays what it says
-    /// they play on their models; one that moved ends theirs here at once. Others' emotes show
-    /// with "Other players' cosmetics" on Shown only; otherwise nothing is asked.
-    pub(super) fn tick_others_emotes(&mut self) {
-        let shown = self.settings.extras.effective_others() == Others::Shown;
-        // Items from a folder (the art, the bench): every mannequin plays its first emote, again
-        // and again.
-        if self.cosmetics.local && shown {
-            let Some(first) = self.owned_emotes().first().cloned() else {
-                return;
-            };
-            for m in self.mobs.iter_mut() {
-                let age = m.age as f32;
-                if &*m.kind.id == "minecraft:mannequin"
-                    && emotes::playing(m).is_none_or(|p| p.at(age).is_none())
-                {
-                    let playing = horizon_cosmetics::Playing {
-                        item: first.clone(),
-                        // Out of step, so a crowd doesn't move as one.
-                        start: age - (m.id % 40) as f32,
-                        stop: None,
-                    };
-                    emotes::set_playing(m, Some(playing));
-                }
-            }
-            return;
-        }
-        let (Some(feed), Some(client)) = (&self.cosmetics.feed, &self.cosmetics.client) else {
-            return;
-        };
-        if !shown {
-            feed.ask([]);
-            for m in self.mobs.iter_mut() {
-                emotes::set_playing(m, None);
-            }
-            return;
-        }
-        let mut frame = client.frame();
-        let mut horizon = Vec::new();
-        for m in self.mobs.iter() {
-            if &*m.kind.id == "minecraft:player"
-                && let Some(uuid) = self.remote_player_uuid(m.id)
-                && frame.horizon(uuid)
-            {
-                horizon.push((m.id, uuid));
-            }
-        }
-        drop(frame);
-        feed.ask(horizon.iter().map(|(_, u)| *u));
-        let now = Instant::now();
-        for (id, uuid) in horizon {
-            let seen = feed.playing(uuid);
-            let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) else {
-                continue;
-            };
-            let age = m.age as f32;
-            let moved = {
-                let (dx, dz) = (m.position.x - m.previous.x, m.position.z - m.previous.z);
-                dx * dx + dz * dz > 1e-4
-            };
-            let mut next = emotes::playing(m).cloned();
-            match (seen, &mut next) {
-                (Some(seen), Some(p)) if Arc::ptr_eq(&p.item, &seen.item) => {
-                    if moved && p.stop.is_none() {
-                        p.stop = Some(age);
-                    }
-                }
-                (Some(seen), slot) if !moved => {
-                    let ticks = now.duration_since(seen.started).as_secs_f32() * 20.0;
-                    *slot = Some(horizon_cosmetics::Playing {
-                        item: seen.item,
-                        start: age - ticks,
-                        stop: None,
-                    });
-                }
-                (_, Some(p)) if p.stop.is_none() => p.stop = Some(age),
-                _ => {}
-            }
-            emotes::set_playing(m, next.filter(|p| p.at(age).is_some()));
-        }
-    }
-
     /// Asks the service which emotes the account owns, for the wheel: when it opens, at most
     /// every 10 minutes (a folder's emotes need no asking; an offline account has none).
     pub(super) fn refresh_owned_emotes(&mut self) {
@@ -669,7 +887,7 @@ impl Game<'_> {
         }
         let (tx, rx) = channel();
         e.loading = Some(rx);
-        let kept = self.cosmetics.emote_out.kept.clone();
+        let kept = service(|s| s.emote_out.kept.clone());
         std::thread::Builder::new()
             .name("Cosmetics emotes owned".into())
             .spawn(move || {
@@ -678,81 +896,6 @@ impl Game<'_> {
             .ok();
     }
 
-    /// Items from a folder (`HORIZON_COSMETICS_LOCAL`): mannequins are dressed and marked too.
-    pub(super) fn cosmetics_local(&self) -> bool {
-        self.cosmetics.local
-    }
-
-    /// What goes by `m`'s name: Horizon's mark if they play Horizon (and the mark is on), the
-    /// name tag style they wear if cosmetics are shown for them (name tags only counts), and how
-    /// high what is drawn on their body gets (`body_top`). One look in the cache for all three.
-    pub(super) fn cosmetics_marks(&self, m: &Mob, own: bool) -> super::names::Marks {
-        let mut marks = super::names::Marks::default();
-        let extras = &self.settings.extras;
-        let styles = if own {
-            extras.cosmetics_mine
-        } else {
-            extras.effective_others() != Others::Hidden
-        };
-        if !(styles || extras.horizon_marks) {
-            return marks;
-        }
-        let (Some(client), Some(uuid)) = (&self.cosmetics.client, self.cosmetics_uuid(m, own))
-        else {
-            return marks;
-        };
-        let mut frame = client.frame();
-        marks.horizon = extras.horizon_marks && frame.horizon(uuid);
-        let worn = if styles { frame.worn(uuid) } else { None };
-        drop(frame);
-        if !horizon_client::mobs::trader::is_invisible(m) {
-            marks.top = body_top(extras, own, worn.as_ref(), |slot| covered(m, slot));
-        }
-        marks.style = worn.and_then(|w| self.cosmetics_tag(&w));
-        marks
-    }
-
-    /// Those of `uuids` who play Horizon, with the mark on (the player list): one look each.
-    pub(super) fn horizon_players(
-        &self,
-        uuids: impl Iterator<Item = u128>,
-    ) -> std::collections::HashSet<u128> {
-        match &self.cosmetics.client {
-            Some(c) if self.settings.extras.horizon_marks => {
-                let mut frame = c.frame();
-                uuids.filter(|u| frame.horizon(*u)).collect()
-            }
-            _ => Default::default(),
-        }
-    }
-
-    /// The name tag style in `worn`: its badge's place in the atlas and its line's colour. None
-    /// until the badge is in the atlas.
-    fn cosmetics_tag(&self, worn: &horizon_cosmetics::Worn) -> Option<super::names::TagStyle> {
-        let item = worn.iter().find(|i| i.slot == Slot::NameTag)?;
-        let [r, g, b] = item.tag?.line;
-        let frame = self.cosmetics.frame.get();
-        let mut baked = self.cosmetics.baked.borrow_mut();
-        let entry = baked
-            .entry(Arc::as_ptr(item) as usize)
-            .or_insert_with(|| Baked::new(item, frame));
-        let Some(slot) = self.gui.atlas.sprites.get(&entry.location) else {
-            self.cosmetics.uploads.borrow_mut().push(item.clone());
-            return None;
-        };
-        if entry.marked.replace(frame) != frame {
-            self.skin_downloads.borrow_mut().drawn(&entry.location);
-        }
-        // The mark sits in the slot's top left corner.
-        let mut mark = *slot;
-        mark.u1 = mark.u0 + (slot.u1 - slot.u0) * item.texture.width as f32 / 64.0;
-        mark.v1 = mark.v0 + (slot.v1 - slot.v0) * item.texture.height as f32 / 64.0;
-        Some(super::names::TagStyle {
-            mark,
-            line: u32::from_be_bytes([0, r, g, b]),
-        })
-    }
-
     /// What `m` wears, if cosmetics are shown for it: `own` for the player's own model.
     fn worn(&self, m: &Mob, own: bool) -> Option<horizon_cosmetics::Worn> {
         let client = self.cosmetics.client.as_ref()?;
@@ -844,7 +987,7 @@ impl Game<'_> {
                 }
                 continue;
             }
-            if emoting.is_none() && covered(m, item.slot) {
+            if emoting.is_none() && covered(super::player_hooks::gear(m), item.slot) {
                 continue;
             }
             let Some((models, uv)) = self.cosmetics_baked(item) else {
@@ -962,7 +1105,7 @@ impl Game<'_> {
 mod tests {
     use super::*;
     use horizon_client::extras::Extras;
-    use std::sync::Mutex;
+    use horizon_client::mobs::anim::BodyPose;
 
     /// A name tag style with a 1×1 mark.
     const TAG: &str = r##"{"format": 1, "id": "tag", "slot": "name_tag", "parts": [],
@@ -1150,13 +1293,18 @@ mod tests {
         let (short, long) = (Duration::from_millis(300), Duration::from_secs(10));
         let top_of = |extras: &Extras, patience| {
             let (worn, _) = other_player_from(Service(Arc::default(), both), extras, patience);
-            body_top(extras, false, worn.as_ref(), |_| false)
+            body_top(extras.effective_others(), false, worn.as_ref(), |_| false)
         };
         // No cosmetics drawn on the body (a name tag style only): vanilla's height exactly.
         let (worn, _) = other_player(&shown, long);
         assert!(worn.is_some());
         assert_eq!(
-            tag(body_top(&shown, false, worn.as_ref(), |_| false)),
+            tag(body_top(
+                shown.effective_others(),
+                false,
+                worn.as_ref(),
+                |_| false
+            )),
             VANILLA
         );
         // A small hat under the tag: vanilla's height too.
@@ -1170,7 +1318,9 @@ mod tests {
         );
         // A helmet over it: vanilla's height.
         let (worn, _) = other_player_from(Service(Arc::default(), both), &shown, long);
-        let helmet = body_top(&shown, false, worn.as_ref(), |slot| slot == Slot::Head);
+        let helmet = body_top(shown.effective_others(), false, worn.as_ref(), |slot| {
+            slot == Slot::Head
+        });
         assert_eq!(tag(helmet), VANILLA);
         // Others' cosmetics on name tags only, or hidden: nothing on the body, vanilla's height.
         for others in [Others::NameTags, Others::Hidden] {
@@ -1186,4 +1336,66 @@ mod tests {
             assert_eq!(tag(top_of(&extras, patience)), VANILLA, "{others:?}");
         }
     }
+
+    /// Player models as the hooks see them, with the pose laid over each.
+    struct View(Vec<(PlayerModel, Option<Arc<dyn BodyPose>>)>);
+
+    impl PlayerModels for View {
+        fn connection(&self) -> u64 {
+            1
+        }
+        fn for_each(&self, f: &mut dyn FnMut(PlayerModel)) {
+            self.0.iter().for_each(|(m, _)| f(*m));
+        }
+        fn body_pose(&self, id: u32) -> Option<&Arc<dyn BodyPose>> {
+            self.0.iter().find(|(m, _)| m.id == id)?.1.as_ref()
+        }
+        fn set_body_pose(&mut self, id: u32, pose: Option<Arc<dyn BodyPose>>) {
+            if let Some((_, p)) = self.0.iter_mut().find(|(m, _)| m.id == id) {
+                *p = pose;
+            }
+        }
+    }
+
+    #[test]
+    fn with_a_folder_mannequins_play_its_first_emote_out_of_step_and_players_do_not() {
+        let item = Arc::new(
+            Item::parse(
+                br#"{"format": 1, "id": "up", "slot": "emote", "parts": [],
+                    "emote": {"length": 20, "blend": 0, "tracks": [
+                      {"part": "right_arm", "keys": [{"t": 10, "rotation": [0, 0, 90]}]}]}}"#,
+            )
+            .unwrap(),
+        );
+        let mut service = Seat {
+            local: true,
+            said: Said {
+                others_shown: true,
+                first: Some(item.clone()),
+                ..Said::default()
+            },
+            ..Seat::default()
+        };
+        let model = |id, kind, uuid| (PlayerModel::new(id, kind, uuid, 50, false), None);
+        let mut view = View(vec![
+            model(1, Kind::Own, None),
+            model(41, Kind::Mannequin, None),
+            model(2, Kind::Player, Some(7)),
+        ]);
+        service.tick(&mut view);
+        let playing = emotes::pose_playing(view.0[1].1.as_ref()).expect("the mannequin plays");
+        assert!(Arc::ptr_eq(&playing.item, &item));
+        // Out of step by its id: 50 - 41 % 40.
+        assert_eq!(playing.start, 49.0);
+        assert!(view.0[0].1.is_none() && view.0[2].1.is_none());
+        // Still playing: the same pose stays.
+        let first = view.0[1].1.clone().unwrap();
+        service.tick(&mut view);
+        assert!(Arc::ptr_eq(&first, view.0[1].1.as_ref().unwrap()));
+        // Others' cosmetics not shown: a new mannequin plays nothing.
+        service.said.others_shown = false;
+        view.0.push(model(3, Kind::Mannequin, None));
+        service.tick(&mut view);
+        assert!(view.0[3].1.is_none());
+    }
 }

crates/horizon-client/src/game/cosmetics/emotes.rs

@@ -10,6 +10,7 @@ use horizon_client::mobs::Mob;
 use horizon_client::mobs::anim::BodyPose;
 use horizon_cosmetics::account::OwnedEmote;
 use horizon_cosmetics::{Item, Playing, Slot};
+use horizon_hooks::players::PlayerModels;
 use std::sync::Arc;
 
 /// How far the player may drift (blocks) before the emote stops: a nudge, not a step.
@@ -37,10 +38,15 @@ pub(in crate::game) struct Emotes {
 
 impl Emotes {
     /// The emote to tell the service about, while it plays: its id and whether it loops.
-    pub(in crate::game) fn sending(&self) -> Option<(String, bool)> {
+    pub(in crate::game) fn sending(&self) -> Option<(&str, bool)> {
         let p = self.playing.as_ref().filter(|p| p.stop.is_none())?;
         let looping = p.item.emote.as_ref().is_some_and(|e| e.looping);
-        Some((p.item.id.clone(), looping))
+        Some((&p.item.id, looping))
+    }
+
+    /// When the emote that pulled the camera back started (the own model's age), while it plays.
+    pub(in crate::game) fn pull(&self) -> Option<f32> {
+        self.camera_from.and(self.playing.as_ref()).map(|p| p.start)
     }
 }
 
@@ -59,23 +65,48 @@ impl BodyPose for EmotePose {
     }
 }
 
-/// The emote `m` plays, if any.
-pub(in crate::game) fn playing(m: &Mob) -> Option<&Playing> {
-    let any: &dyn std::any::Any = &**m.emote.as_ref()?;
+/// The emote a model's pose plays, if it is one.
+pub(in crate::game) fn pose_playing(pose: Option<&Arc<dyn BodyPose>>) -> Option<&Playing> {
+    let any: &dyn std::any::Any = &**pose?;
     any.downcast_ref::<EmotePose>().map(|e| &e.0)
 }
 
-/// Makes `m` play `next`, unless it plays that already (a new one allocates).
-pub(in crate::game) fn set_playing(m: &mut Mob, next: Option<Playing>) {
-    let same = match (playing(m), &next) {
+/// The emote `m` plays, if any.
+pub(in crate::game) fn playing(m: &Mob) -> Option<&Playing> {
+    pose_playing(m.emote.as_ref())
+}
+
+/// The pose that plays `next` where `now` is laid, unless it plays that already (None: keep
+/// it; a new one allocates).
+fn replaced(
+    now: Option<&Arc<dyn BodyPose>>,
+    next: Option<Playing>,
+) -> Option<Option<Arc<dyn BodyPose>>> {
+    let same = match (pose_playing(now), &next) {
         (None, None) => true,
         (Some(a), Some(b)) => {
             Arc::ptr_eq(&a.item, &b.item) && a.start == b.start && a.stop == b.stop
         }
         _ => false,
     };
-    if !same {
-        m.emote = next.map(|p| Arc::new(EmotePose(p)) as Arc<dyn BodyPose>);
+    (!same).then(|| next.map(|p| Arc::new(EmotePose(p)) as Arc<dyn BodyPose>))
+}
+
+/// Makes `m` play `next`, unless it plays that already.
+pub(in crate::game) fn set_playing(m: &mut Mob, next: Option<Playing>) {
+    if let Some(pose) = replaced(m.emote.as_ref(), next) {
+        m.emote = pose;
+    }
+}
+
+/// Makes model `id` play `next`, unless it plays that already.
+pub(in crate::game) fn set_model_playing(
+    models: &mut dyn PlayerModels,
+    id: u32,
+    next: Option<Playing>,
+) {
+    if let Some(pose) = replaced(models.body_pose(id), next) {
+        models.set_body_pose(id, pose);
     }
 }
 
@@ -229,7 +260,7 @@ impl Game<'_> {
         }
     }
 
-    /// Once a tick: my emote, then the other players'.
+    /// Once a tick: my emote (the others' are `cosmetics::Seat::tick`'s, a hook's).
     pub(in crate::game) fn tick_emotes(&mut self) {
         if let Some(done) = self
             .cosmetics
@@ -250,20 +281,6 @@ impl Game<'_> {
             }
         }
         self.tick_emote();
-        self.tick_others_emotes();
-    }
-
-    /// How far the camera stands back while an emote pulls it (1: the usual distance): it eases
-    /// out over the emote's first quarter second.
-    pub(in crate::game) fn emote_camera_pull(&self, partial: f32) -> f32 {
-        let (Some(p), Some(m)) = (&self.cosmetics.emotes.playing, &self.player_model) else {
-            return 1.0;
-        };
-        if self.cosmetics.emotes.camera_from.is_none() {
-            return 1.0;
-        }
-        let t = ((m.age as f32 + partial - p.start) / 5.0).clamp(0.0, 1.0);
-        0.35 + 0.65 * t * t * (3.0 - 2.0 * t)
     }
 }
 

crates/horizon-client/src/game/creatures/mob_geometry.rs

@@ -280,25 +280,18 @@ impl Game<'_> {
                 self.spin_attack_geometry(mob, camera, alpha as f32, packed, out);
                 self.stuck_in_body_geometry(mob, mob.id as i32, camera, alpha as f32, packed, out);
             }
-            // Cosmetics (game/cosmetics.rs), posed on the GPU with the mob's own jobs: culled
-            // with it.
+            // What crates draw on players and mannequins (`game/player_hooks.rs`: cosmetics),
+            // posed on the GPU with the mob's own jobs: culled with it.
             if !layers_only
-                && super::super::cosmetics::enabled()
+                && horizon_hooks::engine::any()
                 && (is_player || &*mob.kind.id == "minecraft:mannequin")
             {
                 let mark = self.skin_frame.borrow().mark();
                 let base = horizon_client::mobs::render::base_transform(mob, alpha as f32, camera);
                 let gpu = skinning;
-                if let Some((lo, hi)) = self.cosmetics_geometry(
-                    mob,
-                    false,
-                    base,
-                    Some(camera),
-                    alpha as f32,
-                    packed,
-                    gpu,
-                    out,
-                ) {
+                if let Some((lo, hi)) =
+                    self.player_layers_geometry(mob, base, camera, alpha as f32, packed, gpu, out)
+                {
                     skinned = Some(match skinned {
                         Some((first, Some((l, h)))) => (first, Some((l.min(lo), h.max(hi)))),
                         Some((first, None)) => (first, Some((lo, hi))),

crates/horizon-client/src/game/dedicated/report.rs

@@ -58,7 +58,7 @@ impl Recording {
         Self {
             seconds,
             started: Instant::now(),
-            cpu_s: horizon_system::cpu_seconds(std::process::id()),
+            cpu_s: horizon_bench::cpu_seconds(std::process::id()),
             spans_were_on,
             ticks: Vec::with_capacity(seconds as usize * 20),
             sampled_ticks: 0,
@@ -363,7 +363,7 @@ impl Game<'_> {
         let costs = tick_profile::take();
         let mob_samples = costs.iter().map(|c| c.mob_ticks).sum();
         let jobs = job_stats::take();
-        let cpu = horizon_system::cpu_seconds(std::process::id())
+        let cpu = horizon_bench::cpu_seconds(std::process::id())
             .zip(r.cpu_s)
             .map(|(end, start)| round((end - start) / window_s.max(1e-9)));
         let players = self.lan.as_ref().map_or(0, |h| h.hub.guests.len());
@@ -382,7 +382,7 @@ impl Game<'_> {
             "overhead": overhead(&r, mob_samples, span_ns, mob_ns),
             "players": players,
             "levels": self.report_levels(),
-            "memory": { "rss_mb": horizon_system::rss_bytes(std::process::id()).map(|b| b >> 20) },
+            "memory": { "rss_mb": horizon_bench::rss_bytes(std::process::id()).map(|b| b >> 20) },
             "process": process_limits(),
             "cpu_cores_used": cpu,
             "config": {
@@ -395,12 +395,9 @@ impl Game<'_> {
         // The machine's description runs commands: off the tick.
         std::thread::spawn(move || {
             let mut report = report;
+            let hw = horizon_bench::Hardware::detect();
             report["machine"] = json!({
-                "os": std::env::consts::OS,
-                "arch": std::env::consts::ARCH,
-                "cpu": horizon_system::cpu(),
-                "cpu_threads": std::thread::available_parallelism().ok().map(|n| n.get()),
-                "ram_mb": horizon_system::ram_bytes().map(|b| b >> 20),
+                "os": hw.os, "arch": hw.arch, "cpu": hw.cpu, "cpu_threads": hw.cpu_threads, "ram_mb": hw.ram_mb,
             });
             match write_report(Path::new("reports"), &report, &text) {
                 Ok(path) => log::info!(

crates/horizon-client/src/game/lan.rs

@@ -1820,7 +1820,7 @@ impl Game<'_> {
             // from carries those, as `save_guest` gives them on leaving. The map
             // stays their one owner.
             let live = self.guest_attachments.get(&uuid).cloned();
-            let g = playerdata::with_warden(&mut host.hub.guests[i], self.warden_tracker_tag());
+            let g = &mut host.hub.guests[i];
             let held = live.map(|a| std::mem::replace(&mut g.attachments, a));
             playerdata::store(g, &mut self.level, vehicle);
             if let Some(held) = held {

crates/horizon-client/src/game/launch_options.rs

@@ -324,7 +324,7 @@ impl Options {
                             "--player-dir" => {}
                             "--dev-mod" => o.dev_mods.push(std::path::absolute(&value)?),
                             "--benchmark" => {
-                                if !horizon_hooks::engine::knows_benchmark(&value) {
+                                if horizon_client::benchmark::scenes(&value).is_none() {
                                     return Err(format!(
                                     "unknown benchmark {value}: standard, village, forest, ocean or mountain"
                                 )

crates/horizon-client/src/game/loading_screen.rs

@@ -123,7 +123,7 @@ impl Loading {
         };
         horizon_client::window::settle_created_fullscreen(&window, fullscreen);
         drop(window_step);
-        horizon_client::play_session::note_display(&window);
+        horizon_client::telemetry::note_display(&window);
         // The renderer takes seconds to build and winit's window sits white
         // until the first frame presents, so paint the boot screen on it and
         // keep repainting it as the console's lines arrive; the wgpu frames

crates/horizon-client/src/game/loading_window.rs

@@ -314,31 +314,27 @@ pub(super) fn start_game<'a>(
     game.preload_registries();
     game.start_agent_control()?;
     if let Some(scenario) = game.options.benchmark.clone() {
-        // A part above the engine runs it (docs/benchmark.md), driving the game through the
-        // command queue horizon-ctl uses.
-        let requests = game
+        let control = game
             .control
-            .get_or_insert_with(horizon_client::control::Server::local)
-            .sender();
-        let control: horizon_hooks::Control = Box::new(move |line, wait| {
-            let (reply, response) = std::sync::mpsc::channel();
-            let line = line.to_owned();
-            requests
-                .send(horizon_client::control::Request { line, reply })
-                .ok()?;
-            response.recv_timeout(wait).ok()
-        });
-        let run = horizon_hooks::Benchmark {
-            scenario: &scenario,
-            started,
-            home: &horizon_client::logging::game_home(),
-            game_dir: &std::env::current_dir()?,
-            version: &horizon_client::crash::version(),
-            build: &horizon_client::crash::build(),
-            simulation_distance: game.settings.simulation_distance as u32,
-            offscreen: game.options.offscreen,
-        };
-        horizon_hooks::engine::benchmark(&run, control);
+            .get_or_insert_with(horizon_client::control::Server::local);
+        horizon_client::benchmark::start(
+            control.sender(),
+            horizon_client::benchmark::Setup {
+                scenario,
+                started,
+                app: horizon_bench::App {
+                    name: "horizon-client".into(),
+                    version: horizon_client::crash::version(),
+                    commit: option_env!("HORIZON_COMMIT").map(str::to_owned),
+                    mods: Vec::new(),
+                },
+                simulation_distance: game.settings.simulation_distance as u32,
+                vsync: false,
+                fps_cap: None,
+                offscreen: game.options.offscreen,
+                game_dir: std::env::current_dir()?,
+            },
+        );
     }
     if let Some(directory) = std::env::var_os("HORIZON_NATIVE_CLIENT_PARTICLES_FIXTURE") {
         game.run_native_client_particles_fixture(std::path::Path::new(&directory))?;

crates/horizon-client/src/game/menu_clicks.rs

@@ -899,32 +899,4 @@ impl Game<'_> {
             f.input_clicked(world_recipes!(self), before);
         }
     }
-
-    /// `AbstractContainerScreen` keeps `isQuickCrafting` and the drag it
-    /// belongs to on the screen. Horizon keeps both on `Game` (`inv_clicks`,
-    /// `inv_drag`, `last_inv_click`), so they are dropped when the pointer
-    /// changes hands: a screen that opens or closes starts with its own
-    /// state, and a press whose release never reached the screen -- the
-    /// pointer left the window, or the screen closed first -- would
-    /// otherwise leave every later press on every later screen swallowed.
-    pub(super) fn reset_inventory_clicks(&mut self) {
-        self.inv_clicks.cancel_drag();
-        self.inv_drag = None;
-        self.last_inv_click = None;
-    }
-
-    /// A sound a menu click made the player play (a bundle's insert or
-    /// remove): `Entity.playSound` at the player.
-    pub(super) fn player_menu_sound(&mut self, sound: &str) {
-        let Some(p) = self.player.as_ref() else {
-            return;
-        };
-        let at = [p.position.x, p.position.y, p.position.z];
-        let (volume, pitch) = if sound == horizon_client::bundle::INSERT_FAIL {
-            (1.0, 1.0)
-        } else {
-            (0.8, 0.8 + self.world.random.next_float() * 0.4)
-        };
-        self.audio.play(sound, Some(at), volume, pitch);
-    }
 }

crates/horizon-client/src/game/minecarts.rs

@@ -28,10 +28,6 @@ use horizon_core::{
 };
 use horizon_world::registry::BlockStateId;
 use std::{collections::HashMap, sync::Arc};
-mod index;
-mod nbt;
-pub(super) use index::CartIndex;
-use index::cart_at;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub(super) enum CartKind {
@@ -191,6 +187,102 @@ pub(super) const TNT_PRIME_EVENT: i8 = 70;
 mod display;
 use display::{cart_render_bounds, display_offset, shown_unless_air};
 pub(super) use display::{default_display_offset, forget_unreadable_display};
+/// The carts' and mobs' boxes for one tick's cart pushes (`push_from_cart`,
+/// `pickup_from_cart`), so a cart reads its neighbours instead of every cart and
+/// every mob of the level. Both answer in slot order, as the scans did.
+///
+/// The cart grid follows each ticked cart ([`CartIndex::moved`]); it is
+/// rebuilt once the list's length changed (a cart gone or added), and dropped
+/// after a command, which can move or replace any cart
+/// ([`CartIndex::forget_carts`]). The mob grid holds until the mob
+/// list's next write ([`ListStamp`]). A native mod's hook can move either kind
+/// unseen, so with mods loaded both scans stay.
+#[derive(Default)]
+pub(super) struct CartIndex {
+    carts: Option<(SeenGrid, Vec<u32>)>,
+    /// The grid, and the carts a mob rides.
+    mobs: Option<(ListStamp, SeenGrid, FxHashSet<u32>)>,
+    near: Vec<u32>,
+}
+impl CartIndex {
+    fn usable() -> bool {
+        horizon_client::mod_api::mods().is_empty()
+    }
+    /// The cart in slot `i` has these bounds now.
+    fn moved(&mut self, i: usize, bounds: Aabb) {
+        if let Some((grid, ids)) = &mut self.carts
+            && i < ids.len()
+        {
+            grid.update(i, bounds);
+        }
+    }
+    fn forget_carts(&mut self) {
+        self.carts = None;
+    }
+    /// The slots of the carts whose box may meet `area`, for the cart in slot
+    /// `i` (just moved); false: scan them all.
+    fn carts_near(&mut self, carts: &[Minecart], i: usize, area: Aabb, out: &mut Vec<u32>) -> bool {
+        if !Self::usable() {
+            return false;
+        }
+        let fresh = |ids: &[u32]| ids.len() == carts.len() && ids[i] == carts[i].id;
+        if !self.carts.as_ref().is_some_and(|(_, ids)| fresh(ids)) {
+            self.carts = Some((
+                SeenGrid::new(carts.iter().map(Minecart::bounds)),
+                carts.iter().map(|c| c.id).collect(),
+            ));
+        }
+        let Some((grid, ids)) = &mut self.carts else {
+            return false;
+        };
+        grid.update(i, carts[i].bounds());
+        if !grid.candidates(area, out) {
+            return false;
+        }
+        if out.iter().any(|&j| ids[j as usize] != carts[j as usize].id) {
+            // A cart was replaced in place: start over next time.
+            self.carts = None;
+            return false;
+        }
+        true
+    }
+    /// The slots of the mobs whose box may meet `area` into `out`, and
+    /// whether a mob rides cart `cart`; None: scan them all.
+    fn mobs_near(
+        &mut self,
+        mobs: &JoinList<Mob>,
+        cart: u32,
+        area: Aabb,
+        out: &mut Vec<u32>,
+    ) -> Option<bool> {
+        if !Self::usable() {
+            return None;
+        }
+        if !self
+            .mobs
+            .as_ref()
+            .is_some_and(|(stamp, ..)| *stamp == mobs.stamp())
+        {
+            self.mobs = Some((
+                mobs.stamp(),
+                SeenGrid::new(mobs.iter().map(Mob::bounds)),
+                mobs.iter().filter_map(|m| m.extra.mount).collect(),
+            ));
+        }
+        let (_, grid, mounted) = self.mobs.as_ref()?;
+        grid.candidates(area, out).then(|| mounted.contains(&cart))
+    }
+}
+/// Where the cart `id` is in `carts`: at `hint` (where it was a moment ago,
+/// the usual case while carts tick in order) or found by a scan. A world
+/// with hundreds of mineshaft chest carts asked this of every cart several
+/// times a tick.
+fn cart_at(carts: &[Minecart], id: u32, hint: usize) -> Option<usize> {
+    if carts.get(hint).is_some_and(|c| c.id == id) {
+        return Some(hint);
+    }
+    carts.iter().position(|c| c.id == id)
+}
 /// `AbstractMinecart.push(entity)` for a non-cart `entity` at `feet`:
 /// the push the cart loses (the entity gets a quarter of it back).
 pub(super) fn cart_push_from(feet: Vec3, cart: Vec3) -> Option<(f64, f64)> {
@@ -2892,6 +2984,177 @@ impl Game<'_> {
             .render_state(&scene, state.0, m, light, out);
     }
 }
+/// Saving and loading.
+impl Minecart {
+    pub fn to_nbt(
+        &self,
+        uuid: [i32; 4],
+        raw: Option<&horizon_world::nbt::Tag>,
+    ) -> horizon_world::nbt::Tag {
+        use horizon_world::nbt::{JavaString, Tag};
+        let mut tag = horizon_client::entity_nbt::vehicle_to_nbt(
+            self.kind.id(),
+            self.position,
+            self.velocity,
+            [self.yaw, self.pitch],
+            (self.on_ground, self.fall_distance),
+            uuid,
+            raw,
+        );
+        horizon_client::entity_nbt::write_saved_flags(&mut tag, self.on_ground, self.no_gravity);
+        if let Tag::Compound(map) = &mut tag {
+            // ContainerEntity.addChestVehicleSaveData belongs only to the
+            // container subclasses, never to a plain or specialized cart.
+            if self.kind.slots() == 0 {
+                map.remove(&JavaString::from("Items"));
+            }
+            if self.kind == CartKind::CommandBlock {
+                for key in ["LastOutput", "LastExecution"] {
+                    map.remove(&JavaString::from(key));
+                }
+            }
+            map.remove(&JavaString::from("DisplayOffset"));
+            map.remove(&JavaString::from("DisplayState"));
+            let mut put = |k: &str, v: Tag| {
+                map.insert(JavaString::from(k), v);
+            };
+            put("FlippedRotation", Tag::Byte(i8::from(self.flipped)));
+            // AbstractMinecart saves firstTick as HasTicked. A cart never burns:
+            // Entity.move sets -getFireImmuneTicks(), 0 for all but players.
+            put("HasTicked", Tag::Byte(i8::from(self.first_tick)));
+            put("Fire", Tag::Short(0));
+            // addAdditionalSaveData: the offset only off its default, the state only when set.
+            if let Some(offset) = self.custom_offset
+                && f64::from(offset) != default_display_offset(self.kind)
+            {
+                put("DisplayOffset", Tag::Int(offset));
+            }
+            if let Some(state) = &self.custom_display {
+                put("DisplayState", state.clone());
+            }
+            match self.kind {
+                CartKind::Chest | CartKind::Hopper => {
+                    put("Items", horizon_client::save::encode_items(&self.items));
+                    if self.kind == CartKind::Hopper {
+                        put("Enabled", Tag::Byte(i8::from(self.enabled)));
+                    }
+                }
+                CartKind::Furnace => {
+                    put("PushX", Tag::Double(self.push.x.to_bits()));
+                    put("PushZ", Tag::Double(self.push.z.to_bits()));
+                    put("Fuel", Tag::Short(self.fuel as i16));
+                }
+                CartKind::Tnt => put("fuse", Tag::Int(self.fuse)),
+                // BaseCommandBlock.save (its CustomName shares the entity's key).
+                CartKind::CommandBlock => {
+                    for (key, value) in self.command.save() {
+                        if !matches!(key, "CustomName" | "powered" | "conditionMet" | "auto") {
+                            put(key, value);
+                        }
+                    }
+                }
+                // BaseSpawner.save: the delays, ranges, SpawnData and SpawnPotentials.
+                CartKind::Spawner => {
+                    if let Some(spawner) = &self.spawner {
+                        for (key, value) in
+                            horizon_client::mobs::spawner::SpawnerExt::save(&**spawner)
+                        {
+                            put(key, value);
+                        }
+                    }
+                }
+                CartKind::Rideable => {}
+            }
+            // A loaded loot table goes back while the items are still its roll;
+            // otherwise the items replace it, as vanilla's unpackLootTable does.
+            if self.loot.as_ref().is_some_and(|l| l.restore(map)) {
+                if let Some(table) = horizon_client::save::text(map.get(&"LootTable".into()))
+                    .and_then(|id| horizon_client_core::identifier::normalize_id(&id))
+                {
+                    map.insert("LootTable".into(), Tag::String(table.as_str().into()));
+                }
+            } else {
+                map.remove(&JavaString::from("LootTable"));
+                map.remove(&JavaString::from("LootTableSeed"));
+            }
+        }
+        tag
+    }
+    pub fn from_nbt(tag: &horizon_world::nbt::Tag, id: u32, kind: CartKind) -> Option<Self> {
+        let (position, _, _) = horizon_client::entity_nbt::boat_from_nbt(tag)?;
+        let mut c = Self::new(id, kind, position);
+        c.load(tag)?;
+        Some(c)
+    }
+    /// `Entity.load` on this cart: the saved fields are read over the live
+    /// ones, the rest (riders, lerp, hurt state) stays; its kind never changes.
+    /// `None`, with nothing changed, when the compound has no position.
+    pub fn load(&mut self, tag: &horizon_world::nbt::Tag) -> Option<()> {
+        use horizon_world::nbt::Tag;
+        let (position, velocity, yaw) = horizon_client::entity_nbt::boat_from_nbt(tag)?;
+        let kind = self.kind;
+        let c = self;
+        c.position = position;
+        c.previous = position;
+        c.velocity = velocity;
+        c.yaw = yaw;
+        c.previous_yaw = yaw;
+        c.no_gravity = horizon_client::entity_nbt::flag(tag, "NoGravity");
+        c.on_ground = horizon_client::entity_nbt::flag(tag, "OnGround");
+        c.pitch = horizon_client::entity_nbt::rotation(tag)[1];
+        c.previous_pitch = c.pitch;
+        // ValueInput's numeric getters take any NumericTag: getIntOr is its
+        // intValue, getShortOr the low 16 bits of it, getBooleanOr
+        // `byteValue() != 0` (the low 8), getDoubleOr its doubleValue.
+        let int = |k: &str| {
+            tag.get(k)
+                .and_then(horizon_client_core::nbt_path::int_value)
+        };
+        let flag = |k: &str, default: bool| int(k).map_or(default, |v| v as i8 != 0);
+        let double = |k: &str| match tag.get(k) {
+            Some(Tag::Byte(v)) => f64::from(*v),
+            Some(Tag::Short(v)) => f64::from(*v),
+            Some(Tag::Int(v)) => f64::from(*v),
+            Some(Tag::Long(v)) => *v as f64,
+            Some(Tag::Float(v)) => f64::from(f32::from_bits(*v)),
+            Some(Tag::Double(v)) => f64::from_bits(*v),
+            _ => 0.0,
+        };
+        // Entity.load: OnGround and fall_distance, as saved.
+        (c.on_ground, c.fall_distance) = horizon_client::entity_nbt::ground_from_nbt(tag);
+        c.flipped = flag("FlippedRotation", false);
+        c.first_tick = flag("HasTicked", false);
+        if kind.slots() > 0 {
+            c.items = horizon_client::save::decode_items(tag.get("Items"), kind.slots());
+        }
+        c.enabled = flag("Enabled", true);
+        c.fuel = int("Fuel").map_or(0, |v| i32::from(v as i16));
+        // readAdditionalSaveData: the saved push has no y.
+        c.push = Vec3::new(double("PushX"), 0.0, double("PushZ"));
+        c.fuse = int("fuse").unwrap_or(-1);
+        // readAdditionalSaveData: DisplayState, DisplayOffset (default offset when absent).
+        c.custom_display = tag.get("DisplayState").cloned();
+        c.custom_offset = int("DisplayOffset");
+        if kind == CartKind::CommandBlock {
+            c.command = horizon_client::command_block::CommandBlock::load(tag);
+            // MinecartCommandBlock.readAdditionalSaveData sets the synched command.
+            // A changed value invokes onSyncedDataUpdated -> setCommand, resetting successes.
+            if c.synced_command != c.command.command {
+                c.synced_command.clone_from(&c.command.command);
+                c.command.set_command(&c.synced_command);
+            }
+            c.synced_output = c.command.last_output_string();
+        }
+        // MinecartSpawner.readAdditionalSaveData: BaseSpawner.load.
+        if kind == CartKind::Spawner {
+            c.spawner = Some(Box::new(horizon_client::mobs::spawner::SpawnerExt::load(
+                tag,
+            )));
+        }
+        Some(())
+    }
+}
+
 /// `VehicleEntity.hurtServer`'s destroy test: a creative player, damage past
 /// 40, or (`MinecartTNT.shouldSourceDestroy`) fire or an explosion hitting a
 /// TNT cart.

crates/horizon-client/src/game/minecarts/index.rs

@@ -1,105 +0,0 @@
-//! The carts' and mobs' boxes for a tick's cart pushes ([`CartIndex`]).
-use super::*;
-
-/// The carts' and mobs' boxes for one tick's cart pushes (`push_from_cart`,
-/// `pickup_from_cart`), so a cart reads its neighbours instead of every cart and
-/// every mob of the level. Both answer in slot order, as the scans did.
-///
-/// The cart grid follows each ticked cart ([`CartIndex::moved`]); it is
-/// rebuilt once the list's length changed (a cart gone or added), and dropped
-/// after a command, which can move or replace any cart
-/// ([`CartIndex::forget_carts`]). The mob grid holds until the mob
-/// list's next write ([`ListStamp`]). A native mod's hook can move either kind
-/// unseen, so with mods loaded both scans stay.
-#[derive(Default)]
-pub(in crate::game) struct CartIndex {
-    pub(super) carts: Option<(SeenGrid, Vec<u32>)>,
-    /// The grid, and the carts a mob rides.
-    pub(super) mobs: Option<(ListStamp, SeenGrid, FxHashSet<u32>)>,
-    pub(super) near: Vec<u32>,
-}
-impl CartIndex {
-    pub(super) fn usable() -> bool {
-        horizon_client::mod_api::mods().is_empty()
-    }
-    /// The cart in slot `i` has these bounds now.
-    pub(super) fn moved(&mut self, i: usize, bounds: Aabb) {
-        if let Some((grid, ids)) = &mut self.carts
-            && i < ids.len()
-        {
-            grid.update(i, bounds);
-        }
-    }
-    pub(super) fn forget_carts(&mut self) {
-        self.carts = None;
-    }
-    /// The slots of the carts whose box may meet `area`, for the cart in slot
-    /// `i` (just moved); false: scan them all.
-    pub(super) fn carts_near(
-        &mut self,
-        carts: &[Minecart],
-        i: usize,
-        area: Aabb,
-        out: &mut Vec<u32>,
-    ) -> bool {
-        if !Self::usable() {
-            return false;
-        }
-        let fresh = |ids: &[u32]| ids.len() == carts.len() && ids[i] == carts[i].id;
-        if !self.carts.as_ref().is_some_and(|(_, ids)| fresh(ids)) {
-            self.carts = Some((
-                SeenGrid::new(carts.iter().map(Minecart::bounds)),
-                carts.iter().map(|c| c.id).collect(),
-            ));
-        }
-        let Some((grid, ids)) = &mut self.carts else {
-            return false;
-        };
-        grid.update(i, carts[i].bounds());
-        if !grid.candidates(area, out) {
-            return false;
-        }
-        if out.iter().any(|&j| ids[j as usize] != carts[j as usize].id) {
-            // A cart was replaced in place: start over next time.
-            self.carts = None;
-            return false;
-        }
-        true
-    }
-    /// The slots of the mobs whose box may meet `area` into `out`, and
-    /// whether a mob rides cart `cart`; None: scan them all.
-    pub(super) fn mobs_near(
-        &mut self,
-        mobs: &JoinList<Mob>,
-        cart: u32,
-        area: Aabb,
-        out: &mut Vec<u32>,
-    ) -> Option<bool> {
-        if !Self::usable() {
-            return None;
-        }
-        if !self
-            .mobs
-            .as_ref()
-            .is_some_and(|(stamp, ..)| *stamp == mobs.stamp())
-        {
-            self.mobs = Some((
-                mobs.stamp(),
-                SeenGrid::new(mobs.iter().map(Mob::bounds)),
-                mobs.iter().filter_map(|m| m.extra.mount).collect(),
-            ));
-        }
-        let (_, grid, mounted) = self.mobs.as_ref()?;
-        grid.candidates(area, out).then(|| mounted.contains(&cart))
-    }
-}
-/// Where the cart `id` is in `carts`: at `hint` (where it was a moment ago,
-/// the usual case while carts tick in order) or found by a scan. A world
-/// with hundreds of mineshaft chest carts asked this of every cart several
-/// times a tick.
-pub(super) fn cart_at(carts: &[Minecart], id: u32, hint: usize) -> Option<usize> {
-    if carts.get(hint).is_some_and(|c| c.id == id) {
-        return Some(hint);
-    }
-    carts.iter().position(|c| c.id == id)
-}

crates/horizon-client/src/game/minecarts/nbt.rs

@@ -1,173 +0,0 @@
-//! Saving and loading a minecart.
-use super::*;
-
-/// Saving and loading.
-impl Minecart {
-    pub fn to_nbt(
-        &self,
-        uuid: [i32; 4],
-        raw: Option<&horizon_world::nbt::Tag>,
-    ) -> horizon_world::nbt::Tag {
-        use horizon_world::nbt::{JavaString, Tag};
-        let mut tag = horizon_client::entity_nbt::vehicle_to_nbt(
-            self.kind.id(),
-            self.position,
-            self.velocity,
-            [self.yaw, self.pitch],
-            (self.on_ground, self.fall_distance),
-            uuid,
-            raw,
-        );
-        horizon_client::entity_nbt::write_saved_flags(&mut tag, self.on_ground, self.no_gravity);
-        if let Tag::Compound(map) = &mut tag {
-            // ContainerEntity.addChestVehicleSaveData belongs only to the
-            // container subclasses, never to a plain or specialized cart.
-            if self.kind.slots() == 0 {
-                map.remove(&JavaString::from("Items"));
-            }
-            if self.kind == CartKind::CommandBlock {
-                for key in ["LastOutput", "LastExecution"] {
-                    map.remove(&JavaString::from(key));
-                }
-            }
-            map.remove(&JavaString::from("DisplayOffset"));
-            map.remove(&JavaString::from("DisplayState"));
-            let mut put = |k: &str, v: Tag| {
-                map.insert(JavaString::from(k), v);
-            };
-            put("FlippedRotation", Tag::Byte(i8::from(self.flipped)));
-            // AbstractMinecart saves firstTick as HasTicked. A cart never burns:
-            // Entity.move sets -getFireImmuneTicks(), 0 for all but players.
-            put("HasTicked", Tag::Byte(i8::from(self.first_tick)));
-            put("Fire", Tag::Short(0));
-            // addAdditionalSaveData: the offset only off its default, the state only when set.
-            if let Some(offset) = self.custom_offset
-                && f64::from(offset) != default_display_offset(self.kind)
-            {
-                put("DisplayOffset", Tag::Int(offset));
-            }
-            if let Some(state) = &self.custom_display {
-                put("DisplayState", state.clone());
-            }
-            match self.kind {
-                CartKind::Chest | CartKind::Hopper => {
-                    put("Items", horizon_client::save::encode_items(&self.items));
-                    if self.kind == CartKind::Hopper {
-                        put("Enabled", Tag::Byte(i8::from(self.enabled)));
-                    }
-                }
-                CartKind::Furnace => {
-                    put("PushX", Tag::Double(self.push.x.to_bits()));
-                    put("PushZ", Tag::Double(self.push.z.to_bits()));
-                    put("Fuel", Tag::Short(self.fuel as i16));
-                }
-                CartKind::Tnt => put("fuse", Tag::Int(self.fuse)),
-                // BaseCommandBlock.save (its CustomName shares the entity's key).
-                CartKind::CommandBlock => {
-                    for (key, value) in self.command.save() {
-                        if !matches!(key, "CustomName" | "powered" | "conditionMet" | "auto") {
-                            put(key, value);
-                        }
-                    }
-                }
-                // BaseSpawner.save: the delays, ranges, SpawnData and SpawnPotentials.
-                CartKind::Spawner => {
-                    if let Some(spawner) = &self.spawner {
-                        for (key, value) in
-                            horizon_client::mobs::spawner::SpawnerExt::save(&**spawner)
-                        {
-                            put(key, value);
-                        }
-                    }
-                }
-                CartKind::Rideable => {}
-            }
-            // A loaded loot table goes back while the items are still its roll;
-            // otherwise the items replace it, as vanilla's unpackLootTable does.
-            if self.loot.as_ref().is_some_and(|l| l.restore(map)) {
-                if let Some(table) = horizon_client::save::text(map.get(&"LootTable".into()))
-                    .and_then(|id| horizon_client_core::identifier::normalize_id(&id))
-                {
-                    map.insert("LootTable".into(), Tag::String(table.as_str().into()));
-                }
-            } else {
-                map.remove(&JavaString::from("LootTable"));
-                map.remove(&JavaString::from("LootTableSeed"));
-            }
-        }
-        tag
-    }
-    pub fn from_nbt(tag: &horizon_world::nbt::Tag, id: u32, kind: CartKind) -> Option<Self> {
-        let (position, _, _) = horizon_client::entity_nbt::boat_from_nbt(tag)?;
-        let mut c = Self::new(id, kind, position);
-        c.load(tag)?;
-        Some(c)
-    }
-    /// `Entity.load` on this cart: the saved fields are read over the live
-    /// ones, the rest (riders, lerp, hurt state) stays; its kind never changes.
-    /// `None`, with nothing changed, when the compound has no position.
-    pub fn load(&mut self, tag: &horizon_world::nbt::Tag) -> Option<()> {
-        use horizon_world::nbt::Tag;
-        let (position, velocity, yaw) = horizon_client::entity_nbt::boat_from_nbt(tag)?;
-        let kind = self.kind;
-        let c = self;
-        c.position = position;
-        c.previous = position;
-        c.velocity = velocity;
-        c.yaw = yaw;
-        c.previous_yaw = yaw;
-        c.no_gravity = horizon_client::entity_nbt::flag(tag, "NoGravity");
-        c.on_ground = horizon_client::entity_nbt::flag(tag, "OnGround");
-        c.pitch = horizon_client::entity_nbt::rotation(tag)[1];
-        c.previous_pitch = c.pitch;
-        // ValueInput's numeric getters take any NumericTag: getIntOr is its
-        // intValue, getShortOr the low 16 bits of it, getBooleanOr
-        // `byteValue() != 0` (the low 8), getDoubleOr its doubleValue.
-        let int = |k: &str| {
-            tag.get(k)
-                .and_then(horizon_client_core::nbt_path::int_value)
-        };
-        let flag = |k: &str, default: bool| int(k).map_or(default, |v| v as i8 != 0);
-        let double = |k: &str| match tag.get(k) {
-            Some(Tag::Byte(v)) => f64::from(*v),
-            Some(Tag::Short(v)) => f64::from(*v),
-            Some(Tag::Int(v)) => f64::from(*v),
-            Some(Tag::Long(v)) => *v as f64,
-            Some(Tag::Float(v)) => f64::from(f32::from_bits(*v)),
-            Some(Tag::Double(v)) => f64::from_bits(*v),
-            _ => 0.0,
-        };
-        // Entity.load: OnGround and fall_distance, as saved.
-        (c.on_ground, c.fall_distance) = horizon_client::entity_nbt::ground_from_nbt(tag);
-        c.flipped = flag("FlippedRotation", false);
-        c.first_tick = flag("HasTicked", false);
-        if kind.slots() > 0 {
-            c.items = horizon_client::save::decode_items(tag.get("Items"), kind.slots());
-        }
-        c.enabled = flag("Enabled", true);
-        c.fuel = int("Fuel").map_or(0, |v| i32::from(v as i16));
-        // readAdditionalSaveData: the saved push has no y.
-        c.push = Vec3::new(double("PushX"), 0.0, double("PushZ"));
-        c.fuse = int("fuse").unwrap_or(-1);
-        // readAdditionalSaveData: DisplayState, DisplayOffset (default offset when absent).
-        c.custom_display = tag.get("DisplayState").cloned();
-        c.custom_offset = int("DisplayOffset");
-        if kind == CartKind::CommandBlock {
-            c.command = horizon_client::command_block::CommandBlock::load(tag);
-            // MinecartCommandBlock.readAdditionalSaveData sets the synched command.
-            // A changed value invokes onSyncedDataUpdated -> setCommand, resetting successes.
-            if c.synced_command != c.command.command {
-                c.synced_command.clone_from(&c.command.command);
-                c.command.set_command(&c.synced_command);
-            }
-            c.synced_output = c.command.last_output_string();
-        }
-        // MinecartSpawner.readAdditionalSaveData: BaseSpawner.load.
-        if kind == CartKind::Spawner {
-            c.spawner = Some(Box::new(horizon_client::mobs::spawner::SpawnerExt::load(
-                tag,
-            )));
-        }
-        Some(())
-    }
-}

crates/horizon-client/src/game/names.rs

@@ -300,11 +300,7 @@ impl Game<'_> {
             ) {
                 continue;
             }
-            let marks = if player || self.cosmetics_local() {
-                self.cosmetics_marks(m, Some(m.id) == own)
-            } else {
-                Marks::default()
-            };
+            let marks = self.hooks_name_marks(m, Some(m.id) == own);
             let at = match marks.top {
                 Some(top) => p + glam::DVec3::Y * cosmetic_lift(top, m.model_scale()),
                 None => p,
@@ -770,10 +766,10 @@ impl Game<'_> {
                     if background { BACKGROUND } else { 0 },
                 ),
             };
-            if n == last && marks.horizon {
+            if let Some(mark) = marks.mark.filter(|_| n == last) {
                 let x = -self.gui.atlas.font.width_text(text) / 2.0 - 10.0;
                 // 8 text pixels square, a pixel left of the background.
-                for &(mx, my, w, h, argb) in super::cosmetics::MARK {
+                for &(mx, my, w, h, argb) in mark {
                     let a = text_alpha * (argb >> 24) / 255;
                     batch.fill(
                         &self.gui.atlas,
@@ -937,10 +933,11 @@ struct NameTag {
     marks: Marks,
 }
 
-/// What Horizon draws by a player's name: its mark (they play Horizon) and their name tag style.
+/// What a hook draws by a player's name (`horizon_hooks::players::NameDecoration`): a mark
+/// before it (Horizon's: they play Horizon) and a name tag style.
 #[derive(Clone, Copy, Default)]
 pub(super) struct Marks {
-    pub horizon: bool,
+    pub mark: Option<horizon_hooks::players::Mark>,
     pub style: Option<TagStyle>,
     /// How high the cosmetics drawn on their body get above the neck, in model pixels: the tag
     /// goes up over a tall one (`cosmetic_lift`).

crates/horizon-client/src/game/perspective.rs

@@ -311,8 +311,8 @@ impl Game<'_> {
             }
         };
         let mut view = self.view;
-        // An emote pulls the camera back from the player's face (`game/cosmetics/emotes.rs`).
-        let pull = self.emote_camera_pull(partial);
+        // A hook may pull the camera back (an emote, from the player's face).
+        let pull = self.hooks_camera_distance(partial);
         let kind = match self.camera_type {
             CameraType::FirstPerson => horizon_client::camera::CameraType::FirstPerson,
             CameraType::ThirdPersonBack => horizon_client::camera::CameraType::ThirdPersonBack,

crates/horizon-client/src/game/player_hooks.rs

@@ -0,0 +1,448 @@
+//! Where the game hands the player models to crates above the engine (`horizon_hooks::Hooks`'s
+//! `frame`, `tick`, `name_decoration`, `player_mark`, `camera`; spec #14091): only a window's
+//! game calls them, never the integrated server's thread or a dedicated server. With no hook
+//! registered nothing is built.
+
+use super::Game;
+use horizon_client::fast_hash::FxHashMap;
+use horizon_client::join_seq::JoinList;
+use horizon_client::mesher::Vertex;
+use horizon_client::mobs::anim::{self, BodyPose, PooledPoses, Poses};
+use horizon_client::mobs::{Mob, Part, Polygon, render};
+use horizon_hooks::engine;
+use horizon_hooks::players::{
+    Bone, CameraView, Frame, Gear, Kind, Mesh, PartPoses, Pass, PlayerDraw, PlayerModel,
+    PlayerModels, SpriteStore, Sprites,
+};
+use std::sync::Arc;
+
+/// Registers the hooks of the Horizon parts still in this crate (cosmetics: spec #14091 step 5
+/// moves them out). Before the hooks are sealed.
+pub(crate) fn register() {
+    if super::cosmetics::enabled()
+        && let Err(e) = horizon_hooks::register(&super::cosmetics::HOOKS)
+    {
+        log::error!("Cosmetics: their hooks came too late: {e}");
+    }
+}
+
+/// The models of the world a window shows: its own first, then the other players and mannequins.
+struct Models<'a> {
+    own: Option<&'a mut Mob>,
+    mobs: &'a mut JoinList<Mob>,
+    remote: &'a super::remote::Remote,
+}
+
+impl Models<'_> {
+    fn find(&mut self, id: u32) -> Option<&mut Mob> {
+        match self.own.as_deref_mut() {
+            Some(m) if m.id == id => Some(m),
+            _ => self
+                .mobs
+                .iter_mut()
+                .find(|m| m.id == id && kind(m).is_some()),
+        }
+    }
+}
+
+/// What kind of player model `m` is, if it is one (the window's own model aside).
+fn kind(m: &Mob) -> Option<Kind> {
+    match &*m.kind.id {
+        "minecraft:player" => Some(Kind::Player),
+        "minecraft:mannequin" => Some(Kind::Mannequin),
+        _ => None,
+    }
+}
+
+/// What `m` wears where a crate may draw: a helmet or head item, a chestplate, a cape or elytra.
+pub(super) fn gear(m: &Mob) -> Gear {
+    let elytra = m.extra.chest.as_deref() == Some("minecraft:elytra");
+    Gear::new(
+        m.extra.head.is_some(),
+        m.extra.chest.is_some() && !elytra,
+        m.cape.is_some() || elytra,
+    )
+}
+
+fn model(m: &Mob, kind: Kind, uuid: Option<u128>) -> PlayerModel {
+    let (dx, dz) = (m.position.x - m.previous.x, m.position.z - m.previous.z);
+    PlayerModel::new(m.id, kind, uuid, m.age, dx * dx + dz * dz > 1e-4)
+        .looks(gear(m), horizon_client::mobs::trader::is_invisible(m))
+}
+
+impl PlayerModels for Models<'_> {
+    fn connection(&self) -> u64 {
+        self.remote.session.serial()
+    }
+
+    fn for_each(&self, f: &mut dyn FnMut(PlayerModel)) {
+        if let Some(m) = self.own.as_deref() {
+            f(model(m, Kind::Own, Some(self.remote.profile())));
+        }
+        for m in self.mobs.iter() {
+            if let Some(kind) = kind(m) {
+                let uuid = (kind == Kind::Player)
+                    .then(|| self.remote.player_uuid(m.id))
+                    .flatten();
+                f(model(m, kind, uuid));
+            }
+        }
+    }
+
+    fn body_pose(&self, id: u32) -> Option<&Arc<dyn BodyPose>> {
+        match self.own.as_deref() {
+            Some(m) if m.id == id => m.emote.as_ref(),
+            _ => self
+                .mobs
+                .iter()
+                .find(|m| m.id == id && kind(m).is_some())?
+                .emote
+                .as_ref(),
+        }
+    }
+
+    fn set_body_pose(&mut self, id: u32, pose: Option<Arc<dyn BodyPose>>) {
+        if let Some(m) = self.find(id) {
+            m.emote = pose;
+        }
+    }
+}
+
+/// Sprite `id`'s place in the atlas's names (`hooks/<hex>`), written into `buf`: no allocation.
+fn location(id: u64, buf: &mut [u8; 22]) -> &str {
+    use std::io::Write;
+    let mut out = std::io::Cursor::new(&mut buf[..]);
+    let _ = write!(out, "hooks/{id:x}");
+    let len = out.position() as usize;
+    std::str::from_utf8(&buf[..len]).unwrap_or_default()
+}
+
+/// The crates' sprites in the GUI atlas, in the skin slots: read while drawing.
+struct HookSprites<'a, 'g>(&'a Game<'g>);
+
+impl Sprites for HookSprites<'_, '_> {
+    fn get(&self, id: u64) -> Option<[f32; 4]> {
+        let mut buf = [0; 22];
+        let at = location(id, &mut buf);
+        let r = self.0.gui.atlas.sprites.get(at)?;
+        // Kept this frame (`skin_slots.next_frame`).
+        self.0.skin_downloads.borrow_mut().drawn(at);
+        Some([r.u0, r.v0, r.u1, r.v1])
+    }
+}
+
+/// Where a crate's frame hook puts its sprites.
+struct HookStore<'a, 'g>(&'a mut Game<'g>);
+
+impl SpriteStore for HookStore<'_, '_> {
+    fn has(&self, id: u64) -> bool {
+        self.0
+            .gui
+            .atlas
+            .sprites
+            .contains_key(location(id, &mut [0; 22]))
+    }
+
+    fn put(&mut self, id: u64, rgba: Vec<u8>) {
+        let at = location(id, &mut [0; 22]).to_owned();
+        self.0.store_skin(at, rgba);
+    }
+}
+
+thread_local! {
+    /// The crates' meshes as the renderer takes them, by the mesh's address (each entry holds its
+    /// mesh, so the address isn't reused); render thread only.
+    static MESHES: std::cell::RefCell<FxHashMap<usize, (Arc<Mesh>, Arc<Part>)>> =
+        Default::default();
+}
+
+/// The game's model of `mesh`, made once.
+fn part_of(mesh: &Arc<Mesh>) -> Arc<Part> {
+    fn part(m: &Mesh) -> Part {
+        Part {
+            name: m.name.clone(),
+            pose: m.pose,
+            polygons: m
+                .quads
+                .iter()
+                .map(|q| Polygon {
+                    normal: q.normal,
+                    vertices: q.vertices,
+                    cull_back: false,
+                })
+                .collect(),
+            children: m.children.iter().map(part).collect(),
+        }
+    }
+    MESHES.with_borrow_mut(|meshes| {
+        let (_, part_of) = meshes
+            .entry(Arc::as_ptr(mesh) as usize)
+            .or_insert_with(|| (mesh.clone(), Arc::new(part(mesh))));
+        part_of.clone()
+    })
+}
+
+/// Forgets the meshes no crate holds any more (once a frame).
+fn forget_meshes() {
+    let _ = MESHES.try_with(|m| {
+        m.borrow_mut()
+            .retain(|_, (mesh, _)| Arc::strong_count(mesh) > 1)
+    });
+}
+
+/// `Poses` as a crate poses a mesh's parts.
+struct PosesOf<'a>(&'a mut Poses);
+
+impl PartPoses for PosesOf<'_> {
+    fn pose(&mut self, name: &str) -> &mut [f32; 9] {
+        self.0.get(name)
+    }
+}
+
+/// A player model drawn in the world pass, as a crate draws on it: posed on the GPU's skin path
+/// when `gpu` (the mob pass's skin frame, begun; the bounds of what went there grow, for
+/// culling), else its vertices go to `out`.
+struct DrawPlayer<'a, 'g> {
+    game: &'a Game<'g>,
+    m: &'a Mob,
+    pass: Pass,
+    /// The model's matrix (`render::base_transform`).
+    base: glam::Mat4,
+    alpha: f32,
+    light: u32,
+    gpu: bool,
+    out: &'a mut Vec<Vertex>,
+    bounds: Option<(glam::Vec3, glam::Vec3)>,
+    /// The body as it is drawn, posed on the first `bone`.
+    body: Option<PooledPoses>,
+    poses: PooledPoses,
+}
+
+impl DrawPlayer<'_, '_> {
+    fn body(&self) -> &Part {
+        let (key, _) = render::body(self.m);
+        self.m.kind.layer(&key).unwrap_or(&self.m.kind.model)
+    }
+}
+
+impl PlayerDraw for DrawPlayer<'_, '_> {
+    fn pass(&self) -> Pass {
+        self.pass
+    }
+
+    fn ticks(&self) -> f32 {
+        self.m.age as f32 + self.alpha
+    }
+
+    fn bone(&mut self, bone: Bone) -> Option<[[f32; 4]; 4]> {
+        if self.body.is_none() {
+            let mut poses = Poses::pooled();
+            poses.reset(self.body());
+            let data = self.game.res.mob_data();
+            let state = anim::state(self.m, self.alpha);
+            anim::setup(self.m, &state, &mut poses, &data.animations);
+            self.body = Some(poses);
+        }
+        let poses = self.body.as_ref()?;
+        let at = render::part_matrix(self.body(), self.base, poses, bone.part(), 0.0)?;
+        Some(at.to_cols_array_2d())
+    }
+
+    fn body_pose(&self) -> Option<&Arc<dyn BodyPose>> {
+        self.m.emote.as_ref()
+    }
+
+    fn sprite(&self, id: u64) -> Option<[f32; 4]> {
+        HookSprites(self.game).get(id)
+    }
+
+    fn draw(
+        &mut self,
+        mesh: &Arc<Mesh>,
+        matrix: [[f32; 4]; 4],
+        uv: [f32; 4],
+        pose: &mut dyn FnMut(&mut dyn PartPoses),
+    ) {
+        let model = part_of(mesh);
+        let matrix = glam::Mat4::from_cols_array_2d(&matrix);
+        self.poses.reset(&model);
+        pose(&mut PosesOf(&mut self.poses));
+        if self.gpu {
+            let mut models = self.game.skin_models.borrow_mut();
+            let mut frame = self.game.skin_frame.borrow_mut();
+            let mut skin = horizon_client::mobs::skin::Skin::new(&mut models, &mut frame);
+            skin.bounds = self.bounds;
+            let paint = horizon_client::mobs::skin::Paint {
+                uv,
+                scroll: 0.0,
+                color: 0xFFFF_FFFF,
+                light: self.light,
+                overlay: 0,
+            };
+            if skin.draw(&model, matrix, &self.poses, paint) {
+                self.bounds = skin.bounds;
+                return;
+            }
+        }
+        let poses = &self.poses;
+        horizon_client::mobs::render_model(
+            &model,
+            matrix,
+            &|p: &Part| poses.pose(p),
+            uv,
+            self.light,
+            0,
+            self.out,
+        );
+    }
+}
+
+impl Game<'_> {
+    /// What crates draw on player model `m` in the world pass (`creatures.rs`), then the
+    /// cosmetics still drawn here: see [`DrawPlayer`]. The bounds of what went to the GPU.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn player_layers_geometry(
+        &self,
+        m: &Mob,
+        base: glam::Mat4,
+        camera: glam::DVec3,
+        alpha: f32,
+        light: u32,
+        gpu: bool,
+        out: &mut Vec<Vertex>,
+    ) -> Option<(glam::Vec3, glam::Vec3)> {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let kind = kind(m)?;
+        let mut bounds = None;
+        if engine::any() {
+            let model = model(m, kind, self.remote_player_uuid(m.id));
+            let mut draw = DrawPlayer {
+                game: self,
+                m,
+                pass: Pass::World,
+                base,
+                alpha,
+                light,
+                gpu,
+                out: &mut *out,
+                bounds: None,
+                body: None,
+                poses: Poses::pooled(),
+            };
+            engine::player_layers(&model, &mut draw);
+            bounds = draw.bounds;
+        }
+        let worn = super::cosmetics::enabled()
+            .then(|| self.cosmetics_geometry(m, false, base, Some(camera), alpha, light, gpu, out))
+            .flatten();
+        match (bounds, worn) {
+            (Some((l, h)), Some((lo, hi))) => Some((l.min(lo), h.max(hi))),
+            (b, w) => b.or(w),
+        }
+    }
+
+    /// Once a frame, before drawing.
+    pub(super) fn client_hooks_frame(&mut self) {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        if !engine::any() {
+            return;
+        }
+        self.cosmetics_say();
+        let connection = self.remote.as_ref().map_or(0, |r| r.session.serial());
+        let frame = Frame::new(connection, self.integrated.is_some());
+        engine::frame(&frame, &mut HookStore(self));
+        forget_meshes();
+        self.cosmetics_frame();
+    }
+
+    /// Once a client tick in a world: the player's own emote, then the hooks.
+    pub(super) fn client_hooks_tick(&mut self) {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        self.tick_emotes();
+        if !engine::any() {
+            return;
+        }
+        self.cosmetics_say();
+        let Some(remote) = self.remote.as_ref() else {
+            return;
+        };
+        engine::tick(&mut Models {
+            own: self.player_model.as_mut(),
+            mobs: &mut self.mobs,
+            remote,
+        });
+    }
+
+    /// What goes by `m`'s name (`own`: the window's own player), from the hooks.
+    pub(super) fn hooks_name_marks(&self, m: &Mob, own: bool) -> super::names::Marks {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let mut marks = super::names::Marks::default();
+        if !engine::any() {
+            return marks;
+        }
+        let model = match (own, kind(m)) {
+            (true, _) => model(m, Kind::Own, self.remote.as_ref().map(|r| r.profile())),
+            (false, Some(kind)) => model(m, kind, self.remote_player_uuid(m.id)),
+            (false, None) => return marks,
+        };
+        if let Some(d) = engine::name_decoration(&model, &HookSprites(self)) {
+            marks.mark = d.mark;
+            marks.top = d.top;
+            marks.style = d.badge.map(|b| {
+                let [u0, v0, u1, v1] = b.uv;
+                super::names::TagStyle {
+                    mark: horizon_client::hud::Rect {
+                        u0,
+                        v0,
+                        u1,
+                        v1,
+                        w: 8,
+                        h: 8,
+                    },
+                    line: b.line,
+                }
+            });
+        }
+        marks
+    }
+
+    /// How far the third-person camera stands back, as a share of the usual distance: a hook's
+    /// (an emote pulls it back), else 1.
+    pub(super) fn hooks_camera_distance(&self, partial: f32) -> f32 {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        match &self.player_model {
+            Some(m) if engine::any() => {
+                engine::camera(&CameraView::new(m.age as f32 + partial)).map_or(1.0, |c| c.distance)
+            }
+            _ => 1.0,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sprite_locations_fit_the_buffer_and_differ_by_id() {
+        let mut a = [0; 22];
+        let mut b = [0; 22];
+        assert_eq!(location(u64::MAX, &mut a), "hooks/ffffffffffffffff");
+        assert_eq!(location(10, &mut b), "hooks/a");
+    }
+}

crates/horizon-client/src/game/remote.rs

@@ -6731,7 +6731,7 @@ impl Game<'_> {
         if self.studio_replay.is_none() {
             self.tick_player_model();
         }
-        self.tick_emotes();
+        self.client_hooks_tick();
         if !dead {
             self.remote_tick_using();
         }
@@ -10714,17 +10714,11 @@ impl Game<'_> {
     /// The profile name of another player the server sent, by entity id.
     /// The UUID of another player's entity in the level.
     pub(super) fn remote_player_uuid(&self, id: u32) -> Option<u128> {
-        let r = self.remote.as_ref()?;
-        let uuid = *r.level_players.get(&(id as i32))?;
-        (uuid != r.profile).then_some(uuid)
+        self.remote.as_ref()?.player_uuid(id)
     }
     pub(super) fn remote_player_name(&self, id: u32) -> Option<&str> {
         let r = self.remote.as_ref()?;
-        let uuid = r.level_players.get(&(id as i32))?;
-        if *uuid == r.profile {
-            return None;
-        }
-        r.level_player_name(id as i32, uuid)
+        r.level_player_name(id as i32, &r.player_uuid(id)?)
     }
     /// Status for `horizon-ctl status`.
     /// The other players' entities in the level and their names (their
@@ -11505,6 +11499,11 @@ impl Remote {
     pub(super) fn profile(&self) -> u128 {
         self.profile
     }
+    /// Another player's profile UUID, by their entity id (None for the local player).
+    pub(super) fn player_uuid(&self, id: u32) -> Option<u128> {
+        let uuid = *self.level_players.get(&(id as i32))?;
+        (uuid != self.profile).then_some(uuid)
+    }
     /// The entity id of a player in the level, by profile UUID.
     pub(super) fn player_entity(&self, uuid: u128) -> Option<u32> {
         self.level_players

crates/horizon-client/src/game/resource_load.rs

@@ -487,7 +487,7 @@ pub(super) fn load_resources(
     };
     let resources = Arc::new(resources);
     if menu {
-        horizon_client::play_session::core_ready();
+        horizon_client::telemetry::mark_core_ready();
         log::info!(
             "Horizon: core-ready after {} ms",
             started.elapsed().as_millis()
@@ -526,7 +526,7 @@ pub(super) fn load_resources(
                     .set(rest)
                     .map_err(|_| "world resources already loaded".to_owned())?;
                 progress.set(9);
-                horizon_client::play_session::rest_ready();
+                horizon_client::telemetry::mark_rest_ready();
                 log::info!(
                     "Horizon: rest-ready after {} ms",
                     started.elapsed().as_millis()

crates/horizon-client/src/game/resource_tables.rs

@@ -292,8 +292,10 @@ fn pack_particles(
 }
 
 /// The packs' custom colours; their dye and sheep colours go to the draw paths' table.
-fn read_colors(root: &std::path::Path) -> horizon_client::pack_palette::PackColors {
-    let colors = horizon_client::pack_palette::read(root);
-    horizon_client::brewing::set_pack_colors(colors.effects.clone());
+fn read_colors(root: &std::path::Path) -> horizon_client::polytone_colors::PackColors {
+    let colors = horizon_client::polytone_colors::PackColors::read(root);
+    horizon_client::pack_palette::set(&colors);
+    horizon_client::pack_palette::set_item_bars(root);
+    horizon_client::brewing::set_pack_colors(colors.effects());
     colors
 }

crates/horizon-client/src/game/scoreboard.rs

@@ -823,7 +823,7 @@ impl Game<'_> {
         for (location, rgba) in ready {
             self.store_skin(location, rgba);
         }
-        self.cosmetics_frame();
+        self.client_hooks_frame();
     }
     /// `Hud.extractTabList`: the player list while the player-list key is
     /// held. A local world shows it with a joined LAN guest or a `list`
@@ -900,10 +900,12 @@ impl Game<'_> {
         let board = &self.score.board;
         let objective = board.display_objective(sb::SLOT_LIST);
         let up = |id: u128| upside_down.contains(&id);
-        // Horizon's mark before the names of Horizon players (the cosmetics service's cache).
-        let horizon = self.horizon_players(players.iter().map(|p| p.uuid));
-        let horizon_mark = super::cosmetics::MARK;
-        let marked = |id: u128| horizon.contains(&id).then_some(horizon_mark);
+        // A hook's mark before a name (Horizon's: they play Horizon).
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let marked = horizon_hooks::engine::player_mark;
         let inputs = TabInputs {
             players: &players,
             board,

crates/horizon-client/src/game/sculk.rs

@@ -359,19 +359,12 @@ impl Game<'_> {
             self.sculk.tracker = WardenSpawnTracker::from_nbt(tag);
         }
     }
-    /// The tracker as saved, once it has been loaded.
-    pub(super) fn warden_tracker_tag(&self) -> Option<horizon_world::nbt::Tag> {
-        self.sculk
-            .tracker_loaded
-            .then(|| self.sculk.tracker.to_nbt())
-    }
-    /// Write the tracker into the player data being saved. With a LAN owner,
-    /// `store_owner` rewrites that from the owner's guest, so it puts the
-    /// tracker there as well (`playerdata::with_warden`).
+    /// Write the tracker into the player data being saved.
     pub(super) fn save_warden_tracker(&mut self) {
-        let Some(tag) = self.warden_tracker_tag() else {
+        if !self.sculk.tracker_loaded {
             return;
-        };
+        }
+        let tag = self.sculk.tracker.to_nbt();
         let extra = self
             .level
             .player_extra

crates/horizon-client/src/game/split.rs

@@ -261,6 +261,8 @@ impl<'a> Split<'a> {
                 .get(i.wrapping_sub(1))
                 .map(|g| g.options.clone()),
         );
+        let seat = self.guests.get(i.wrapping_sub(1)).map_or(1, |g| g.seat);
+        horizon_hooks::engine::set_seat(seat - 1);
         self.turn = i;
     }
 

crates/horizon-client/src/game/split/players.rs

@@ -126,6 +126,7 @@ impl Split<'_> {
         // Until it has a profile, a scratch options file: never P1's.
         let options = Self::folder()?.join(".joining/options.txt");
         OPTIONS.set(Some(options.clone()));
+        horizon_hooks::engine::set_seat(seat - 1);
         let mut settings = self.host.settings.clone();
         if pad.is_some() {
             // The Controller setting is P1's own: a player who pressed a pad to join plays
@@ -135,6 +136,7 @@ impl Split<'_> {
         }
         let game = self.start_guest(seat, &options, settings);
         OPTIONS.set(None);
+        horizon_hooks::engine::set_seat(0);
         let mut game = game?;
         if let Some(pad) = pad {
             // The press that joined it doesn't act in its game.
@@ -299,16 +301,31 @@ impl Split<'_> {
         }
         let profile = profiles.join(&name);
         let options = profile.join("options.txt");
-        let mut settings = if options.exists() {
-            horizon_client::settings::Settings::load(&options)
+        let made = if options.exists() {
+            None
         } else {
             std::fs::create_dir_all(&profile)?;
             let mut new = self.host.settings.clone();
             // The Controller setting is P1's, as on the profile page (`join`).
             new.controller.enabled |= self.guests[i].pad.is_some();
+            // On P1's seat, so the crates' settings stores write P1's values too.
+            let turn = horizon_hooks::seat();
+            horizon_hooks::engine::set_seat(0);
             new.save(&options);
-            new
+            horizon_hooks::engine::set_seat(turn);
+            Some(new)
         };
+        // The crates' stores load into the guest's seat, before its turn starts below.
+        let turn = horizon_hooks::seat();
+        horizon_hooks::engine::set_seat(self.guests[i].seat - 1);
+        let mut settings = match made {
+            Some(new) => {
+                horizon_client::settings::Settings::load_stores(&options);
+                new
+            }
+            None => horizon_client::settings::Settings::load(&options),
+        };
+        horizon_hooks::engine::set_seat(turn);
         // A profile an earlier join saved with P1's off, or the player's pad would be dead.
         settings.controller.enabled |= self.guests[i].pad.is_some();
         // P1's own world through memory (`Ok`), else P1's server over the network (`Err`).

crates/horizon-client/src/game/startup_menu.rs

@@ -53,7 +53,7 @@ pub(super) struct StartupMenu {
     pub reload_packs: bool,
     /// Browse mods' worker (`mod_browser`).
     mod_jobs: super::mod_browser::Jobs,
-    pub perf: horizon_client::play_session::Session,
+    pub perf: horizon_client::telemetry::Session,
 }
 
 impl StartupMenu {

crates/horizon-client/src/game/window_handler.rs

@@ -304,7 +304,7 @@ impl ApplicationHandler for Game<'_> {
         };
         horizon_client::window::settle_created_fullscreen(&window, fullscreen);
         drop(window_step);
-        horizon_client::play_session::note_display(&window);
+        horizon_client::telemetry::note_display(&window);
         match self.new_renderer(window.clone()) {
             Ok(r) => {
                 self.renderer = Some(r);

crates/horizon-client/src/game/world_session.rs

@@ -169,33 +169,33 @@ impl Game<'_> {
     /// Leaving the game with a world open (window closed, Quit, `quit`):
     /// menu items go back (Player.closeContainer), then the world is saved,
     /// once.
-    /// Ends this play session for the hooks (`horizon_client::play_session`): opt-in telemetry
-    /// keeps its performance summary for the launcher to send, if the player allows it.
+    /// Keeps this play session's performance summary for the launcher to send, if the player
+    /// allows performance statistics (`horizon_client::telemetry`), and starts the next one.
     pub(super) fn finish_perf(&mut self) {
         // One session per computer: P1's (a splitscreen player's would count it again).
         if self.options.split_guest {
             return;
         }
-        // Again now: on Wayland the window is on a screen only once it has been shown.
-        if let Some(window) = &self.window {
-            horizon_client::play_session::note_display(window);
-        }
         let s = &self.settings;
-        let home = horizon_client::logging::game_home();
-        let version = horizon_client::crash::build();
-        let gpu = horizon_client::crash::gpu();
-        self.perf.finish(&horizon_hooks::WorldLeft {
-            home: &home,
-            version: &version,
-            gpu: gpu.as_ref(),
-            render_distance: s.render_distance,
-            simulation_distance: s.simulation_distance,
+        let settings = horizon_telemetry::payload::Settings {
+            render_distance: s.render_distance.clamp(0, 255) as u8,
+            simulation_distance: s.simulation_distance.clamp(0, 255) as u8,
             // 260 is the slider's "unlimited".
-            max_fps: (s.max_fps < 260).then_some(s.max_fps),
+            max_fps: if s.max_fps >= 260 {
+                0
+            } else {
+                s.max_fps.min(u32::from(u16::MAX)) as u16
+            },
             vsync: s.vsync,
             fullscreen: s.fullscreen,
-            graphics: &s.graphics_preset,
-        });
+            graphics: s.graphics_preset.clone(),
+        };
+        // Again now: on Wayland the window is on a screen only once it has been shown.
+        if let Some(window) = &self.window {
+            horizon_client::telemetry::note_display(window);
+        }
+        self.perf
+            .finish(&horizon_client::logging::game_home(), settings);
     }
 
     pub(super) fn save_for_exit(&mut self) -> Result<()> {

crates/horizon-client/src/lan/playerdata.rs

@@ -53,27 +53,6 @@ pub fn exists(world: &Path, uuid: u128) -> bool {
     path(world, uuid).is_file()
 }
 
-/// The key `ServerPlayer.addAdditionalSaveData` stores the `WardenSpawnTracker` under.
-pub const WARDEN_TRACKER_KEY: &str = "warden_spawn_tracker";
-
-/// Put a player's `warden_spawn_tracker` into the compound `store` writes from
-/// (`guest.saved`), so a save keeps it rather than the older one loaded with
-/// the file (the LAN owner's tracker lives in `Game`, `save_warden_tracker`).
-/// Other saved keys are left as they are; no tracker (not loaded yet) changes
-/// nothing.
-pub fn with_warden(guest: &mut Guest, tracker: Option<Tag>) -> &mut Guest {
-    let Some(tracker) = tracker else {
-        return guest;
-    };
-    let saved = guest
-        .saved
-        .get_or_insert_with(|| Tag::Compound(Default::default()));
-    if let Tag::Compound(map) = saved {
-        map.insert(WARDEN_TRACKER_KEY.into(), tracker);
-    }
-    guest
-}
-
 /// `PlayerDataStorage.load`: a guest's saved state, if they have been here
 /// before. The player's file, else its `.dat_old` (what a save cut off
 /// between its two renames leaves, `write_dat`).
@@ -672,42 +651,6 @@ mod tests {
         )
     }
 
-    /// #9965: the owner's warden warning level and cooldown reach the file on
-    /// a save, instead of the ones the file was loaded with.
-    #[test]
-    fn a_stored_warden_tracker_replaces_the_loaded_one() {
-        let mut g = guest();
-        g.saved = Some(Tag::compound(vec![
-            (
-                "warden_spawn_tracker",
-                Tag::compound(vec![
-                    ("warning_level", Tag::Int(2)),
-                    ("cooldown_ticks", Tag::Int(77)),
-                    ("ticks_since_last_warning", Tag::Int(5)),
-                ]),
-            ),
-            ("unrelated_key", Tag::Int(9)),
-        ]));
-        let tracker = crate::sculk::WardenSpawnTracker {
-            ticks_since_last_warning: 0,
-            warning_level: 3,
-            cooldown_ticks: 200,
-        };
-        with_warden(&mut g, Some(tracker.to_nbt()));
-        let (tag, _) = round_trip(&g);
-        let mut back = guest();
-        let mut level = Level::default();
-        level.read_player(&tag);
-        level.player_extra = Some(tag);
-        apply(&mut back, &level);
-        let saved = back.saved.as_ref().unwrap();
-        let read =
-            crate::sculk::WardenSpawnTracker::from_nbt(saved.get("warden_spawn_tracker").unwrap());
-        assert_eq!((read.warning_level, read.cooldown_ticks), (3, 200));
-        assert_eq!(read.ticks_since_last_warning, 0);
-        assert!(matches!(saved.get("unrelated_key"), Some(Tag::Int(9))));
-    }
-
     #[test]
     fn a_new_player_faces_the_world_spawn_angle() {
         let mut g = guest();

crates/horizon-client/src/mobs/anim.rs

@@ -771,26 +771,9 @@ fn swim(p: &mut Poses, pos: f32, h: &Hum) {
         lerp(amount, x, 0.3 * (pos * 0.333_333_34).mcos()),
     );
 }
-/// The player model's parts a [`BodyPose`] poses, in its order.
-pub const BODY_PARTS: [&str; 6] = [
-    "head",
-    "body",
-    "right_arm",
-    "left_arm",
-    "right_leg",
-    "left_leg",
-];
-
-/// A pose a higher layer lays over the player model's body after its vanilla animation (Horizon's
-/// emotes, docs/cosmetics.md), handed to the model through [`Mob::emote`]. The engine names no
-/// type of that layer (docs/layers.md); it downcasts its own back through [`std::any::Any`].
-pub trait BodyPose: std::any::Any + std::fmt::Debug + Send + Sync {
-    /// Poses the [`BODY_PARTS`] at `age` (the mob's ticks): `at_rest` holds each part before the
-    /// animation, `poses` as the animation left it; a part the model lacks holds the identity in
-    /// both and is not written back. False when it poses nothing at `age` (`poses` is then
-    /// ignored).
-    fn pose(&self, age: f32, at_rest: &[[f32; 9]; 6], poses: &mut [[f32; 9]; 6]) -> bool;
-}
+/// A pose laid over the player model's body after its vanilla animation, and the parts it poses:
+/// the hook's own types (`horizon_hooks::players`), kept here under their old path.
+pub use horizon_hooks::players::{BODY_PARTS, BodyPose};
 
 /// Apply the mob's model animation to `p` (at rest), then the pose laid over it, if any.
 pub fn setup(

crates/horizon-client/src/mobs/shulker.rs

@@ -855,11 +855,9 @@ pub fn texture(m: &Mob) -> String {
         "red",
         "black",
     ];
-    // Shulker.getColor: the saved byte is signed; 16 and above are undyed, and
-    // DyeColor.byId sends a negative id to white (OutOfBoundsStrategy.ZERO).
-    match m.extra.color as i8 {
-        16.. => "entity/shulker/shulker".into(),
-        c => format!("entity/shulker/shulker_{}", COLORS[c.max(0) as usize]),
+    match COLORS.get(m.extra.color as usize) {
+        Some(c) => format!("entity/shulker/shulker_{c}"),
+        None => "entity/shulker/shulker".into(),
     }
 }
 /// `attachFace.getOpposite().getRotation()` by attach face: the open
@@ -1146,46 +1144,3 @@ mod tests {
         assert!((h - 1.0).abs() < 1e-9, "{h}");
     }
 }
-
-#[cfg(test)]
-mod saved_bytes_tests {
-    use super::*;
-
-    /// `Shulker.readAdditionalSaveData`: `AttachFace` is
-    /// `Direction.LEGACY_ID_CODEC` (`from3DDataValue` wraps the id through
-    /// `abs(id % 6)`), while `Peek` and `Color` are raw `getByteOr` bytes. The
-    /// load clamped all three to their setters' ranges instead.
-    #[test]
-    fn a_shulker_reads_its_face_and_lid_bytes_like_vanilla() {
-        use crate::entity_nbt::mob_from_nbt;
-        use horizon_world::nbt::Tag;
-        let mut kind = crate::mobs::sensor_scan_tests::kind();
-        let k = std::sync::Arc::make_mut(&mut kind);
-        k.id = "minecraft:shulker".into();
-        k.species = Species::Shulker;
-        let types = [("minecraft:shulker".into(), kind)].into();
-        let tag = Tag::compound([
-            ("id", Tag::String("minecraft:shulker".into())),
-            (
-                "Pos",
-                Tag::List(vec![
-                    Tag::Double(0.0f64.to_bits()),
-                    Tag::Double(64.0f64.to_bits()),
-                    Tag::Double(0.0f64.to_bits()),
-                ]),
-            ),
-            ("AttachFace", Tag::Byte(7)),
-            ("Peek", Tag::Byte(-1)),
-            ("Color", Tag::Byte(-1)),
-        ]);
-        let m = mob_from_nbt(&tag, &types, 1, None).unwrap();
-        assert_eq!(m.extra.variant3, 1, "abs(7 % 6) is up");
-        assert_eq!(m.extra.counter, -1, "the peek byte is kept");
-        assert_eq!(m.extra.color, 255, "the color byte is kept");
-        assert_eq!(
-            texture(&m),
-            "entity/shulker/shulker_white",
-            "DyeColor.byId(-1)"
-        );
-    }
-}

crates/horizon-client/src/motion.rs

@@ -2148,16 +2148,18 @@ impl MotionWorld<'_, '_, '_> {
         let gravity = living_motion::effective_gravity(self)?;
         self.player.velocity = fall_flying_movement(v, self.player.pitch, self.player.yaw, gravity);
         let movement = self.player.velocity;
+        let before = self.player.position;
         self.move_self(movement)?;
         // LivingEntity.handleFallFlyingCollisions: the fall-damage sound plays
         // on both sides (a glider's own travel is client-side, and the sound
         // must reach its own ears, #8906), only the server hurts, and it
-        // compares the horizontal speed before `updateFallFlyingMovement`
-        // with the delta `Entity.move` leaves (the collided axes zeroed).
+        // compares the delta before the move with the one after it, which
+        // `Entity.move` leaves as the movement it resolved. `move_entity` does
+        // not write that back, so the distance actually travelled stands in.
         if self.player.collision.horizontal {
-            let v = self.player.velocity;
-            let after_h = (v.x * v.x + v.z * v.z).sqrt();
-            let dmg = fly_into_wall_damage(move_h, after_h);
+            let travelled = self.player.position.subtract(before);
+            let new_h = (travelled.x * travelled.x + travelled.z * travelled.z).sqrt();
+            let dmg = fly_into_wall_damage(move_h, new_h);
             if dmg > 0.0 {
                 let first = self.player.events.len();
                 // getFallDamageSound((int) dmg)
@@ -3146,7 +3148,6 @@ mod tests {
         assert_eq!(fly_into_wall_damage(0.3, 0.0), 0.0);
         assert!((fly_into_wall_damage(0.5, 0.1) - 1.0).abs() < 1e-5);
         assert!((fly_into_wall_damage(1.2, 0.0) - 9.0).abs() < 1e-5);
-        assert!(fly_into_wall_damage(0.01, 0.0) < 0.0);
     }
 
     use super::*;
@@ -4194,16 +4195,17 @@ mod tests {
             health: &resources.health,
         };
         w.travel_fall_flying().unwrap();
-        let is_fall = |e: &_| {
-            matches!(
+        assert!(
+            w.player.events.iter().any(|e| matches!(
                 e,
-                MotionEvent::Fall(crate::landing::FallEvent::Sound { .. })
-            )
-        };
-        assert_eq!(w.player.events.iter().filter(|e| is_fall(e)).count(), 1);
-        // The sound must play only once on impact, not repeat on subsequent ticks (#12304):
-        w.travel_fall_flying().unwrap();
-        assert_eq!(w.player.events.iter().filter(|e| is_fall(e)).count(), 1);
+                MotionEvent::Fall(crate::landing::FallEvent::Sound {
+                    sound: crate::landing::SceneSound::SmallFall,
+                    ..
+                })
+            )),
+            "{:?}",
+            w.player.events
+        );
         assert!(
             !w.player
                 .hurt_log

crates/horizon-client/src/net.rs

@@ -149,8 +149,20 @@ pub struct Session {
     far: Arc<crate::lod_net::Inbox>,
     /// The recording running, if any.
     recorder: RecorderSlot,
+    /// This connection's number, new for each one ([`Session::serial`]).
+    serial: u64,
+}
+/// The next [`Session::serial`].
+static NEXT_SERIAL: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
+fn next_serial() -> u64 {
+    NEXT_SERIAL.fetch_add(1, Ordering::Relaxed)
 }
 impl Session {
+    /// A number of its own for each connection, never 0: entity ids are per connection, so what
+    /// is kept by id goes when it changes (`horizon_hooks::players::PlayerModels::connection`).
+    pub fn serial(&self) -> u64 {
+        self.serial
+    }
     /// The negotiated wire release, once the connection has been established.
     pub fn server_version(&self) -> horizon_protocol::adapter::ServerVersion {
         self.writer.lock().unwrap().as_ref().map_or(
@@ -256,6 +268,7 @@ impl Session {
             debug: false,
             far: Arc::new(crate::lod_net::Inbox::default()),
             recorder: Arc::new(Mutex::new(None)),
+            serial: next_serial(),
         }
     }
     fn start(
@@ -333,6 +346,7 @@ impl Session {
             debug,
             far,
             recorder,
+            serial: next_serial(),
         }
     }
     /// Everything received since the last poll.
@@ -1829,6 +1843,7 @@ mod tests {
                 debug: false,
                 far: Arc::default(),
                 recorder: Arc::new(Mutex::new(None)),
+                serial: next_serial(),
             };
             let started = std::time::Instant::now();
             if explicit_disconnect {
@@ -1932,6 +1947,7 @@ mod tests {
             debug: false,
             far: Arc::default(),
             recorder: Arc::new(Mutex::new(None)),
+            serial: next_serial(),
         };
         let (thread_writer, thread_configuring, thread_recorder) = (
             session.writer.clone(),
@@ -2215,6 +2231,7 @@ mod tests {
             debug: false,
             far: Arc::default(),
             recorder: Arc::new(Mutex::new(None)),
+            serial: next_serial(),
         };
         let recorder = TestRecorder::default();
         session.start_recording(recorder.clone(), |_| {});

crates/horizon-client/src/play_session.rs

@@ -1,81 +0,0 @@
-//! A play session as the hooks above the engine hear it (`horizon_hooks`): the title screen's
-//! first frame, a world opening and its first frame, the frames played, and leaving the world.
-//! It also marks those moments in the startup trace (`spans::startup`). Opt-in telemetry's
-//! performance summary is built from these hooks (docs/telemetry.md).
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::time::Instant;
-
-use horizon_hooks::{Frame, Milestone, WorldLeft, engine};
-
-use crate::spans::{self, startup};
-
-/// One window's session: moved from the startup menu to the game with the window.
-#[derive(Default)]
-pub struct Session {
-    /// When the world being opened started to, until its first frame.
-    opening: Option<Instant>,
-}
-
-impl Session {
-    /// The title screen drew a frame: the first time, how long the start took.
-    pub fn title_shown(&mut self) {
-        static SHOWN: AtomicBool = AtomicBool::new(false);
-        if !SHOWN.swap(true, Ordering::Relaxed) {
-            startup::mark("title.shown");
-            // The frame itself: the menu bundle can be ready seconds before the renderer that
-            // draws it (pipelines compiling on a slow driver).
-            engine::startup(Milestone::TitleShown, startup::since_start());
-        }
-    }
-
-    /// A world starts loading.
-    pub fn world_opening(&mut self) {
-        if self.opening.is_none() {
-            startup::arm("world.opening");
-        }
-        self.opening.get_or_insert_with(Instant::now);
-    }
-
-    /// An entry queued during startup was cancelled before opening a world.
-    pub fn cancel_world_opening(&mut self) {
-        self.opening = None;
-    }
-
-    /// A frame drawn while playing (not in menus or loading), with the spans the render thread
-    /// recorded in it ([`spans::take_raw`]): the step it spent most of its time in is
-    /// [`spans::culprit`].
-    pub fn frame(&mut self, ms: f32, frame_spans: &[spans::Span]) {
-        if let Some(opening) = self.opening.take() {
-            startup::mark("world.first_frame");
-            engine::world_shown(opening.elapsed());
-        }
-        engine::frame(&Frame::new(ms, &|| spans::culprit(frame_spans)));
-    }
-
-    /// The player left the world: the session ends.
-    pub fn finish(&mut self, left: &WorldLeft<'_>) {
-        engine::world_left(left);
-    }
-}
-
-/// Tells the hooks the screen `window` is on ([`crate::window::display`]).
-pub fn note_display(window: &winit::window::Window) {
-    if let Some(d) = crate::window::display(window) {
-        engine::display(&horizon_hooks::Display {
-            width: d.width,
-            height: d.height,
-            refresh_hz: d.refresh_hz,
-            scale: d.scale,
-        });
-    }
-}
-
-/// The resources the menus need are loaded.
-pub fn core_ready() {
-    engine::startup(Milestone::CoreReady, startup::since_start());
-}
-
-/// What a world needs is loaded too.
-pub fn rest_ready() {
-    engine::startup(Milestone::RestReady, startup::since_start());
-}

crates/horizon-client/src/telemetry.rs

@@ -1,21 +1,16 @@
-//! The game's part in opt-in data collection (docs/telemetry.md), behind the `game` feature. When
-//! the player allows it, the game keeps a scrubbed crash report, or a play session's performance
+//! The game's part in opt-in data collection (`horizon_telemetry`, docs/telemetry.md). When the
+//! player allows it, the game keeps a scrubbed crash report, or a play session's performance
 //! summary, in the outbox. It never sends those itself: the launcher does, at its next start (the
-//! game's only sending is the anonymous "I'm playing" ping, `horizon-heartbeat`). Without the
-//! player's yes for that kind nothing is kept, and crash-reports/ stays local.
-//!
-//! It hears the game only through the platform's hooks ([`HOOKS`], `horizon_platform::hooks`);
-//! the official executable registers it (`horizon_official::PARTS`).
+//! game's only sending is the anonymous "I'm playing" ping, `heartbeat.rs`).
+//! Without the player's yes for that kind nothing is kept, and crash-reports/ stays local.
 use std::path::Path;
 use std::sync::atomic::{AtomicU32, Ordering};
-use std::sync::{LazyLock, Mutex};
-use std::time::Duration;
+use std::sync::{Mutex, OnceLock};
+use std::time::Instant;
 
-use horizon_platform::hooks::{self, Frame, Hooks, Milestone, WorldLeft};
-
-use crate::payload::{Crash, Display, Perf, Settings, System, Timings};
-use crate::scrub::Scrubber;
-use crate::{Item, Payload, Source, outbox};
+use horizon_telemetry::payload::{Crash, Display, Perf, Settings, System, Timings};
+use horizon_telemetry::scrub::Scrubber;
+use horizon_telemetry::{Item, Payload, Source, outbox};
 
 /// A session shorter than this says too little to keep.
 const MIN_SECONDS: f32 = 60.0;
@@ -24,82 +19,30 @@ const MIN_SECONDS: f32 = 60.0;
 /// world, the server or the resource packs.
 const CRASH_DETAILS: [&str; 3] = ["Horizon Version", "Graphics Adapter", "Render Settings"];
 
+static STARTED: OnceLock<Instant> = OnceLock::new();
 static CORE_READY_MS: AtomicU32 = AtomicU32::new(u32::MAX);
 static REST_READY_MS: AtomicU32 = AtomicU32::new(u32::MAX);
 /// The screen the window opened on.
 static DISPLAY: Mutex<Option<Display>> = Mutex::new(None);
 
-/// The game's hooks, for `horizon_platform::hooks::register`.
-pub static HOOKS: Telemetry = Telemetry {
-    session: LazyLock::new(|| Mutex::new(Session::default())),
-};
-
-/// The play session's performance, as the game's hooks tell it.
-pub struct Telemetry {
-    session: LazyLock<Mutex<Session>>,
+/// When the game started, for the time to the title screen. Call first thing in `main`.
+pub fn mark_start() {
+    STARTED.get_or_init(Instant::now);
 }
 
-impl Telemetry {
-    fn session(&self) -> std::sync::MutexGuard<'_, Session> {
-        self.session.lock().unwrap_or_else(|e| e.into_inner())
-    }
+pub fn mark_core_ready() {
+    mark_ready(&CORE_READY_MS);
 }
 
-impl Hooks for Telemetry {
-    fn startup(&self, milestone: Milestone, since_start: Duration) {
-        match milestone {
-            Milestone::CoreReady => mark_ready(&CORE_READY_MS, since_start),
-            Milestone::RestReady => mark_ready(&REST_READY_MS, since_start),
-            Milestone::TitleShown => self.session().title_shown(since_start),
-        }
-    }
-
-    /// A player who allows performance statistics also says what their slow frames spent their
-    /// time in.
-    fn wants_frame_steps(&self, home: &Path) -> bool {
-        crate::Consent::load(home).allows(crate::Kind::Perf)
-    }
-
-    fn world_shown(&self, since_opening: Duration) {
-        self.session().world_shown(since_opening);
-    }
-
-    fn frame(&self, frame: &Frame<'_>) {
-        self.session().frame(frame.ms, || frame.slowest_step());
-    }
-
-    fn world_left(&self, left: &WorldLeft<'_>) {
-        let settings = Settings {
-            render_distance: left.render_distance.clamp(0, 255) as u8,
-            simulation_distance: left.simulation_distance.clamp(0, 255) as u8,
-            max_fps: left
-                .max_fps
-                .map_or(0, |f| f.min(u32::from(u16::MAX)) as u16),
-            vsync: left.vsync,
-            fullscreen: left.fullscreen,
-            graphics: left.graphics.to_owned(),
-        };
-        self.session()
-            .finish(left.home, left.version, left.gpu, settings);
-    }
-
-    fn display(&self, display: &hooks::Display) {
-        *DISPLAY.lock().unwrap_or_else(|e| e.into_inner()) = Some(Display {
-            width: display.width,
-            height: display.height,
-            refresh_hz: display.refresh_hz.unwrap_or(0),
-            scale: display.scale as f32,
-        });
-    }
-
-    fn crashed(&self, crash: &hooks::Crash<'_>) {
-        keep_crash(crash);
-    }
+pub fn mark_rest_ready() {
+    mark_ready(&REST_READY_MS);
 }
 
-fn mark_ready(mark: &AtomicU32, since_start: Duration) {
-    let ms = since_start.as_millis().min(u128::from(u32::MAX - 1)) as u32;
-    let _ = mark.compare_exchange(u32::MAX, ms, Ordering::Relaxed, Ordering::Relaxed);
+fn mark_ready(mark: &AtomicU32) {
+    if let Some(started) = STARTED.get() {
+        let ms = started.elapsed().as_millis().min(u128::from(u32::MAX - 1)) as u32;
+        let _ = mark.compare_exchange(u32::MAX, ms, Ordering::Relaxed, Ordering::Relaxed);
+    }
 }
 
 fn readiness_ms(mark: &AtomicU32) -> Option<u32> {
@@ -107,32 +50,54 @@ fn readiness_ms(mark: &AtomicU32) -> Option<u32> {
     (ms != u32::MAX).then_some(ms)
 }
 
-/// This machine, with the GPU once the renderer has one and the screen. The drive is the one
+/// The screen the window is on: size in physical pixels, refresh rate, scale.
+pub fn set_display(width: u32, height: u32, refresh_hz: u32, scale: f64) {
+    *DISPLAY.lock().unwrap_or_else(|e| e.into_inner()) = Some(Display {
+        width,
+        height,
+        refresh_hz,
+        scale: scale as f32,
+    });
+}
+
+/// Keeps the screen `window` is on ([`crate::window::display`]) for the items' `system.display`.
+pub fn note_display(window: &winit::window::Window) {
+    if let Some(d) = crate::window::display(window) {
+        set_display(d.width, d.height, d.refresh_hz.unwrap_or(0), d.scale);
+    }
+}
+
+/// This machine, with the GPU and the screen once the renderer knows them. The drive is the one
 /// under the game folder (the current folder).
-pub fn system(gpu: Option<&hooks::Gpu>) -> System {
+pub fn system() -> System {
     let home = std::env::current_dir().ok();
     let mut system = System::detect_in(home.as_deref());
-    if let Some(gpu) = gpu {
+    if let Some(gpu) = crate::gfx::adapter() {
         system.vram_mb = match gpu.kind.as_str() {
-            "discrete" => crate::system::vram_mb(&gpu.vendor).unwrap_or(0),
+            "discrete" => horizon_telemetry::system::vram_mb(&gpu.vendor).unwrap_or(0),
             _ => 0,
         };
-        system.gpu = gpu.name.clone();
-        system.gpu_vendor = gpu.vendor.clone();
-        system.gpu_kind = gpu.kind.clone();
-        system.driver = gpu.driver.clone();
-        system.backend = gpu.backend.clone();
+        system.gpu = gpu.name;
+        system.gpu_vendor = gpu.vendor;
+        system.gpu_kind = gpu.kind;
+        system.driver = gpu.driver;
+        system.backend = gpu.backend;
     }
     system.display = DISPLAY.lock().unwrap_or_else(|e| e.into_inner()).clone();
     system
 }
 
+/// The release (`v0.2.3`), or the client's crate version for a build from source.
+pub fn version() -> String {
+    crate::crash::release_tag().unwrap_or_else(|| format!("dev {}", env!("CARGO_PKG_VERSION")))
+}
+
 /// What a crash report becomes when it may leave: the error and stack, the thread, and the
 /// details in [`CRASH_DETAILS`], with the world's name and folder and the server's address
 /// scrubbed wherever they appear. No log lines.
-pub fn crash_item(report: &hooks::Crash<'_>) -> Item {
+pub fn crash_item(report: &crate::crash::Report) -> Item {
     let mut scrubber = Scrubber::new();
-    for (key, value) in report.details {
+    for (key, value) in &report.details {
         match key.as_str() {
             // `Name (saves/folder)`, as game.rs sets it.
             "World" => {
@@ -147,10 +112,10 @@ pub fn crash_item(report: &hooks::Crash<'_>) -> Item {
         }
     }
     let crash = Crash {
-        system: system(report.gpu),
-        error: scrubber.scrub(report.error),
-        stack: scrubber.scrub(report.stack),
-        thread: report.thread.to_owned(),
+        system: system(),
+        error: scrubber.scrub(&report.error),
+        stack: scrubber.scrub(&report.stack),
+        thread: report.thread.clone(),
         details: report
             .details
             .iter()
@@ -158,7 +123,7 @@ pub fn crash_item(report: &hooks::Crash<'_>) -> Item {
             .map(|(k, v)| (k.clone(), scrubber.scrub(v)))
             .collect(),
     };
-    let mut item = Item::new(Source::Game, report.version, Payload::Crash(crash));
+    let mut item = Item::new(Source::Game, version(), Payload::Crash(crash));
     // A huge stack keeps its top, where the error is.
     while item.validate().is_err() {
         let Payload::Crash(crash) = &mut item.payload else {
@@ -180,12 +145,26 @@ pub fn crash_item(report: &hooks::Crash<'_>) -> Item {
 }
 
 /// Keeps the crash for the launcher to send, if the player allows crash reports.
-pub fn keep_crash(report: &hooks::Crash<'_>) {
-    if let Err(e) = outbox::push(report.home, &crash_item(report)) {
+pub fn keep_crash(home: &Path, report: &crate::crash::Report) {
+    if let Err(e) = outbox::push(home, &crash_item(report)) {
         log::warn!("Horizon: could not keep the crash report to send: {e}");
     }
 }
 
+/// Keeps a benchmark report (`--benchmark`) for the launcher to send, if the player allows
+/// benchmark uploads: the report as docs/benchmark-report.md defines it, dated to the day.
+pub fn keep_benchmark(home: &Path, report: &horizon_bench::Report) {
+    let Ok(data) = serde_json::to_value(report.for_upload()) else {
+        return;
+    };
+    if let Err(e) = outbox::push(
+        home,
+        &Item::new(Source::Game, version(), Payload::Benchmark(data)),
+    ) {
+        log::warn!("Horizon: could not keep the benchmark report to send: {e}");
+    }
+}
+
 /// One play session's performance, from entering a world to leaving it: frame and tick
 /// times as [`Timings`] (fixed size whatever the length), never the frames themselves.
 #[derive(Default)]
@@ -197,33 +176,42 @@ pub struct Session {
     /// The start was measured: only the first session carries it.
     title_measured: bool,
     to_world_ms: Option<u32>,
-    slow_frames: Vec<crate::payload::SlowFrames>,
+    opening: Option<Instant>,
+    slow_frames: Vec<horizon_telemetry::payload::SlowFrames>,
 }
 
 impl Session {
-    /// The title screen drew its first frame, `since_start` after the game started.
-    pub fn title_shown(&mut self, since_start: Duration) {
+    /// The title screen drew a frame: the first time, how long the start took.
+    pub fn title_shown(&mut self) {
         if !self.title_measured {
             self.title_measured = true;
-            self.to_title_ms = Some(since_start.as_millis().min(u128::from(u32::MAX)) as u32);
+            crate::spans::startup::mark("title.shown");
+            // The frame itself: the menu bundle can be ready seconds before
+            // the renderer that draws it (pipelines compiling on a slow driver).
+            self.to_title_ms = STARTED.get().map(|s| s.elapsed().as_millis() as u32);
         }
     }
 
-    /// A world's first frame, `since_opening` after it started opening: the session's first
-    /// world counts.
-    pub fn world_shown(&mut self, since_opening: Duration) {
-        if self.to_world_ms.is_none() {
-            self.to_world_ms = Some(since_opening.as_millis().min(u128::from(u32::MAX)) as u32);
+    /// A world starts loading.
+    pub fn world_opening(&mut self) {
+        if self.opening.is_none() {
+            crate::spans::startup::arm("world.opening");
         }
+        self.opening.get_or_insert_with(Instant::now);
     }
 
-    /// A frame drawn while playing (not in menus or loading): a frame of `SLOW_FRAME_MS` or
-    /// more counts under the step it spent most of its time in (`slowest_step`, the game's
-    /// `spans::culprit`).
-    pub fn frame(&mut self, ms: f32, slowest_step: impl FnOnce() -> Option<(String, f32)>) {
-        use crate::payload::{SLOW_FRAME_MS, SlowFrames};
+    /// An entry queued during startup was cancelled before opening a world.
+    pub fn cancel_world_opening(&mut self) {
+        self.opening = None;
+    }
+
+    /// A frame drawn while playing (not in menus or loading), with the spans the render thread
+    /// recorded in it ([`crate::spans::take_raw`]): a frame of `SLOW_FRAME_MS` or more counts
+    /// under the step it spent most of its time in ([`crate::spans::culprit`]).
+    pub fn frame(&mut self, ms: f32, spans: &[crate::spans::Span]) {
+        use horizon_telemetry::payload::{SLOW_FRAME_MS, SlowFrames};
         if ms >= SLOW_FRAME_MS {
-            let (mut path, span_ms) = slowest_step().unwrap_or_default();
+            let (mut path, span_ms) = crate::spans::culprit(spans).unwrap_or_default();
             // A path too long for the item keeps its last steps.
             while path.len() > SlowFrames::MAX_NAME
                 && let Some((_, rest)) = path.split_once('/')
@@ -232,6 +220,12 @@ impl Session {
             }
             SlowFrames::record(&mut self.slow_frames, ms, &path, span_ms);
         }
+        if let Some(opening) = self.opening.take() {
+            crate::spans::startup::mark("world.first_frame");
+            if self.to_world_ms.is_none() {
+                self.to_world_ms = Some(opening.elapsed().as_millis() as u32);
+            }
+        }
         self.frames.record(ms);
         self.played_ms += ms;
     }
@@ -242,10 +236,10 @@ impl Session {
     }
 
     /// The session's summary, if it was long enough to say something.
-    pub fn summary(&self, gpu: Option<&hooks::Gpu>, settings: Settings) -> Option<Perf> {
+    pub fn summary(&self, settings: Settings) -> Option<Perf> {
         let seconds = self.played_ms / 1000.0;
         (seconds >= MIN_SECONDS).then(|| Perf {
-            system: system(gpu),
+            system: system(),
             settings,
             seconds: seconds as u32,
             frames: self.frames.summary(),
@@ -261,17 +255,11 @@ impl Session {
 
     /// Keeps the session's summary for the launcher to send, if the player allows performance
     /// statistics, and starts the next session (the time to the title goes with the first).
-    pub fn finish(
-        &mut self,
-        home: &Path,
-        version: &str,
-        gpu: Option<&hooks::Gpu>,
-        settings: Settings,
-    ) {
-        if crate::Consent::load(home).allows(crate::Kind::Perf)
-            && let Some(perf) = self.summary(gpu, settings)
+    pub fn finish(&mut self, home: &Path, settings: Settings) {
+        if horizon_telemetry::Consent::load(home).allows(horizon_telemetry::Kind::Perf)
+            && let Some(perf) = self.summary(settings)
         {
-            let item = Item::new(Source::Game, version, Payload::Perf(perf));
+            let item = Item::new(Source::Game, version(), Payload::Perf(perf));
             if let Err(e) = outbox::push(home, &item) {
                 log::warn!("Horizon: could not keep the session's performance summary: {e}");
             }
@@ -316,7 +304,7 @@ fn peak_ram_mb() -> u32 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{Choices, Consent, Kind};
+    use horizon_telemetry::{Choices, Consent, Kind};
 
     fn home(name: &str) -> std::path::PathBuf {
         let dir = std::env::temp_dir().join(format!(
@@ -334,33 +322,16 @@ mod tests {
         consent.save(home).unwrap();
     }
 
-    /// A crash report's parts, as `crash.rs` gives them to the hooks.
-    struct Report {
-        error: String,
-        stack: String,
-        details: Vec<(String, String)>,
-    }
-
-    impl Report {
-        fn crash<'a>(&'a self, home: &'a Path) -> hooks::Crash<'a> {
-            hooks::Crash {
-                home,
-                version: "v2026.10.15",
-                error: &self.error,
-                stack: &self.stack,
-                thread: "Render thread",
-                details: &self.details,
-                gpu: None,
-            }
-        }
-    }
-
-    fn report() -> Report {
-        Report {
+    fn report() -> crate::crash::Report {
+        crate::crash::Report {
+            time: chrono::Local::now(),
+            description: "Unexpected error".into(),
             error:
                 "panicked at src/save.rs:10:5:\nno level.dat in /Users/ana/horizon/saves/Ana's Base"
                     .into(),
             stack: "horizon_client::save::load (crates/horizon-client/src/save.rs:10:5)\n".into(),
+            thread: "Render thread".into(),
+            side: "client",
             details: vec![
                 (
                     "Horizon Version".into(),
@@ -374,13 +345,13 @@ mod tests {
                 ("Server".into(), "play.example.net:25565".into()),
                 ("Resource Packs".into(), "Ana's pack".into()),
             ],
+            log: vec!["[CHAT] <Ana> hi".into()],
         }
     }
 
     #[test]
     fn a_crash_keeps_only_what_says_what_happened() {
-        let report = report();
-        let item = crash_item(&report.crash(Path::new("home")));
+        let item = crash_item(&report());
         let Payload::Crash(crash) = &item.payload else {
             panic!("a crash item");
         };
@@ -396,7 +367,13 @@ mod tests {
             )]
         );
         let json = serde_json::to_string(&item).unwrap();
-        for private in ["Castle Ana", "Ana's Base", "example.net", "Ana's pack"] {
+        for private in [
+            "Castle Ana",
+            "Ana's Base",
+            "example.net",
+            "Ana's pack",
+            "CHAT",
+        ] {
             assert!(!json.contains(private), "{private} in {json}");
         }
         assert!(item.validate().is_ok());
@@ -407,7 +384,7 @@ mod tests {
         let mut report = report();
         report.stack =
             "horizon_client::game::deep (crates/horizon-client/src/game.rs:1:1)\n".repeat(2000);
-        let item = crash_item(&report.crash(Path::new("home")));
+        let item = crash_item(&report);
         assert!(item.validate().is_ok());
         let Payload::Crash(crash) = item.payload else {
             panic!("a crash item");
@@ -415,11 +392,43 @@ mod tests {
         assert!(crash.stack.lines().count() > 100);
     }
 
+    #[test]
+    fn benchmark_reports_need_their_own_consent_and_go_dated_to_the_day() {
+        let home = home("benchmark");
+        let mut report = horizon_bench::Report::new(horizon_bench::Kind::Game, Default::default());
+        report.created = "2026-10-15T14:03:27Z".into();
+        report.label = Some("my machine".into());
+        keep_benchmark(&home, &report);
+        allow(
+            &home,
+            Choices {
+                performance: true,
+                ..Choices::NONE
+            },
+        );
+        keep_benchmark(&home, &report);
+        assert!(outbox::pending(&home).is_empty());
+        allow(
+            &home,
+            Choices {
+                benchmarks: true,
+                ..Choices::NONE
+            },
+        );
+        keep_benchmark(&home, &report);
+        let pending = outbox::pending(&home);
+        assert_eq!(pending.len(), 1);
+        let text = serde_json::to_string(&pending[0].1).unwrap();
+        assert!(
+            text.contains("2026-10-15T00:00:00Z") && !text.contains("my machine"),
+            "{text}"
+        );
+    }
+
     #[test]
     fn crashes_stay_local_without_consent() {
         let home = home("crash");
-        let report = report();
-        keep_crash(&report.crash(&home));
+        keep_crash(&home, &report());
         assert!(outbox::pending(&home).is_empty());
         allow(
             &home,
@@ -428,7 +437,7 @@ mod tests {
                 ..Choices::NONE
             },
         );
-        keep_crash(&report.crash(&home));
+        keep_crash(&home, &report());
         assert!(outbox::pending(&home).is_empty());
         allow(
             &home,
@@ -437,38 +446,33 @@ mod tests {
                 ..Choices::NONE
             },
         );
-        keep_crash(&report.crash(&home));
+        keep_crash(&home, &report());
         let pending = outbox::pending(&home);
         assert_eq!(pending.len(), 1);
         assert_eq!(pending[0].1.kind(), Kind::Crash);
     }
 
     #[test]
-    fn the_time_to_a_world_is_the_sessions_first() {
+    fn cancelled_startup_entry_does_not_time_menu_browsing() {
         let mut session = Session::default();
-        session.world_shown(Duration::from_millis(4200));
-        session.world_shown(Duration::from_millis(900));
-        assert_eq!(session.to_world_ms, Some(4200));
-    }
-
-    #[test]
-    fn the_time_to_the_title_goes_with_the_first_session_only() {
-        let home = home("title");
-        let mut session = Session::default();
-        session.title_shown(Duration::from_millis(3100));
-        assert_eq!(session.to_title_ms, Some(3100));
-        session.finish(&home, "dev", None, Settings::default());
-        session.title_shown(Duration::from_millis(9000));
-        assert_eq!(session.to_title_ms, None);
+        session.world_opening();
+        assert!(session.opening.is_some());
+        session.cancel_world_opening();
+        assert!(session.opening.is_none());
+        session.frame(16.0, &[]);
+        assert!(session.to_world_ms.is_none());
+        session.world_opening();
+        session.frame(16.0, &[]);
+        assert!(session.to_world_ms.is_some());
     }
 
     #[test]
     fn a_session_is_kept_only_with_consent_and_once_long_enough() {
         let home = home("session");
         let mut session = Session::default();
-        session.world_shown(Duration::from_millis(1500));
-        (0..2000).for_each(|_| session.frame(16.6, || None));
-        session.finish(&home, "dev", None, Settings::default());
+        session.world_opening();
+        (0..2000).for_each(|_| session.frame(16.6, &[]));
+        session.finish(&home, Settings::default());
         assert!(outbox::pending(&home).is_empty(), "33 s, and no consent");
         allow(
             &home,
@@ -477,16 +481,14 @@ mod tests {
                 ..Choices::NONE
             },
         );
-        (0..2000).for_each(|_| session.frame(16.6, || None));
-        session.finish(&home, "dev", None, Settings::default());
+        (0..2000).for_each(|_| session.frame(16.6, &[]));
+        session.finish(&home, Settings::default());
         assert!(outbox::pending(&home).is_empty(), "33 s is too short");
-        session.world_shown(Duration::from_millis(1500));
-        (0..4000).for_each(|_| session.frame(16.6, || None));
+        session.world_opening();
+        (0..4000).for_each(|_| session.frame(16.6, &[]));
         (0..1200).for_each(|_| session.tick(4.0));
         session.finish(
             &home,
-            "dev",
-            None,
             Settings {
                 render_distance: 12,
                 ..Settings::default()
@@ -509,15 +511,21 @@ mod tests {
     /// span counts under none. Faster frames leave no entry.
     #[test]
     fn slow_frames_are_put_down_to_their_step() {
-        // What the game's `spans::culprit` names for each frame.
-        let step = |path: &'static str, ms: f32| move || Some((path.to_owned(), ms));
+        use crate::spans::Span;
+        let span = |name, ms, depth| Span {
+            name,
+            ms,
+            cpu_ms: ms,
+            depth,
+        };
         let mut session = Session::default();
-        (0..4000).for_each(|_| session.frame(16.6, step("tick", 10.0)));
-        session.frame(320.0, step("renderer/r_uploads", 280.0));
-        session.frame(900.0, step("renderer/r_uploads", 280.0));
-        session.frame(260.0, || None);
-        session.frame(249.0, step("renderer/r_uploads", 280.0));
-        let perf = session.summary(None, Settings::default()).unwrap();
+        (0..4000).for_each(|_| session.frame(16.6, &[span("tick", 10.0, 0)]));
+        let frozen = [span("r_uploads", 280.0, 1), span("renderer", 300.0, 0)];
+        session.frame(320.0, &frozen);
+        session.frame(900.0, &frozen);
+        session.frame(260.0, &[]);
+        session.frame(249.0, &frozen);
+        let perf = session.summary(Settings::default()).unwrap();
         let seen: Vec<_> = perf
             .slow_frames
             .iter()

crates/horizon-cosmetics/src/fetch.rs

@@ -70,7 +70,8 @@ struct Shared {
 /// The game's handle. Dropping it stops the thread.
 pub struct Cosmetics {
     shared: Arc<Shared>,
-    worker: Option<Box<dyn FnMut() + Send>>,
+    /// Behind a lock so one client can be shared (`Arc<Cosmetics>` is `Send + Sync`).
+    worker: Mutex<Option<Box<dyn FnMut() + Send>>>,
 }
 
 impl Cosmetics {
@@ -78,7 +79,12 @@ impl Cosmetics {
     /// `cache` when given.
     pub fn new(transport: impl Transport, cache: Option<PathBuf>) -> Self {
         let mut c = Self::manual(transport, cache, Arc::new(Instant::now));
-        let mut work = c.worker.take().expect("worker");
+        let mut work = c
+            .worker
+            .get_mut()
+            .unwrap_or_else(PoisonError::into_inner)
+            .take()
+            .expect("worker");
         let shared = c.shared.clone();
         let _ = std::thread::Builder::new()
             .name("Cosmetics".into())
@@ -125,7 +131,7 @@ impl Cosmetics {
         });
         Self {
             shared,
-            worker: Some(worker),
+            worker: Mutex::new(Some(worker)),
         }
     }
 

crates/horizon-cosmetics/src/fetch_tests.rs

@@ -87,7 +87,7 @@ fn clock() -> (Clock, Arc<AtomicU64>) {
 }
 
 fn run(c: &mut Cosmetics) {
-    (c.worker.as_mut().unwrap())();
+    (c.worker.get_mut().unwrap().as_mut().unwrap())();
 }
 
 fn ids(worn: Option<Worn>) -> Vec<String> {

crates/horizon-hooks/src/lib.rs

@@ -19,14 +19,14 @@
 
 pub mod hud;
 pub mod pages;
+pub mod players;
 mod registry;
 pub mod settings;
 pub mod tunnel;
 
 use registry::Registry;
-use std::path::Path;
-use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
-use std::time::{Duration, Instant};
+use std::cell::Cell;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 /// What a crate above the engine hears from the game. Every method has an empty default:
 /// implement only those you need. Hooks run on the game's thread (the render thread) unless a
@@ -44,45 +44,39 @@ pub trait Hooks: Sync {
     /// The game is ending normally: its window closed and the world is saved. Not after a crash.
     fn shutdown(&self) {}
 
-    /// A moment of the game's start, once each, with the time since the process started.
-    fn startup(&self, _milestone: Milestone, _since_start: Duration) {}
+    /// Once a frame, before drawing: `sprites` takes the pictures the crate's
+    /// [`players::Sprites`] lacked. Only a window's game calls it (each splitscreen player in
+    /// turn, [`seat`]), never the integrated server's thread or a dedicated server; so are the
+    /// player methods below (not [`Hooks::tunnel`]).
+    fn frame(&self, _frame: &players::Frame, _sprites: &mut dyn players::SpriteStore) {}
 
-    /// Whether this hook wants the render thread to time its steps in every frame, for
-    /// [`Frame::slowest_step`]. Asked once as the game starts (not on a dedicated server);
-    /// `home` is the game's home folder. Timing the steps costs microseconds a frame.
-    fn wants_frame_steps(&self, _home: &Path) -> bool {
-        false
+    /// Once a client tick while a world is shown: the player models in view.
+    fn tick(&self, _models: &mut dyn players::PlayerModels) {}
+
+    /// What goes by a player model's name over its head, each frame its name tag is drawn. The
+    /// first hook that answers is used.
+    fn name_decoration(
+        &self,
+        _model: &players::PlayerModel,
+        _sprites: &dyn players::Sprites,
+    ) -> Option<players::NameDecoration> {
+        None
     }
 
-    /// A world's first frame was drawn: the time since it started opening (single player, a
-    /// server, LAN). Every time a world is entered.
-    fn world_shown(&self, _since_opening: Duration) {}
-
-    /// A frame drawn while playing: not in the menus or while a world loads. Every frame.
-    fn frame(&self, _frame: &Frame<'_>) {}
-
-    /// The player left a world (to the title screen, or by quitting): the end of a play
-    /// session, with the settings it was played with.
-    fn world_left(&self, _left: &WorldLeft<'_>) {}
-
-    /// The screen the window is on: when the window opens, and again as a session ends (on
-    /// Wayland a window is on a screen only once it has been shown).
-    fn display(&self, _display: &Display) {}
-
-    /// The game crashed, once, before its report is saved in `crash-reports/`. Called on the
-    /// thread that crashed, whatever the mode (a dedicated server too).
-    fn crashed(&self, _crash: &Crash<'_>) {}
-
-    /// Whether this crate runs the benchmark `--benchmark SCENARIO` names. Asked while the command
-    /// line is read; a scenario no hook knows is refused there.
-    fn knows_benchmark(&self, _scenario: &str) -> bool {
-        false
+    /// The mark before the name of the player `uuid` in the player list, each frame it shows.
+    /// The first hook that answers is used.
+    fn player_mark(&self, _uuid: u128) -> Option<players::Mark> {
+        None
     }
 
-    /// Starts the benchmark [`Hooks::knows_benchmark`] accepted, once the title screen loads: it
-    /// drives the game through `control` on a thread of its own and quits the game when done.
-    /// Only the first hook that knows the scenario is called.
-    fn benchmark(&self, _run: &Benchmark<'_>, _control: Control) {}
+    /// How the camera stands in third person, each frame. The first hook that answers is used.
+    fn camera(&self, _own: &players::CameraView) -> Option<players::CameraOverride> {
+        None
+    }
+
+    /// Draws on a player model, after its vanilla layers, each time it is drawn.
+    fn player_layers(&self, _model: &players::PlayerModel, _draw: &mut dyn players::PlayerDraw) {}
+
     /// The resolver of `friend:` addresses this crate offers ([`tunnel`]); the first hook that
     /// offers one is used. Asked on the network thread when joining and on the game thread when
     /// an address is shown, never per frame.
@@ -91,129 +85,6 @@ pub trait Hooks: Sync {
     }
 }
 
-/// One command line into the game's agent control (docs/agent-control.md), answered with its
-/// JSON reply, as `horizon-ctl` would send it. `None`: the game has exited, or gave no reply
-/// within the time given.
-pub type Control = Box<dyn Fn(&str, Duration) -> Option<String> + Send>;
-
-/// What [`Hooks::benchmark`] gets.
-pub struct Benchmark<'a> {
-    pub scenario: &'a str,
-    /// When the process started.
-    pub started: Instant,
-    /// The game's home folder (logs, crash reports, telemetry).
-    pub home: &'a Path,
-    /// The game folder (saves, options).
-    pub game_dir: &'a Path,
-    /// The release, as the game's log names it: a nightly's label, the tag, or the crate version
-    /// for a build from source.
-    pub version: &'a str,
-    /// As [`Crash::version`].
-    pub build: &'a str,
-    pub simulation_distance: u32,
-    pub offscreen: bool,
-}
-
-/// The graphics adapter the renderer runs on.
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct Gpu {
-    pub name: String,
-    pub vendor: String,
-    /// `integrated`, `discrete`, `virtual`, `cpu` or `other`.
-    pub kind: String,
-    pub driver: String,
-    /// `metal`, `vulkan`, `dx12` or `gl`.
-    pub backend: String,
-}
-
-/// The screen a window is on ([`Hooks::display`]).
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Display {
-    /// Physical pixels.
-    pub width: u32,
-    pub height: u32,
-    /// `None` where the OS doesn't say.
-    pub refresh_hz: Option<u32>,
-    pub scale: f64,
-}
-
-/// What [`Hooks::crashed`] gets: the crash report's parts.
-pub struct Crash<'a> {
-    /// The game's home folder.
-    pub home: &'a Path,
-    /// The build: the release (`v0.2.3`), or `dev <crate version>` for a build from source.
-    pub version: &'a str,
-    /// The error's message.
-    pub error: &'a str,
-    /// Where it happened and how it got there: one frame a line.
-    pub stack: &'a str,
-    pub thread: &'a str,
-    /// The report's details (`Horizon Version`, `World`, `Server`...), as written in it.
-    pub details: &'a [(String, String)],
-    /// The renderer's adapter, once it has one.
-    pub gpu: Option<&'a Gpu>,
-}
-
-/// A moment of the game's start ([`Hooks::startup`]).
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Milestone {
-    /// The resources the menus need are loaded.
-    CoreReady,
-    /// The rest (what a world needs) too.
-    RestReady,
-    /// The title screen drew its first frame.
-    TitleShown,
-}
-
-impl Milestone {
-    fn bit(self) -> u8 {
-        match self {
-            Self::CoreReady => 1,
-            Self::RestReady => 2,
-            Self::TitleShown => 4,
-        }
-    }
-}
-
-/// What [`Hooks::frame`] gets.
-pub struct Frame<'a> {
-    /// How long the frame took.
-    pub ms: f32,
-    slowest_step: &'a dyn Fn() -> Option<(String, f32)>,
-}
-
-impl<'a> Frame<'a> {
-    /// `slowest_step` gives [`Frame::slowest_step`], only when asked.
-    pub fn new(ms: f32, slowest_step: &'a dyn Fn() -> Option<(String, f32)>) -> Self {
-        Self { ms, slowest_step }
-    }
-
-    /// The step the frame spent the most time in (`render/terrain`) and its milliseconds, when
-    /// the steps were timed ([`Hooks::wants_frame_steps`]). Worked out on each call: ask only
-    /// for a slow frame.
-    pub fn slowest_step(&self) -> Option<(String, f32)> {
-        (self.slowest_step)()
-    }
-}
-
-/// What [`Hooks::world_left`] gets: the game's home folder, the build, the adapter and the
-/// settings played with.
-pub struct WorldLeft<'a> {
-    pub home: &'a Path,
-    /// As [`Crash::version`].
-    pub version: &'a str,
-    /// The renderer's adapter.
-    pub gpu: Option<&'a Gpu>,
-    pub render_distance: i32,
-    pub simulation_distance: i32,
-    /// `None`: unlimited.
-    pub max_fps: Option<u32>,
-    pub vsync: bool,
-    pub fullscreen: bool,
-    /// The graphics preset's name.
-    pub graphics: &'a str,
-}
-
 /// What [`Hooks::started`] gets.
 #[non_exhaustive]
 pub struct Started<'a> {
@@ -253,10 +124,27 @@ fn all() -> &'static [&'static dyn Hooks] {
     HOOKS.all()
 }
 
+thread_local! {
+    static SEAT: Cell<usize> = const { Cell::new(0) };
+}
+
+/// The splitscreen player whose turn it is: 0 for P1 (and without splitscreen), 1 for P2...
+/// Splitscreen players are one process, each `Game` in turn on the game's thread, so a crate's
+/// statics are shared by them: a crate that keeps per-player state (settings, pages, HUD) indexes
+/// it by this. A player keeps its seat while it plays. Other threads always see 0.
+pub fn seat() -> usize {
+    SEAT.get()
+}
+
 /// The engine's side: where it calls the hooks. Only the engine calls these.
 pub mod engine {
     use super::*;
 
+    /// The player whose turn starts on this thread ([`seat`]).
+    pub fn set_seat(seat: usize) {
+        SEAT.set(seat);
+    }
+
     /// Seals every list (hooks and the registries); their first use does it anyway. Call where
     /// registration ends.
     pub fn seal() {
@@ -294,72 +182,50 @@ pub mod engine {
         }
     }
 
-    /// The milestones already said.
-    static MILESTONES: AtomicU8 = AtomicU8::new(0);
-
-    /// [`Hooks::startup`], the first time `milestone` is reached; later calls do nothing.
-    pub fn startup(milestone: Milestone, since_start: Duration) {
-        if MILESTONES.fetch_or(milestone.bit(), Ordering::Relaxed) & milestone.bit() == 0 {
-            for hooks in all() {
-                hooks.startup(milestone, since_start);
-            }
-        }
-    }
-
-    /// [`Hooks::wants_frame_steps`]: whether any hook wants them.
-    pub fn wants_frame_steps(home: &Path) -> bool {
-        all().iter().any(|h| h.wants_frame_steps(home))
-    }
-
-    /// [`Hooks::world_shown`].
-    pub fn world_shown(since_opening: Duration) {
-        for hooks in all() {
-            hooks.world_shown(since_opening);
-        }
+    /// Whether any hook is registered: without one the engine builds no view to hand them.
+    pub fn any() -> bool {
+        !all().is_empty()
     }
 
     /// [`Hooks::frame`].
-    pub fn frame(frame: &Frame<'_>) {
+    pub fn frame(frame: &players::Frame, sprites: &mut dyn players::SpriteStore) {
         for hooks in all() {
-            hooks.frame(frame);
+            hooks.frame(frame, sprites);
         }
     }
 
-    /// [`Hooks::world_left`].
-    pub fn world_left(left: &WorldLeft<'_>) {
+    /// [`Hooks::name_decoration`].
+    pub fn name_decoration(
+        model: &players::PlayerModel,
+        sprites: &dyn players::Sprites,
+    ) -> Option<players::NameDecoration> {
+        all().iter().find_map(|h| h.name_decoration(model, sprites))
+    }
+
+    /// [`Hooks::player_mark`].
+    pub fn player_mark(uuid: u128) -> Option<players::Mark> {
+        all().iter().find_map(|h| h.player_mark(uuid))
+    }
+
+    /// [`Hooks::player_layers`].
+    pub fn player_layers(model: &players::PlayerModel, draw: &mut dyn players::PlayerDraw) {
         for hooks in all() {
-            hooks.world_left(left);
+            hooks.player_layers(model, draw);
         }
     }
 
-    /// [`Hooks::display`].
-    pub fn display(display: &Display) {
+    /// [`Hooks::camera`].
+    pub fn camera(own: &players::CameraView) -> Option<players::CameraOverride> {
+        all().iter().find_map(|h| h.camera(own))
+    }
+
+    /// [`Hooks::tick`].
+    pub fn tick(models: &mut dyn players::PlayerModels) {
         for hooks in all() {
-            hooks.display(display);
+            hooks.tick(models);
         }
     }
 
-    /// [`Hooks::crashed`].
-    pub fn crashed(crash: &Crash<'_>) {
-        for hooks in all() {
-            hooks.crashed(crash);
-        }
-    }
-
-    /// [`Hooks::knows_benchmark`]: whether any hook does.
-    pub fn knows_benchmark(scenario: &str) -> bool {
-        all().iter().any(|h| h.knows_benchmark(scenario))
-    }
-
-    /// [`Hooks::benchmark`]: starts the run on the first hook that knows the scenario. False when
-    /// none does.
-    pub fn benchmark(run: &Benchmark<'_>, control: Control) -> bool {
-        let Some(hooks) = all().iter().find(|h| h.knows_benchmark(run.scenario)) else {
-            return false;
-        };
-        hooks.benchmark(run, control);
-        true
-    }
     /// [`Hooks::tunnel`]: the first registered hook's resolver.
     pub fn tunnel() -> Option<&'static dyn tunnel::Resolver> {
         all().iter().find_map(|hooks| hooks.tunnel())
@@ -369,6 +235,7 @@ pub mod engine {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use players::PlayerModels as _;
     use std::sync::Mutex as StdMutex;
 
     /// Records what it heard. One process-wide list, as the game has: this test is the only
@@ -385,33 +252,148 @@ mod tests {
         fn published(&self, open: bool) {
             self.0.lock().unwrap().push(format!("published {open}"));
         }
-        fn startup(&self, milestone: Milestone, since_start: Duration) {
+        fn frame(&self, frame: &players::Frame, sprites: &mut dyn players::SpriteStore) {
             self.0
                 .lock()
                 .unwrap()
-                .push(format!("{milestone:?} {}", since_start.as_millis()));
+                .push(format!("frame {}", frame.connection));
+            if !sprites.has(1) {
+                sprites.put(1, vec![0; 64 * 64 * 4]);
+            }
         }
-        fn wants_frame_steps(&self, _home: &Path) -> bool {
-            true
+        fn name_decoration(
+            &self,
+            model: &players::PlayerModel,
+            sprites: &dyn players::Sprites,
+        ) -> Option<players::NameDecoration> {
+            let badge = sprites.get(1).map(|uv| players::Badge::new(uv, 0xFF0000));
+            (model.kind == players::Kind::Player)
+                .then(|| players::NameDecoration::new(Some(MARK), badge, Some(2.0)))
         }
-        fn knows_benchmark(&self, scenario: &str) -> bool {
-            scenario == "ocean"
+        fn player_mark(&self, uuid: u128) -> Option<players::Mark> {
+            (uuid == 9).then_some(MARK)
         }
-        fn benchmark(&self, run: &Benchmark<'_>, control: Control) {
-            let reply = control("status", Duration::from_secs(1)).unwrap_or_default();
-            self.0
-                .lock()
-                .unwrap()
-                .push(format!("benchmark {} {reply}", run.scenario));
+        fn camera(&self, own: &players::CameraView) -> Option<players::CameraOverride> {
+            Some(players::CameraOverride::new(own.age / 10.0))
         }
-        fn frame(&self, frame: &Frame<'_>) {
-            let step = frame
-                .slowest_step()
-                .map(|(name, ms)| format!(" {name} {ms}"));
-            self.0
-                .lock()
-                .unwrap()
-                .push(format!("frame {}{}", frame.ms, step.unwrap_or_default()));
+        /// A hat on the head, its brim turned by the model's age.
+        fn player_layers(&self, _: &players::PlayerModel, draw: &mut dyn players::PlayerDraw) {
+            let (Some(head), Some(uv)) = (draw.bone(players::Bone::Head), draw.sprite(1)) else {
+                return;
+            };
+            let turn = draw.ticks() / 100.0;
+            draw.draw(&HAT, head, uv, &mut |p| p.pose("brim")[4] = turn);
+        }
+        fn tick(&self, models: &mut dyn players::PlayerModels) {
+            let mut ids = Vec::new();
+            models.for_each(&mut |m| ids.push(m.id));
+            for id in ids {
+                models.set_body_pose(id, Some(std::sync::Arc::new(Still)));
+            }
+        }
+    }
+
+    #[derive(Debug)]
+    struct Still;
+    impl players::BodyPose for Still {
+        fn pose(&self, _: f32, _: &[[f32; 9]; 6], _: &mut [[f32; 9]; 6]) -> bool {
+            false
+        }
+    }
+
+    /// Two models, poses by id.
+    struct Two(std::collections::BTreeMap<u32, std::sync::Arc<dyn players::BodyPose>>);
+    impl players::PlayerModels for Two {
+        fn connection(&self) -> u64 {
+            1
+        }
+        fn for_each(&self, f: &mut dyn FnMut(players::PlayerModel)) {
+            for id in [3, 7] {
+                f(players::PlayerModel::new(
+                    id,
+                    players::Kind::Player,
+                    None,
+                    0,
+                    false,
+                ));
+            }
+        }
+        fn body_pose(&self, id: u32) -> Option<&std::sync::Arc<dyn players::BodyPose>> {
+            self.0.get(&id)
+        }
+        fn set_body_pose(&mut self, id: u32, pose: Option<std::sync::Arc<dyn players::BodyPose>>) {
+            match pose {
+                Some(p) => self.0.insert(id, p),
+                None => self.0.remove(&id),
+            };
+        }
+    }
+
+    const MARK: players::Mark = &[(0, 0, 8, 8, 0xFF00_00FF)];
+
+    /// One sprite slot, as the game's atlas has many.
+    #[derive(Default)]
+    struct Atlas(Option<(u64, usize)>);
+    impl players::SpriteStore for Atlas {
+        fn has(&self, id: u64) -> bool {
+            self.0.is_some_and(|(i, _)| i == id)
+        }
+        fn put(&mut self, id: u64, rgba: Vec<u8>) {
+            self.0 = Some((id, rgba.len()));
+        }
+    }
+    impl players::Sprites for Atlas {
+        fn get(&self, id: u64) -> Option<[f32; 4]> {
+            players::SpriteStore::has(self, id).then_some([0.0, 0.0, 0.5, 0.5])
+        }
+    }
+
+    static HAT: std::sync::LazyLock<std::sync::Arc<players::Mesh>> =
+        std::sync::LazyLock::new(|| {
+            let brim = players::Mesh::new("brim".into(), [0.0; 9], Vec::new(), Vec::new());
+            std::sync::Arc::new(players::Mesh::new(
+                "hat".into(),
+                [0.0; 9],
+                Vec::new(),
+                vec![brim],
+            ))
+        });
+
+    /// A player drawn at age 50, its head where the camera is; logs each draw.
+    #[derive(Default)]
+    struct Canvas(Vec<(String, [[f32; 4]; 4], [f32; 4], f32)>);
+    impl players::PlayerDraw for Canvas {
+        fn pass(&self) -> players::Pass {
+            players::Pass::World
+        }
+        fn ticks(&self) -> f32 {
+            50.0
+        }
+        fn bone(&mut self, bone: players::Bone) -> Option<[[f32; 4]; 4]> {
+            (bone == players::Bone::Head).then_some([[1.0, 0.0, 0.0, 0.0]; 4])
+        }
+        fn body_pose(&self) -> Option<&std::sync::Arc<dyn players::BodyPose>> {
+            None
+        }
+        fn sprite(&self, id: u64) -> Option<[f32; 4]> {
+            (id == 1).then_some([0.0, 0.0, 0.5, 0.5])
+        }
+        fn draw(
+            &mut self,
+            mesh: &std::sync::Arc<players::Mesh>,
+            matrix: [[f32; 4]; 4],
+            uv: [f32; 4],
+            pose: &mut dyn FnMut(&mut dyn players::PartPoses),
+        ) {
+            struct Rest([f32; 9]);
+            impl players::PartPoses for Rest {
+                fn pose(&mut self, _: &str) -> &mut [f32; 9] {
+                    &mut self.0
+                }
+            }
+            let mut brim = Rest(mesh.children[0].pose);
+            pose(&mut brim);
+            self.0.push((mesh.name.clone(), matrix, uv, brim.0[4]));
         }
     }
 
@@ -430,39 +412,46 @@ mod tests {
         for open in [false, true, true, true, false, false] {
             engine::published(open);
         }
-        // Each milestone once: the first time it is reached.
-        engine::startup(Milestone::CoreReady, Duration::from_millis(900));
-        engine::startup(Milestone::TitleShown, Duration::from_millis(1500));
-        engine::startup(Milestone::CoreReady, Duration::from_millis(4000));
-        // Any hook that wants the steps timed has them.
-        assert!(engine::wants_frame_steps(Path::new("home")));
-        engine::frame(&Frame::new(70.0, &|| Some(("render/terrain".into(), 50.0))));
-        // A benchmark runs on the hook that knows it, and on none when nobody does.
-        let run = |scenario| Benchmark {
-            scenario,
-            started: Instant::now(),
-            home: Path::new("home"),
-            game_dir: Path::new("game"),
-            version: "v0.2.31",
-            build: "v0.2.31",
-            simulation_distance: 12,
-            offscreen: true,
-        };
-        let control = || -> Control { Box::new(|line, _| Some(format!("{{{line}}}"))) };
-        assert!(engine::knows_benchmark("ocean") && !engine::knows_benchmark("nether"));
-        assert!(engine::benchmark(&run("ocean"), control()));
-        assert!(!engine::benchmark(&run("nether"), control()));
         engine::shutdown();
+        assert!(engine::any());
+        let mut atlas = Atlas::default();
+        let model = |kind| players::PlayerModel::new(5, kind, Some(9), 0, false);
+        // Before the frame put the sprite in: the decoration without its badge.
+        let before = engine::name_decoration(&model(players::Kind::Player), &atlas).unwrap();
+        assert!(before.badge.is_none() && before.top == Some(2.0));
+        engine::frame(&players::Frame::new(4, false), &mut atlas);
+        assert_eq!(atlas.0, Some((1, 64 * 64 * 4)));
+        let after = engine::name_decoration(&model(players::Kind::Player), &atlas).unwrap();
+        assert_eq!(
+            after.badge.map(|b| (b.uv, b.line)),
+            Some(([0.0, 0.0, 0.5, 0.5], 0xFF0000))
+        );
+        assert!(engine::name_decoration(&model(players::Kind::Mannequin), &atlas).is_none());
+        assert_eq!(engine::player_mark(9), Some(MARK));
+        assert_eq!(engine::player_mark(8), None);
+        let camera = engine::camera(&players::CameraView::new(5.0));
+        assert_eq!(camera.map(|c| c.distance), Some(0.5));
+        let mut canvas = Canvas::default();
+        engine::player_layers(&model(players::Kind::Player), &mut canvas);
+        assert_eq!(
+            canvas.0,
+            [(
+                "hat".to_owned(),
+                [[1.0, 0.0, 0.0, 0.0]; 4],
+                [0.0, 0.0, 0.5, 0.5],
+                0.5
+            )]
+        );
+        let mut models = Two(Default::default());
+        engine::tick(&mut models);
+        assert!(models.body_pose(3).is_some() && models.body_pose(7).is_some());
         assert_eq!(
             *RECORDER.0.lock().unwrap(),
             [
                 "started 0.2.31",
                 "published true",
                 "published false",
-                "CoreReady 900",
-                "TitleShown 1500",
-                "frame 70 render/terrain 50",
-                "benchmark ocean {status}",
+                "frame 4"
             ]
         );
         assert_eq!(register(&Silent), Err(TooLate));

crates/horizon-hooks/src/players.rs

@@ -0,0 +1,309 @@
+//! The players the game shows, as a crate above the engine sees them (Horizon's emotes, spec
+//! #14091): [`PlayerModels`] in [`crate::Hooks::tick`], [`Frame`] in [`crate::Hooks::frame`],
+//! [`BodyPose`], a pose laid over a player's body after its vanilla animation, what goes by their
+//! names, and the crate's [`Sprites`]. Plain types only: no engine type crosses this line.
+use std::sync::Arc;
+
+/// The player model's parts a [`BodyPose`] poses, in its order.
+pub const BODY_PARTS: [&str; 6] = [
+    "head",
+    "body",
+    "right_arm",
+    "left_arm",
+    "right_leg",
+    "left_leg",
+];
+
+/// A pose a crate lays over a player model's body after its vanilla animation (Horizon's emotes,
+/// docs/cosmetics.md), handed to the model with [`PlayerModels::set_body_pose`]. The crate
+/// downcasts its own back through [`std::any::Any`].
+pub trait BodyPose: std::any::Any + std::fmt::Debug + Send + Sync {
+    /// Poses the [`BODY_PARTS`] at `age` (the model's ticks): `at_rest` holds each part before the
+    /// animation, `poses` as the animation left it (x, y, z, x/y/z rotation, x/y/z scale); a part
+    /// the model lacks holds the identity in both and is not written back. False when it poses
+    /// nothing at `age` (`poses` is then ignored).
+    fn pose(&self, age: f32, at_rest: &[[f32; 9]; 6], poses: &mut [[f32; 9]; 6]) -> bool;
+}
+
+/// What a player model is.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Kind {
+    /// The player of this window, seen from outside (third person, the inventory picture).
+    Own,
+    /// Another player.
+    Player,
+    /// A mannequin: a player model with no player.
+    Mannequin,
+}
+
+/// One player model, as [`PlayerModels::for_each`] shows it.
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct PlayerModel {
+    /// Its entity id on this connection ([`PlayerModels::connection`]).
+    pub id: u32,
+    pub kind: Kind,
+    /// The player's UUID as the server gave it (the window's own: its profile); None for
+    /// mannequins.
+    pub uuid: Option<u128>,
+    /// Its age in ticks, the clock a [`BodyPose`] is timed on.
+    pub age: u32,
+    /// It moved sideways since the last tick (more than 0.01 blocks).
+    pub moved: bool,
+    /// What it wears that covers a crate's drawing.
+    pub gear: Gear,
+    /// It is drawn invisible (the effect, or a trader's disguise).
+    pub invisible: bool,
+}
+
+impl PlayerModel {
+    pub fn new(id: u32, kind: Kind, uuid: Option<u128>, age: u32, moved: bool) -> Self {
+        Self {
+            id,
+            kind,
+            uuid,
+            age,
+            moved,
+            gear: Gear::default(),
+            invisible: false,
+        }
+    }
+
+    /// With what it wears and whether it is invisible.
+    pub fn looks(self, gear: Gear, invisible: bool) -> Self {
+        Self {
+            gear,
+            invisible,
+            ..self
+        }
+    }
+}
+
+/// What a player model wears where a crate may draw.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct Gear {
+    /// A helmet or a head item.
+    pub head: bool,
+    /// A chestplate (an elytra is on the back).
+    pub chest: bool,
+    /// A cape or an elytra.
+    pub back: bool,
+}
+
+impl Gear {
+    pub fn new(head: bool, chest: bool, back: bool) -> Self {
+        Self { head, chest, back }
+    }
+}
+
+/// The player models of the world this window shows, once a tick ([`crate::Hooks::tick`]).
+pub trait PlayerModels {
+    /// Changes on every join: entity ids are per connection, so what a crate keeps by id goes
+    /// when this changes.
+    fn connection(&self) -> u64;
+    /// Each player model in view (other players and mannequins; the window's own model first).
+    fn for_each(&self, f: &mut dyn FnMut(PlayerModel));
+    /// The pose laid over model `id`, if any.
+    fn body_pose(&self, id: u32) -> Option<&Arc<dyn BodyPose>>;
+    /// Lays `pose` over model `id` (None: its vanilla animation alone). Unknown ids are ignored.
+    fn set_body_pose(&mut self, id: u32, pose: Option<Arc<dyn BodyPose>>);
+}
+
+/// What [`crate::Hooks::frame`] gets, once a frame before drawing.
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct Frame {
+    /// As [`PlayerModels::connection`]; 0 with no world.
+    pub connection: u64,
+    /// The world is the window's own single-player one: its server names the player by an
+    /// offline profile.
+    pub solo: bool,
+}
+
+impl Frame {
+    pub fn new(connection: u64, solo: bool) -> Self {
+        Self { connection, solo }
+    }
+}
+
+/// Rectangles drawn before a name: x, y, width, height in text pixels from the name line's top
+/// left corner (a pixel left of its background), and `0xAARRGGBB`.
+pub type Mark = &'static [(u8, u8, u8, u8, u32)];
+
+/// What a crate draws by a player's name over their head ([`crate::Hooks::name_decoration`]).
+#[derive(Clone, Copy, Debug, Default)]
+#[non_exhaustive]
+pub struct NameDecoration {
+    /// Before the name.
+    pub mark: Option<Mark>,
+    /// After the name, and a line under it.
+    pub badge: Option<Badge>,
+    /// How high the crate's drawing on the body gets above the neck, in model pixels: the tag
+    /// goes up over it.
+    pub top: Option<f32>,
+}
+
+impl NameDecoration {
+    pub fn new(mark: Option<Mark>, badge: Option<Badge>, top: Option<f32>) -> Self {
+        Self { mark, badge, top }
+    }
+}
+
+/// A badge after a name: 8 text pixels square, a pixel right of the background.
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct Badge {
+    /// Its picture: a part of a [`Sprites`] sprite, in atlas coordinates (u0, v0, u1, v1).
+    pub uv: [f32; 4],
+    /// The line under the name, `0xRRGGBB`.
+    pub line: u32,
+}
+
+impl Badge {
+    pub fn new(uv: [f32; 4], line: u32) -> Self {
+        Self { uv, line }
+    }
+}
+
+/// A crate's pictures in the game's atlas, by ids of its own: 64×64 RGBA each, in the slots skins
+/// use (one no frame drew for a while may go). Read while drawing.
+pub trait Sprites {
+    /// Where sprite `id` is (u0, v0, u1, v1), and it is kept this frame. None until
+    /// [`SpriteStore::put`] put it there.
+    fn get(&self, id: u64) -> Option<[f32; 4]>;
+}
+
+/// Where a crate puts its [`Sprites`], in [`crate::Hooks::frame`].
+pub trait SpriteStore {
+    /// Sprite `id` is in the atlas.
+    fn has(&self, id: u64) -> bool;
+    /// Puts sprite `id` in the atlas (64×64 RGBA), if a slot is free.
+    fn put(&mut self, id: u64, rgba: Vec<u8>);
+}
+
+/// The window's own model, as [`crate::Hooks::camera`] sees it.
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct CameraView {
+    /// Its age in ticks, with the frame's part of a tick.
+    pub age: f32,
+}
+
+impl CameraView {
+    pub fn new(age: f32) -> Self {
+        Self { age }
+    }
+}
+
+/// How a crate moves the camera in third person.
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct CameraOverride {
+    /// How far it stands back, as a share of the usual distance.
+    pub distance: f32,
+}
+
+impl CameraOverride {
+    pub fn new(distance: f32) -> Self {
+        Self { distance }
+    }
+}
+
+/// A model a crate draws on players, as the game's own models are: a tree of parts, 16 units a
+/// block, y down. Build it once and keep the `Arc`: the engine prepares it for the GPU once, by
+/// the `Arc`'s address, while the crate holds it.
+#[derive(Clone, Debug, Default)]
+#[non_exhaustive]
+pub struct Mesh {
+    /// What [`PartPoses::pose`] names it by.
+    pub name: String,
+    /// At rest: x, y, z, x/y/z rotation (radians), x/y/z scale.
+    pub pose: [f32; 9],
+    pub quads: Vec<Quad>,
+    pub children: Vec<Mesh>,
+}
+
+impl Mesh {
+    pub fn new(name: String, pose: [f32; 9], quads: Vec<Quad>, children: Vec<Mesh>) -> Self {
+        Self {
+            name,
+            pose,
+            quads,
+            children,
+        }
+    }
+}
+
+/// One face of a [`Mesh`].
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct Quad {
+    pub normal: [f32; 3],
+    /// Its corners: x, y, z, then u, v across the sprite (0 to 1).
+    pub vertices: [[f32; 5]; 4],
+}
+
+impl Quad {
+    pub fn new(normal: [f32; 3], vertices: [[f32; 5]; 4]) -> Self {
+        Self { normal, vertices }
+    }
+}
+
+/// A part of the player's body a crate draws on.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Bone {
+    Head,
+    Body,
+    RightArm,
+    LeftArm,
+    RightLeg,
+    LeftLeg,
+}
+
+impl Bone {
+    /// Its name among [`BODY_PARTS`].
+    pub fn part(self) -> &'static str {
+        BODY_PARTS[self as usize]
+    }
+}
+
+/// Which picture of a player is drawn.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Pass {
+    /// In the world, seen by the camera.
+    World,
+}
+
+/// The poses of a [`Mesh`]'s parts for one [`PlayerDraw::draw`], each at rest to begin with.
+pub trait PartPoses {
+    /// Part `name`'s pose, to change (see [`Mesh::pose`]); a name the mesh lacks gets a pose that
+    /// is not used.
+    fn pose(&mut self, name: &str) -> &mut [f32; 9];
+}
+
+/// Where a crate draws on a player model ([`crate::Hooks::player_layers`]). Matrices are
+/// column-major, relative to the camera, in blocks.
+pub trait PlayerDraw {
+    fn pass(&self) -> Pass;
+    /// The model's age in ticks, with the frame's part of a tick.
+    fn ticks(&self) -> f32;
+    /// Where `bone` is as the body is drawn this frame; None if the model has no such part.
+    fn bone(&mut self, bone: Bone) -> Option<[[f32; 4]; 4]>;
+    /// The pose laid over the model's body ([`PlayerModels::set_body_pose`]), if any.
+    fn body_pose(&self) -> Option<&Arc<dyn BodyPose>>;
+    /// As [`Sprites::get`].
+    fn sprite(&self, id: u64) -> Option<[f32; 4]>;
+    /// Draws `mesh` at `matrix`, textured by the sprite part `uv` (u0, v0, u1, v1) and lit as the
+    /// model is; `pose` poses its parts first.
+    fn draw(
+        &mut self,
+        mesh: &Arc<Mesh>,
+        matrix: [[f32; 4]; 4],
+        uv: [f32; 4],
+        pose: &mut dyn FnMut(&mut dyn PartPoses),
+    );
+}

crates/horizon-official/Cargo.toml

@@ -15,8 +15,6 @@ horizon-game = { path = "../horizon-game" }
 horizon-platform = { path = "../horizon-platform" }
 horizon-heartbeat = { path = "../horizon-heartbeat" }
 horizon-friends = { path = "../horizon-friends", features = ["game"] }
-horizon-telemetry = { path = "../horizon-telemetry", default-features = false, features = ["game"] }
-horizon-bench = { path = "../horizon-bench", features = ["game"] }
 log = "0.4"
 
 [build-dependencies]

crates/horizon-official/src/lib.rs

@@ -11,15 +11,11 @@
 use horizon_platform::hooks::{self, Hooks};
 
 /// Every Horizon part in the game, in the order its hooks run.
-const PARTS: [&dyn Hooks; 4] = [
+const PARTS: [&dyn Hooks; 2] = [
     // The anonymous "I'm playing" ping.
     &horizon_heartbeat::HOOKS,
     // Play with Friends: `friend:` addresses join through its tunnel.
     &horizon_friends::game::HOOKS,
-    // Opt-in telemetry: the play session's summary and crash reports, kept for the launcher.
-    &horizon_telemetry::game::HOOKS,
-    // `--benchmark SCENARIO`: the built-in benchmark (docs/benchmark.md).
-    &horizon_bench::game::HOOKS,
 ];
 
 /// Registers Horizon's in-game parts with the game. The executable calls it before it runs the

crates/horizon-optifine/Cargo.toml

@@ -13,7 +13,7 @@ regex = { version = "1", default-features = false, features = ["std", "unicode-p
 
 [dev-dependencies]
 # `cpu_seconds` for cem_expr_bench.
-horizon-system = { path = "../horizon-system" }
+horizon-bench = { path = "../horizon-bench" }
 
 [lints]
 workspace = true

crates/horizon-optifine/examples/cem_expr_bench.rs

@@ -101,7 +101,7 @@ fn main() {
     let mut slots = vec![0.0f32; NAMES.len()];
     let frames = 2_000_000u32;
     let pid = std::process::id();
-    let cpu = horizon_system::cpu_seconds(pid);
+    let cpu = horizon_bench::cpu_seconds(pid);
     let start = Instant::now();
     for frame in 0..frames {
         // An entity walking in and out of water.
@@ -125,7 +125,7 @@ fn main() {
         evals / elapsed / 1e6,
         elapsed * 1e6 / f64::from(frames),
     );
-    match cpu.zip(horizon_system::cpu_seconds(pid)) {
+    match cpu.zip(horizon_bench::cpu_seconds(pid)) {
         Some((before, after)) => println!(
             "  cpu time {:.1} ns per expression, {:.2} us per entity frame",
             (after - before) * 1e9 / evals,

crates/horizon-platform/src/lib.rs

@@ -46,10 +46,15 @@ pub use horizon_server_files as server_files;
 /// [`hooks::register`] it before the game starts (docs/layers.md, "How a Horizon crate plugs
 /// in"). The engine's dispatch side is not part of the API.
 pub mod hooks {
-    pub use horizon_hooks::{
-        Benchmark, Control, Crash, Display, Frame, Gpu, Hooks, Milestone, Started, TooLate,
-        WorldLeft, register, tunnel,
+    /// The players the game shows (`horizon_hooks::players`): the views [`Hooks::frame`] and
+    /// [`Hooks::tick`] get, the pose a crate lays over a player's body, what goes by their names,
+    /// the crate's sprites, the camera, and what a crate draws on them.
+    pub use horizon_hooks::players::{
+        BODY_PARTS, Badge, BodyPose, Bone, CameraOverride, CameraView, Frame, Gear, Kind, Mark,
+        Mesh, NameDecoration, PartPoses, Pass, PlayerDraw, PlayerModel, PlayerModels, Quad,
+        SpriteStore, Sprites,
     };
+    pub use horizon_hooks::{Hooks, Started, TooLate, register, seat, tunnel};
 }
 
 /// The settings store (`horizon_hooks::settings`): a crate's own `key:value` lines in the game

crates/horizon-system/src/lib.rs

@@ -229,8 +229,7 @@ fn os_version() -> Option<String> {
     }
 }
 
-/// The CPU's name (`Apple M4 Pro`, `AMD Ryzen 7 7700X 8-Core Processor`).
-pub fn cpu() -> Option<String> {
+fn cpu() -> Option<String> {
     if cfg!(target_os = "linux") {
         read("/proc/cpuinfo").and_then(|t| linux_cpu_name(&t))
     } else if cfg!(target_os = "macos") {
@@ -282,8 +281,7 @@ fn processor_name_from_reg_query(query: &str) -> Option<String> {
     })
 }
 
-/// Installed memory, in bytes.
-pub fn ram_bytes() -> Option<u64> {
+fn ram_bytes() -> Option<u64> {
     if cfg!(target_os = "linux") {
         let kib = read("/proc/meminfo").and_then(|t| field(&t, "MemTotal"))?;
         kib.split_whitespace()
@@ -742,64 +740,6 @@ impl Machine {
     }
 }
 
-/// The one-minute load average: above about the number of threads the machine was busy.
-pub fn load_average() -> Option<f64> {
-    if cfg!(target_os = "macos") {
-        // "{ 1.23 1.10 1.00 }"
-        command_output("sysctl", &["-n", "vm.loadavg"])?
-            .trim_start_matches('{')
-            .split_whitespace()
-            .next()?
-            .parse()
-            .ok()
-    } else {
-        std::fs::read_to_string("/proc/loadavg")
-            .ok()?
-            .split_whitespace()
-            .next()?
-            .parse()
-            .ok()
-    }
-}
-
-/// Resident memory of a process, in bytes (macOS, Linux).
-pub fn rss_bytes(pid: u32) -> Option<u64> {
-    if cfg!(target_os = "macos") {
-        return command_output("ps", &["-o", "rss=", "-p", &pid.to_string()])?
-            .parse::<u64>()
-            .ok()
-            .map(|kb| kb * 1024);
-    }
-    let status = std::fs::read_to_string(format!("/proc/{pid}/status")).ok()?;
-    let line = status.lines().find(|l| l.starts_with("VmRSS:"))?;
-    line.split_whitespace()
-        .nth(1)?
-        .parse::<u64>()
-        .ok()
-        .map(|kb| kb * 1024)
-}
-
-/// CPU time a process has used, user and system, in seconds (macOS, Linux).
-pub fn cpu_seconds(pid: u32) -> Option<f64> {
-    if cfg!(target_os = "macos") {
-        // "[[dd-]hh:]mm:ss.cc"
-        let time = command_output("ps", &["-o", "time=", "-p", &pid.to_string()])?;
-        let (rest, days) = match time.split_once('-') {
-            Some((d, rest)) => (rest.to_owned(), d.parse::<f64>().ok()?),
-            None => (time, 0.0),
-        };
-        let seconds = rest.split(':').try_fold(0.0, |acc, part| {
-            part.parse::<f64>().ok().map(|v| acc * 60.0 + v)
-        })?;
-        return Some(days * 86_400.0 + seconds);
-    }
-    // utime and stime, fields 14 and 15, in clock ticks (100 per second on Linux).
-    let stat = std::fs::read_to_string(format!("/proc/{pid}/stat")).ok()?;
-    let fields: Vec<&str> = stat.rsplit_once(')')?.1.split_whitespace().collect();
-    let ticks: f64 = fields.get(11)?.parse::<f64>().ok()? + fields.get(12)?.parse::<f64>().ok()?;
-    Some(ticks / 100.0)
-}
-
 /// The GPU's maker from its name and the vendor ID wgpu reports (0: none, as on Metal).
 pub fn gpu_vendor(name: &str, vendor_id: u32) -> &'static str {
     match vendor_id {
@@ -1065,13 +1005,4 @@ mod tests {
         let dir = std::env::temp_dir();
         assert!(["", "nvme", "ssd", "hdd"].contains(&Machine::detect_in(Some(&dir)).storage));
     }
-
-    #[test]
-    fn this_process_is_measured() {
-        if cfg!(any(target_os = "macos", target_os = "linux")) {
-            assert!(load_average().is_some());
-            assert!(rss_bytes(std::process::id()).unwrap() > 1 << 20);
-            assert!(cpu_seconds(std::process::id()).unwrap() >= 0.0);
-        }
-    }
 }

crates/horizon-telemetry/Cargo.toml

@@ -18,16 +18,12 @@ ruzstd = "0.9"
 getrandom = "0.3"
 # Sending, for the launcher (and the game's "I'm playing" ping); the ingest server builds without it.
 ureq = { version = "2", default-features = false, features = ["tls"], optional = true }
-log = { version = "0.4", optional = true }
 
 [features]
 default = ["upload", "live"]
 upload = ["dep:ureq"]
 # The "I'm playing" ping and reading the live count (`live`), for the game and the launcher.
 live = ["dep:ureq"]
-# The game's part (`game`): the play session's summary and crash reports, kept through the
-# platform's hooks. The official executable turns it on.
-game = ["dep:log"]
 
 [[test]]
 name = "consent_gating"

crates/horizon-telemetry/src/lib.rs

@@ -15,8 +15,6 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 pub mod batch;
 pub mod consent;
-#[cfg(feature = "game")]
-pub mod game;
 pub mod live;
 pub mod outbox;
 pub mod payload;

docs/architecture.md

@@ -65,7 +65,7 @@ command above to inspect the selection rather than relying on historical counts.
 | 36 | Audio and music (38) | `R/audio.rs`, `R/sound_engine.rs`, `R/sound_events.rs`, `L/music.rs`, `G/music.rs`, `L/ambience.rs`, `G/subtitle_hud.rs` | sound_engine, sound_event, music, situational_music, ambient_sound, subtitle |
 | 37 | Integrated server and levels (34) | `G/integrated.rs`, `G/levels.rs`, `G/server_travel.rs` | server_dimension_players, `lan_e2e` (server-thread by default; portals, levels, distance, lava) |
 | 38 | Command parsing (34) | `C/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`); `cargo test -p horizon-command` | command_parse (corpus `tools/command_parse_corpus.py`) |
-| 39 | Benchmarks and telemetry (34) | `crates/horizon-bench/src/game.rs`, `crates/horizon-telemetry/src/game.rs`, `tools/perf_bench.py`, `crates/horizon-telemetry*/`, `crates/horizon-bench/` | `python3 -m unittest tests.test_perf_bench`; [benchmark.md](benchmark.md) |
+| 39 | Benchmarks and telemetry (34) | `L/benchmark.rs`, `L/telemetry.rs`, `tools/perf_bench.py`, `crates/horizon-telemetry*/`, `crates/horizon-bench/` | `python3 -m unittest tests.test_perf_bench`; [benchmark.md](benchmark.md) |
 | 40 | Explosions and TNT (31) | `G/explosion.rs`, `G/tnt.rs` | lan_e2e blast; no dedicated harness yet |
 
 Controller glyphs (`R/pad_glyph.rs`, drawn by the gameplay guide, notices, splitscreen prompts and declared

docs/benchmark.md

@@ -42,8 +42,6 @@ horizon-client --benchmark standard --render-distance 16
 
 It starts at the title screen, creates the world `horizon-benchmark` (seed 1234, creative; the next run replaces it, and it never touches a world it didn't create), flies the four scenes as above, writes a report to `benchmarks/` in the game folder and quits. `--benchmark village` (or `forest`, `ocean`, `mountain`) flies one scene. For the run only, VSync is off, the frame rate unlimited and the game doesn't pause or slow down without focus; your options are not changed. Your other settings (render distance unless given, graphics, window size) are used as they are, and stored in the report, so compare reports with the same conditions.
 
-The run is a part of the official build (`horizon-official`, which the releases ship as `horizon-client`; [docs/layers.md](layers.md)). From source: `cargo run --release -p horizon-official -- --benchmark standard`; horizon-client's own executable and horizon-plain refuse `--benchmark`.
-
 The report is the [benchmark report format](benchmark-report.md): startup to the title screen and to in-world, each scene's chunk load time, chunks generated and section meshes built, every flight's frame figures and histogram, resident and GPU memory, the binary's size, and the machine (OS, CPU, RAM, GPU, driver, backend, display), the load average before the run and whether it ran on battery. If you allowed benchmark uploads (the launcher's data collection choices, [docs/telemetry.md](telemetry.md)), the same report, dated to the day and without local fields, is kept for the launcher to send; otherwise it stays on your machine.
 
 ## Reproduce it

docs/graphics.md

@@ -45,7 +45,7 @@ Every setting applies at once, except worker threads, the graphics API and trans
 
 **Translucent batching** (Advanced, after Graphics API; on by default, `batchTranslucent` in `horizon-graphics.txt`, a new key so that the `translucentBatching:false` earlier builds saved for everyone doesn't keep it off; it applies at the next start or resource reload, and is no part of a preset) gives water, glass, ice and other translucent quads a vertex buffer of their own, with pages up to 2 GiB, and their sorted indices the same: the back-to-front list then stays in one page and goes out in a few draw calls instead of switching pages every few sections. The picture is the same and frames come faster, most over water and at high render distances (RTX 4090 at 1080p: 4 to 16% more FPS at render distance 32; over the ocean at 64, 354 draw calls a frame instead of 3,832 and 43% more FPS); it costs a little video memory, as solid and translucent quads no longer share free space (terrain meshes take 1 to 15% more at render distance 32, 5 to 10% more at 64). The large pages shrink once the view has settled (a second after terrain stops arriving): one much larger than what it holds, as after a teleport or a lower render distance, moves into a page of the right size, about 32 MiB a frame. It needs indirect multi-draw that isn't OpenGL's (which loops over the entries on the CPU), and devices whose vanilla frames draw flat (Metal, Intel Gen11 and Gen12 on Vulkan) don't offer it: there the switch is greyed out and reads Off, and macOS doesn't show it. A `shaders/` pack's terrain and shadow passes, and the `[shadow]` pass of one of Horizon's own packs, draw flat where the device can, reading translucent quads beside their section's solid ones: while such a pack runs they go back there. Such a pack picked at the start has the world laid out for it from the first; switching to or from one later meshes the world again.
 
-**HDR** has its own page and three choices: **Off** (the default) keeps SDR; **On** uses HDR wherever the display path offers it; **Auto** uses HDR only while the system reports HDR active for the window's display and an HDR output is offered, otherwise SDR. On is unavailable where no HDR output is offered; Auto stays selectable before the system is queried, including on an SDR display. The controls below work only while HDR is active. The existing `hdr` key in `horizon-graphics.txt` saves On as `true`, Off as `false`, and Auto as `auto`; old boolean files keep their meaning, and older builds ignore `auto` and keep their Off default. It presents to an HDR10 swapchain (`Rgb10a2Unorm`, BT.2020 with the PQ curve) or, where only that is offered, an scRGB one (`Rgba16Float`, extended linear sRGB), on displays and compositors that offer either; `HORIZON_HDR_OUTPUT=pq` or `scrgb` allows only one, and offers it to an `--offscreen` run, which has no display to ask: there HDR is drawn and screenshotted (the `-hdr.png` below) but not presented, and automatic brightness takes 203 and 1000 nits, so HDR can be checked without an HDR display. The frame is drawn exactly as in SDR, in vanilla's gamma space (into a 16-bit target (`Rgba16Unorm`, which clips at white after every pass as the 8-bit one does) when HDR is on as the renderer is made, at the start or a resource reload, with **Smooth Gradients** on (the default, `hdrSmoothGradients`; off, the 8-bit frame) and where the device can draw into it, else an 8-bit one; HDR switched off after that keeps the 16-bit frame and copies it to the 8-bit swapchain, without frame generation, until the next start; with `HORIZON_HDR_FRAME=float` the frame follows HDR, Smooth Gradients and the picked pack unless it was refused, is missing or its owner mod is off (the renderer is made again on the same device before the next frame, and the world meshed again), and with no shader pack or a 0.2 one, where the device can keep the HUD on a layer of its own, a float one (`Rgba16Float`) takes the 16-bit one's place whatever Smooth Gradients is: the world's shaders write light past white into it themselves, and it holds no marks (below)), and a last pass (`hdr.wgsl`) decodes it to linear light at the **Paper White** and lifts light sources (blocks that emit light, lava, the sun and the moon) towards the **Peak Brightness**; everything else stays as in SDR. The mesher puts the light a block's face emits in its vertex colour's alpha (`EMISSION_BITS`), the frame's alpha carries the mark, and only pixels that still show the world before the hand and HUD are lifted. On Vulkan, `horizon-hdr` sends HDR metadata (MaxCLL and mastering luminance at the peak, MaxFALL as 0, unknown, since a frame's average isn't known ahead of it), which wgpu doesn't: without it a compositor may clip everything above SDR white. Paper White and Peak Brightness are **Auto** by default: they follow what the system reports for the display. Set by hand, on the slider and in calibration alike, Paper White runs from 10 to 480 nits by 10, and Peak Brightness from 200 to 2000 nits by 50, where most displays' peaks are, then by 500 up to PQ's 10 000, for displays that are brighter or tone-map the signal themselves; `hdrPeak` keeps any value from 200 to 10 000. On Wayland that's the compositor's preferred image description of the window (`wp_color_management_v1`, in `horizon-hdr`'s `wayland.rs`), watched while HDR is On or Auto (Off does not ask the system); the preferred target peak above reference white reports HDR headroom, so a move to another output or a recalibrated desktop applies at once. KWin maps the content's reference white (203 nits) onto the desktop's SDR white, so Auto puts Paper White at 203 and Peak Brightness at the display's peak over that ratio; Hyprland (0.57) doesn't: it reports the standard 203 as reference white, so Auto puts Paper White at 203, and it shows HDR windows below its own SDR white (`sdr_max_luminance`, which it doesn't report): in a test, a white browser page was brighter than both the game's white and a 1000-nit patch in mpv. Other compositors are unchecked. On Windows Auto takes what wgpu reads from the OS (`Surface::display_hdr_info`: DXGI's `MaxLuminance` and the SDR white level of Windows' SDR content brightness slider, both absolute nits), read again every 2 seconds since no event says they changed; the same reading's current output colour-space state drives Auto (an offered Direct3D 12 HDR10 swapchain alone does not). macOS reports potential EDR headroom, fixed for a display rather than following desktop brightness: Auto uses it above 1, or stays SDR if it is missing or invalid. macOS reports no absolute nits or separate HDR-mode flag. X11, OpenGL, other paths without a report and offscreen runs keep Auto in SDR. Windows' SDR white is the player's own slider, but its peak is mostly the display's EDID figure, which often runs high: Auto still uses it, over the 1000-nit default, but the HDR Line truncated
+**HDR** has its own page and three choices: **Off** (the default) keeps SDR; **On** uses HDR wherever the display path offers it; **Auto** uses HDR only while the system reports HDR active for the window's display and an HDR output is offered, otherwise SDR. On is unavailable where no HDR output is offered; Auto stays selectable before the system is queried, including on an SDR display. The controls below work only while HDR is active. The existing `hdr` key in `horizon-graphics.txt` saves On as `true`, Off as `false`, and Auto as `auto`; old boolean files keep their meaning, and older builds ignore `auto` and keep their Off default. It presents to an HDR10 swapchain (`Rgb10a2Unorm`, BT.2020 with the PQ curve) or, where only that is offered, an scRGB one (`Rgba16Float`, extended linear sRGB), on displays and compositors that offer either; `HORIZON_HDR_OUTPUT=pq` or `scrgb` allows only one, and offers it to an `--offscreen` run, which has no display to ask: there HDR is drawn and screenshotted (the `-hdr.png` below) but not presented, and automatic brightness takes 203 and 1000 nits, so HDR can be checked without an HDR display. The frame is drawn exactly as in SDR, in vanilla's gamma space (into a 16-bit target (`Rgba16Unorm`, which clips at white after every pass as the 8-bit one does) when HDR is on as the renderer is made, at the start or a resource reload, with **Smooth Gradients** on (the default, `hdrSmoothGradients`; off, the 8-bit frame) and where the device can draw into it, else an 8-bit one; HDR switched off after that keeps the 16-bit frame and copies it to the 8-bit swapchain, without frame generation, until the next start; with `HORIZON_HDR_FRAME=float` the frame follows HDR, Smooth Gradients and the picked pack unless it was refused, is missing or its owner mod is off (the renderer is made again on the same device before the next frame, and the world meshed again), and with no shader pack or a 0.2 one, where the device can keep the HUD on a layer of its own, a float one (`Rgba16Float`) takes the 16-bit one's place whatever Smooth Gradients is: the world's shaders write light past white into it themselves, and it holds no marks (below)), and a last pass (`hdr.wgsl`) decodes it to linear light at the **Paper White** and lifts light sources (blocks that emit light, lava, the sun and the moon) towards the **Peak Brightness**; everything else stays as in SDR. The mesher puts the light a block's face emits in its vertex colour's alpha (`EMISSION_BITS`), the frame's alpha carries the mark, and only pixels that still show the world before the hand and HUD are lifted. On Vulkan, `horizon-hdr` sends HDR metadata (MaxCLL and mastering luminance at the peak, MaxFALL as 0, unknown, since a frame's average isn't known ahead of it), which wgpu doesn't: without it a compositor may clip everything above SDR white. Paper White and Peak Brightness are **Auto** by default: they follow what the system reports for the display. Set by hand, on the slider and in calibration alike, Paper White runs from 10 to 480 nits by 10, and Peak Brightness from 200 to 2000 nits by 50, where most displays' peaks are, then by 500 up to PQ's 10 000, for displays that are brighter or tone-map the signal themselves; `hdrPeak` keeps any value from 200 to 10 000. On Wayland that's the compositor's preferred image description of the window (`wp_color_management_v1`, in `horizon-hdr`'s `wayland.rs`), watched while HDR is On or Auto (Off does not ask the system); the preferred target peak above reference white reports HDR headroom, so a move to another output or a recalibrated desktop applies at once. KWin maps the content's reference white (203 nits) onto the desktop's SDR white, so Auto puts Paper White at 203 and Peak Brightness at the display's peak over that ratio; Hyprland (0.57) doesn't: it reports the standard 203 as reference white, so Auto puts Paper White at 203, and it shows HDR windows below its own SDR white (`sdr_max_luminance`, which it doesn't report): in a test, a white browser page was brighter than both the game's white and a 1000-nit patch in mpv. Other compositors are unchecked. On Windows Auto takes what wgpu reads from the OS (`Surface::display_hdr_info`: DXGI's `MaxLuminance` and the SDR white level of Windows' SDR content brightness slider, both absolute nits), read again every 2 seconds since no event says they changed; the same reading's current output colour-space state drives Auto (an offered Direct3D 12 HDR10 swapchain alone does not). macOS reports potential EDR headroom, fixed for a display rather than following desktop brightness: Auto uses it above 1, or stays SDR if it is missing or invalid. macOS reports no absolute nits or separate HDR-mode flag. X11, OpenGL, other paths without a report and offscreen runs keep Auto in SDR. Windows' luminance readings often come from the display's EDID and may run optimistic, and this is untested so far. **Calibrate...** (`hdr_calibration.rs`) sets Black Level, Peak Line truncated
 
 With `HORIZON_HDR_FRAME=float`, HDR on and no shader pack or a 0.2 one, devices with independent blending draw the frame in layers ([hdr-linear-light.md](design/hdr-linear-light.md), The HUD and menus). The world's shaders write their own light into the frame instead of a mark (`hdr_written`, `hdr_light.wgsl`), a whole frame at a time, so glass, water, clouds and particles each lay their own light over the light behind them. Improved Transparency's layers write their own light too, before they are weighted and composited. No float frame holds marks: under a 0.2 pack Horizon's own draws keep their colour, alpha 1 where opaque and coverage where blended, HDR output lifts nothing, and the pack's `[tonemap]` takes the tone curve's place below (one or the other runs, never both); without the HUD layer (HDR off, or a device without independent blending) its float frame finishes on the swapchain's 8 bits before the camera overlays, which then draw with the HUD as in SDR, and HDR output stays off. The camera overlays (vignette, pumpkin, powder snow, portal, nausea), post effects and entity outlines draw on light. After the post effects and before the camera overlays, the tone curve eases that light into the peak (`Hdr::tonemap`) in place of HDR lighting's own easing and the light sources' cap at the peak: up to 60% of the peak light stays as it is, and above it ITU-R BT.2390's EETF in PQ rolls it off, on its brightest channel so it keeps its hue. The HUD and menus then draw on an 8-bit target of their own, the world clipped to white, as they found the frame before (each draw clips at white as there), and write how much of the world they hide into an R8 coverage target. The last pass lays the HUD over the world's light by that coverage, in gamma as the HUD blends: light behind see-through HUD shows as vanilla weights the HUD over it, and none shows through what covers it. The menu blur blurs that picture, light above white included, and the menu draws over the result. UI Brightness scales the HUD's own part, not the world under it. A screenshot maps the world's light into SDR, unchanged up to 0.6 of paper white in linear light and smoothly rolled towards white above it, with one scale for all RGB channels to keep their hue (where Horizon lifts nothing, with HDR Lighting off or under a 0.2 pack, the world is clipped at white as SDR draws it); the HUD's own part stays as drawn, whatever UI Brightness is, over the mapped world by its coverage. The world's icon uses the same mapping without the HUD; the `-hdr.png` beside a screenshot keeps the whole HDR picture. `HORIZON_HDR_DEBUG=coverage` tints the coverage magenta for inspection.
 

docs/layers.md

@@ -288,19 +288,12 @@ build pays nothing.
 
 The hooks today: `started` (once, when someone plays: not a dedicated server, a benchmark or an automated run),
 `published` (the world opened to or closed from LAN or friends, on change), `shutdown` (the window closed, the
-world saved), and the play session's: `startup` (core-ready, rest-ready, the title's first frame, once each),
-`wants_frame_steps` (asked once: time the render thread's steps), `world_shown` (a world's first frame), `frame`
-(every frame played), `world_left` (the session's end, with its settings), `display` (the screen the window is on)
-`crashed` (each crash, before its report is saved), and `knows_benchmark` and `benchmark` (`--benchmark SCENARIO`:
-the part that knows the scenario drives the game through horizon-ctl's command queue); and `tunnel` (the resolver
-of `friend:` addresses, Play with Friends'). Opt-in telemetry (`horizon_telemetry::game`) and the benchmark
-(`horizon_bench::game`), both registered by `horizon-official`, hear the game through these only. **A hook you need
-and don't find:** add a method with an empty default to `Hooks` and a function in `horizon_hooks::engine` that the
-engine calls where vanilla does the matching thing; give it plain data or a type the engine owns, never one from
-above. A hook that needs engine types the platform doesn't expose yet (a draw context for HUD and chat overlays, a
-settings page) comes with that type's platform API (M6). An extension point that belongs to one subsystem (an input
-source, the compositor) lives in the engine crate that owns it, with the same shape: registered before the game
-runs, read-only after.
+world saved) and `tunnel` (the resolver of `friend:` addresses, Play with Friends'). **A hook you need and don't find:** add a method with an empty default to `Hooks` and a function in
+`horizon_hooks::engine` that the engine calls where vanilla does the matching thing; give it plain data or a type
+the engine owns, never one from above. A hook that needs engine types the platform doesn't expose yet (a draw
+context for HUD and chat overlays, a settings page) comes with that type's platform API (M6). An extension point
+that belongs to one subsystem (an input source, the compositor) lives in the engine crate that owns it, with the
+same shape: registered before the game runs, read-only after.
 
 **What players get.** The release builds (`game-build.yml`, so the nightly and the release; `tools/ci/build-musl.sh`)
 build `horizon-official` and ship it as `horizon-client`, the name the launcher and players know. The launcher's

launcher/src/glass_settings.rs

@@ -462,7 +462,17 @@ impl Launcher {
                 .into_any_element()
         };
         let about = card()
-            .child(self.location_row(0, cx).mb(px(0.)))
+            .child(index_row(
+                0,
+                tr("Data folder"),
+                Some(mono(short(&backend::data_dir()))),
+                Some(
+                    button("about-open-data", "Open", Kind::Secondary, &t)
+                        .on_click(|_, _, cx| crate::glass_toast::open(cx, &backend::data_dir()))
+                        .into_any_element(),
+                ),
+                &t,
+            ))
             .child(index_row(
                 0,
                 tr("Logs"),

launcher/src/location_page.rs

@@ -209,18 +209,7 @@ impl Launcher {
                 n,
                 tr("Data folder"),
                 Some(div().font_family(theme::MONO).child(short(&backend::data_dir())).into_any_element()),
-                Some(
-                    div()
-                        .flex()
-                        .gap(px(8.))
-                        .child(
-                            button("about-open-data", "Open", Kind::Secondary, &t).on_click(
-                                |_, _, cx| crate::glass_toast::open(cx, &backend::data_dir()),
-                            ),
-                        )
-                        .child(move_button)
-                        .into_any_element(),
-                ),
+                Some(move_button.into_any_element()),
                 &t,
             ))
             .child(text(theme::CAPTION).text_color(t.muted).child(tr(

tests/test_pr_ready.py

@@ -172,8 +172,6 @@ class PrReadyTests(unittest.TestCase):
         self.assertEqual(pr_ready.mod_features(["horizon-client"]), "")
         self.assertEqual(pr_ready.mod_features(["horizon-mods"]),
                          " --features horizon-mods/index")
-        self.assertEqual(pr_ready.mod_features(["horizon-bench", "horizon-telemetry"]),
-                         " --features horizon-telemetry/game,horizon-bench/game")
         self.assertEqual(pr_ready.mod_features(None), MODS)
 
     def test_mod_api_data_inputs_build_and_test_the_consuming_crates(self):

tools/layers.json

@@ -81,6 +81,7 @@
   },
   "allowed": [
     "horizon-client -> horizon-anticheat",
+    "horizon-client -> horizon-bench",
     "horizon-client -> horizon-chat-filter",
     "horizon-client -> horizon-cosmetics",
     "horizon-client -> horizon-dualsense",
@@ -95,6 +96,7 @@
     "horizon-client -> horizon-theme",
     "horizon-client-input -> horizon-theme",
     "horizon-client-lib -> horizon-anticheat",
+    "horizon-client-lib -> horizon-bench",
     "horizon-client-lib -> horizon-chat-filter",
     "horizon-client-lib -> horizon-hdr",
     "horizon-client-lib -> horizon-mcp",

tools/port_map/game-005.tsv

@@ -46,7 +46,7 @@ Entity.dropAllLeashConnections	port	crates/horizon-client/src/game/leads.rs::Gam
 Entity.canCollideWith	inline	crates/horizon-client/src/game/ghasts.rs::Game::player_entity_collisions	gap: player: the entities a player cannot walk through are boats and happy ghasts only; a live shulker (canBeCollidedWith) is not solid, so the player walks through it
 Entity.getDefaultPassengerAttachmentPoint	inline	crates/horizon-client/src/mobs/riders.rs::passenger_attachment	one point per vehicle, so the passenger index is always 0; default is the top of the box
 Entity.ejectPassengers	port	crates/horizon-client/src/game/boat_passengers.rs::Game::eject_boat_mobs	gap: minor: boats place riders at the dismount spot; when a mob vehicle dies sync_riders only lets go and the rider stays where it was seated
-Entity.removeVehicle	port	crates/horizon-client/src/game/sculk.rs::Game::mount_events	`startRiding`/`removeVehicle`: `entity_mount` at the new vehicle and `entity_dismount` at the old one, derived from the vehicle the rider had last tick, for players and mobs
+Entity.removeVehicle	inline	crates/horizon-client/src/game/commands/world_cmds.rs::Game::dismount_mob	gap: minor: no entity_dismount game event, so sculk sensors and wardens never hear a dismount
 Entity.moveOrInterpolateTo	port	crates/horizon-world/src/stepped_interpolation.rs::SteppedInterpolation::interpolate_to	living entities from a server; boats and other objects use a three tick Lerp
 Entity.getHandHoldingItemAngle	port	crates/horizon-client/src/game/fireworks.rs::Game::rocket_hand_angle	ticked in #3514; `Entity.getHandHoldingItemAngle` is cited at crates/horizon-client/src/game/fireworks.rs:241
 Entity.teleportToPortalDestination	inline	crates/horizon-client/src/game/nether_portal.rs::Game::send_through_portal	may_enter checks isAllowedToEnterPortal; the entity is saved and waits for its dimension

tools/port_map/game-006.tsv

@@ -62,7 +62,7 @@ LivingEntity.dropFromShearingLootTable	port	crates/horizon-client/src/game/creat
 LivingEntity.getFallDamageSound	inline	crates/horizon-client/src/mobs/landing.rs::MobLanding::living_fall_sound	a monster gets entity.hostile.big_fall and entity.hostile.small_fall, anything else the generic pair; a player's comes from landing.rs
 LivingEntity.getHitbox	missing		minor: a rider's hitbox is not cut at its seat height; spear and melee tests use the full box
 LivingEntity.postPiercingAttack	port	crates/horizon-client/src/game/enchant_effects.rs::Game::post_piercing_attack	Lunge's dash after a jab
-LivingEntity.trapdoorUsableAsLadder	port	crates/horizon-world/src/climbing.rs::on_climbable	the climbable tag, or an open trapdoor directly over a ladder with the same facing: `climbing::on_climbable` for the player and `Mob::on_climbable` for mobs
+LivingEntity.trapdoorUsableAsLadder	port	crates/horizon-world/src/climbing.rs::on_climbable	gap: minor: the player only; a mob's ai.rs::on_climbable checks the climbable tag at its feet, no open trapdoor over a ladder
 LivingEntity.isAlive	port	crates/horizon-client/src/mobs.rs::Mob::alive	not removed and health above zero
 LivingEntity.setIgnoreFallDamageFromCurrentImpulse	port	crates/horizon-world/src/living_fall.rs::ImpulseContext::set_ignore_fall_damage	40 ticks of grace
 LivingEntity.getDamageAfterArmorAbsorb	inline	crates/horizon-client/src/mobs.rs::Mob::damage_with	the player's armor wear is health.rs hurt_armor; the mob path also scales armor effectiveness (breach)

tools/port_map/game2-002.tsv

@@ -116,7 +116,7 @@ Ravager.strongKnockback	inline	crates/horizon-client/src/mobs/ravager.rs::roar	t
 Ravager.addRoarParticleEffects	inline	crates/horizon-client/src/mobs/ravager.rs::roar	the poof particles are emitted in roar
 Shulker.registerGoals	port	crates/horizon-client/src/mobs/shulker.rs::register	gap: minor: no defense target goal (priority 3)
 Shulker.defineSynchedData	skip:other		attach face, peek and colour are Mob extra fields
-Shulker.readAdditionalSaveData	inline	crates/horizon-client/src/entity_nbt.rs::mob_from_nbt	AttachFace wraps through Direction.from3DDataValue, Peek and Color are raw getByteOr bytes
+Shulker.readAdditionalSaveData	inline	crates/horizon-client/src/entity_nbt.rs::mob_from_nbt	AttachFace, Peek and Color are read there
 Shulker.addAdditionalSaveData	inline	crates/horizon-client/src/entity_nbt.rs::mob_to_nbt	AttachFace, Peek and Color are written there
 Shulker.findNewAttachment	inline	crates/horizon-client/src/mobs/shulker.rs::tick	keeps its face or teleports in tick, through attachable and teleport
 Shulker.makeBoundingBox	port	crates/horizon-client/src/mobs/shulker.rs::progress_aabb	

tools/port_map/game2-006.tsv

@@ -31,7 +31,7 @@ Projectile.onAboveBubbleColumn	port	crates/horizon-client/src/projectiles.rs::Pr
 Projectile.onInsideBubbleColumn	port	crates/horizon-client/src/projectiles.rs::Projectile::bubble_column_push	unclamped 0.06 up (0.03 down) inside a column; arrows in arrows.rs::Ticker::bubble_column
 Projectile.canBreakBlockInAdventureMode	port	crates/horizon-client/src/game/creatures.rs::Game::projectile_breaks_block	gap: minor: the shooter's gamemode and kind decide it; a stack's `can_break` predicate is not consulted
 Projectile.spawnProjectileFromRotation	port	crates/horizon-client/src/projectiles.rs::Projectile::shoot_from_rotation	gap: minor: the aim and inherited velocity only; the add-to-world step is the caller's
-Projectile.spawnProjectile	inline	crates/horizon-client/src/game/creatures.rs::Game::throw_item	each shooter adds its own projectile (throw_item, shoot_crossbow, shoot_projectile_item, the bow in game/use_hand.rs::release_bow); throw_item is the player throw path
+Projectile.spawnProjectile	inline	crates/horizon-client/src/game/creatures.rs::Game::throw_item	each shooter adds its own projectile (throw_item, shoot_crossbow, shoot_projectile_item, the bow in game.rs); throw_item is the player throw path
 Projectile.applyOnProjectileSpawned	port	crates/horizon-client/src/game/enchant_effects.rs::Game::ignite_spawned_arrow	gap: minor: Flame ignite only; Piercing and Punch go through Projectile::set_bonus
 Projectile.hitTargetOrDeflectSelf	port	crates/horizon-client/src/game/creatures.rs::Game::tick_projectiles	gap: minor: deflection is checked for breezes only; the onHit dispatch is creatures.rs projectile_hit
 Projectile.onRedirectProjectile	port	crates/horizon-client/src/game/deflect.rs::Game::deflect	gap: minor: the player's attack turns the projectile; a projectile hitting another redirectable one is not modelled

tools/pr_ready.py

@@ -333,17 +333,10 @@ def mark_old_rust(steps, warning):
     steps.insert(steps.index(clippy[0]), rust)
 
 
-# The features another workspace package turns on for these crates: horizon-mods' index, and the game parts
-# horizon-official runs (telemetry's and the benchmark's `game`).
-WORKSPACE_FEATURES = {"horizon-mods": "horizon-mods/index", "horizon-telemetry": "horizon-telemetry/game",
-                      "horizon-bench": "horizon-bench/game"}
-
-
 def mod_features(crates):
     """The features CI's workspace-wide test run gives these crates. Cargo unifies features over the packages it
-    builds, so a crate tested alone needs the ones the workspace would have turned on for it (WORKSPACE_FEATURES)."""
-    features = [f for crate, f in WORKSPACE_FEATURES.items() if crates is not None and crate in crates]
-    return f" --features {','.join(features)}" if features else ""
+    builds, so a crate tested alone needs the ones the workspace would have turned on for it: horizon-mods' index."""
+    return " --features horizon-mods/index" if crates is not None and "horizon-mods" in crates else ""
 
 
 # What horizon-client's full content-root tests load (mod_content_tests.rs). They take minutes on prepared data, so