From 35a89eaebe28921c12c9b5a05072d3b3f31ab00a Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Sun, 25 Oct 2026 18:48:38 +0100
Subject: [PATCH 001/475] Mod API 0.3: capability world for server mods
 (blocks, biomes)

Server mods get interface world: get-block(dimension, x, y, z) reads a
loaded chunk's block state as "minecraft:oak_log[axis=y]", get-biome its
biome ("minecraft:plains"), and
set-blocks(dimension, changes) sets up to 4096 blocks per call, checked at
once, made as /setblock makes them (place_state: neighbours, light, block
entities, every client told through the block log) after the call, before
that dimension's next tick.

Reads cost no copy: for a mod call the game lends Mods the levels' chunk
maps (moved out with mem::take and put back after), only while a running
mod has world. Writes for a level that isn't ticking (another dimension,
in-frame) wait for it, up to 65,536.

Test scripts get blocks (setup) and expect.blocks; cargo horizon-mod check
reports a trial run's block writes. Example beacons: /beacon builds a
glowstone pillar beside the player, /ground reads the block underfoot and the biome.
parse_state is now a free function so the mod path shares it.

Docs: docs/mods.md (the capability, script keys), docs/api/mods.md and the
regenerated reference.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock                                    |   7 +
 Cargo.toml                                    |   2 +-
 crates/cargo-horizon-mod/src/check.rs         |   5 +
 crates/horizon-client/src/game/levels.rs      |  15 ++
 crates/horizon-client/src/game/mods.rs        |  15 +-
 .../horizon-client/src/game/render_control.rs |  61 ++++---
 crates/horizon-client/src/game/server_mods.rs | 154 +++++++++++++++++-
 .../examples/beacons/Cargo.toml               |  16 ++
 .../examples/beacons/horizon-mod.toml         |   8 +
 .../examples/beacons/src/lib.rs               |  87 ++++++++++
 .../examples/beacons/tests/beacons.toml       |  22 +++
 crates/horizon-mod-sdk/src/lib.rs             |   1 +
 crates/horizon-mod-sdk/wit/horizon.wit        |  28 ++++
 crates/horizon-mods/src/manifest.rs           |  14 +-
 crates/horizon-mods/src/runtime.rs            |  98 ++++++++++-
 crates/horizon-mods/src/testing.rs            |  92 ++++++++++-
 crates/horizon-mods/tests/sandbox.rs          |  29 +++-
 docs/api/mods-reference.md                    |  24 ++-
 docs/api/mods.md                              |  12 +-
 docs/mods.md                                  |  18 +-
 20 files changed, 658 insertions(+), 50 deletions(-)
 create mode 100644 crates/horizon-mod-sdk/examples/beacons/Cargo.toml
 create mode 100644 crates/horizon-mod-sdk/examples/beacons/horizon-mod.toml
 create mode 100644 crates/horizon-mod-sdk/examples/beacons/src/lib.rs
 create mode 100644 crates/horizon-mod-sdk/examples/beacons/tests/beacons.toml

diff --git a/Cargo.lock b/Cargo.lock
index 0b8adf3ea..8c74b3b46 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -205,6 +205,13 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "beacons"
+version = "0.1.0"
+dependencies = [
+ "horizon-mod-sdk",
+]
+
 [[package]]
 name = "bit-set"
 version = "0.10.0"
diff --git a/Cargo.toml b/Cargo.toml
index 44ed89122..ffe744e65 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [workspace]
 exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"]
-members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/welcome", "xtask"]
+members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/welcome", "crates/horizon-mod-sdk/examples/beacons", "xtask"]
 resolver = "2"
 
 [workspace.package]
diff --git a/crates/cargo-horizon-mod/src/check.rs b/crates/cargo-horizon-mod/src/check.rs
index 86ce9654d..4d271e2c1 100644
--- a/crates/cargo-horizon-mod/src/check.rs
+++ b/crates/cargo-horizon-mod/src/check.rs
@@ -242,6 +242,11 @@ fn play(path: &Path, report: &mut Report) -> Result<(), String> {
                 format!("{}: {text}", if error { "error" } else { "feedback" })
             }
             Output::Stopped { reason, .. } => return Err(format!("it stopped: {reason}")),
+            Output::SetBlocks {
+                dimension, blocks, ..
+            } => {
+                format!("set {} block(s) in {dimension}", blocks.len())
+            }
         });
     }
     match failed(&mods) {
diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs
index f685200f2..09d5c0bff 100644
--- a/crates/horizon-client/src/game/levels.rs
+++ b/crates/horizon-client/src/game/levels.rs
@@ -106,6 +106,19 @@ pub(super) struct Levels {
     parked: HashMap<Dim, Parked>,
 }
 
+impl Levels {
+    /// The chunks of each level not in place (capability `world` lends
+    /// them to server mods for a call).
+    #[cfg_attr(not(feature = "mods"), allow(dead_code))]
+    pub(super) fn parked_chunks(
+        &mut self,
+    ) -> impl Iterator<Item = (Dim, &mut horizon_client::chunk_map::ChunkMap)> {
+        self.parked
+            .iter_mut()
+            .map(|(d, p)| (*d, &mut p.world.chunks))
+    }
+}
+
 impl Game<'_> {
     /// A new level for `dim`, opened from the save (`MinecraftServer.createLevels`).
     fn open_level(&self, dim: Dim) -> Result<Parked> {
@@ -295,6 +308,8 @@ impl Game<'_> {
             };
             self.update_dedicated_streaming();
             self.update_world();
+            // What server mods set in this level since its last tick.
+            self.apply_mod_block_writes();
             result = if paused {
                 self.tick_lan(true);
                 Ok(())
diff --git a/crates/horizon-client/src/game/mods.rs b/crates/horizon-client/src/game/mods.rs
index b1ce4207c..111b797ad 100644
--- a/crates/horizon-client/src/game/mods.rs
+++ b/crates/horizon-client/src/game/mods.rs
@@ -49,6 +49,14 @@ pub(super) struct ModsState {
     /// What players did this tick, for server mods at its end.
     #[cfg(feature = "mods")]
     pub(super) events: Vec<ModEvent>,
+    /// A running server mod has capability `world`: its calls get the
+    /// levels' chunks to read.
+    #[cfg(feature = "mods")]
+    pub(super) world: bool,
+    /// Blocks server mods set, by dimension, made before that level's next
+    /// tick.
+    #[cfg(feature = "mods")]
+    pub(super) block_writes: Vec<(String, horizon_mods::BlockChange)>,
 }
 impl ModsState {
     /// The chat's command tree: vanilla's, plus the running mods' commands.
@@ -213,6 +221,7 @@ impl Game<'_> {
     /// The Mods page's rows, from what loaded.
     fn list_mods(&mut self) {
         self.mods.server = self.mods.mods.runs_server();
+        self.mods.world = self.mods.mods.wants_world();
         let dev = &self.mods.dev;
         self.settings.mods.installed = self
             .mods
@@ -399,8 +408,10 @@ impl Game<'_> {
                     }
                     Text::literal(line).with_color(text::RED)
                 }
-                server
-                @ (Output::Tell { .. } | Output::Broadcast { .. } | Output::Reply { .. }) => {
+                server @ (Output::Tell { .. }
+                | Output::Broadcast { .. }
+                | Output::Reply { .. }
+                | Output::SetBlocks { .. }) => {
                     self.route_server_output(host.as_deref_mut(), server);
                     continue;
                 }
diff --git a/crates/horizon-client/src/game/render_control.rs b/crates/horizon-client/src/game/render_control.rs
index 0a2f9b715..7c5ff4b2d 100644
--- a/crates/horizon-client/src/game/render_control.rs
+++ b/crates/horizon-client/src/game/render_control.rs
@@ -19,33 +19,7 @@ pub const HELP: &[&str] = &[
 impl Game<'_> {
     /// Parse `name[k=v,...]` into a registry state (defaults for missing properties).
     fn parse_state(&self, text: &str) -> Result<BlockStateId> {
-        let (name, props) = match text.split_once('[') {
-            Some((n, rest)) => (n, rest.trim_end_matches(']')),
-            None => (text, ""),
-        };
-        let name = if name.contains(':') {
-            name.to_owned()
-        } else {
-            format!("minecraft:{name}")
-        };
-        let registry = &self.pack.assets.registry;
-        let default = registry
-            .default_state(&name)
-            .ok_or_else(|| format!("unknown block {name}"))?;
-        let mut state = registry
-            .state(default)
-            .ok_or("missing default state")?
-            .clone();
-        for pair in props.split(',').filter(|p| !p.is_empty()) {
-            let (k, v) = pair
-                .split_once('=')
-                .ok_or_else(|| format!("bad property {pair}"))?;
-            if !state.properties.contains_key(k) {
-                return Err(format!("{name} has no property {k}").into());
-            }
-            state.properties.insert(k.to_owned(), v.to_owned());
-        }
-        Ok(registry.resolve(&state)?)
+        parse_state(self.pack.assets.registry, text)
     }
     pub(super) fn render_command(&mut self, words: &[&str]) -> Result<Option<Value>> {
         let int = |i: usize| -> Result<i32> {
@@ -137,3 +111,36 @@ impl Game<'_> {
         }
     }
 }
+
+/// Parse `name[k=v,...]` into a registry state (defaults for missing properties).
+pub(super) fn parse_state(
+    registry: &horizon_world::registry::BlockRegistry,
+    text: &str,
+) -> Result<BlockStateId> {
+    let (name, props) = match text.split_once('[') {
+        Some((n, rest)) => (n, rest.trim_end_matches(']')),
+        None => (text, ""),
+    };
+    let name = if name.contains(':') {
+        name.to_owned()
+    } else {
+        format!("minecraft:{name}")
+    };
+    let default = registry
+        .default_state(&name)
+        .ok_or_else(|| format!("unknown block {name}"))?;
+    let mut state = registry
+        .state(default)
+        .ok_or("missing default state")?
+        .clone();
+    for pair in props.split(',').filter(|p| !p.is_empty()) {
+        let (k, v) = pair
+            .split_once('=')
+            .ok_or_else(|| format!("bad property {pair}"))?;
+        if !state.properties.contains_key(k) {
+            return Err(format!("{name} has no property {k}").into());
+        }
+        state.properties.insert(k.to_owned(), v.to_owned());
+    }
+    Ok(registry.resolve(&state)?)
+}
diff --git a/crates/horizon-client/src/game/server_mods.rs b/crates/horizon-client/src/game/server_mods.rs
index db88639eb..f5ee5cdc2 100644
--- a/crates/horizon-client/src/game/server_mods.rs
+++ b/crates/horizon-client/src/game/server_mods.rs
@@ -47,19 +47,72 @@ impl Game<'_> {
     ) -> bool {
         false
     }
+    pub(super) fn apply_mod_block_writes(&mut self) {}
 }
 
 #[cfg(feature = "mods")]
 mod run {
     use super::{Game, LanHost, ModEvent, Who};
+    use horizon_client::chunk_map::ChunkMap;
     use horizon_client::{
         command::args::GameMode as Mode,
         lan::data::component_nbt,
         text::{self, Text},
     };
-    use horizon_mods::{BlockPos, GameMode, Output, ServerPlayer};
+    use horizon_mods::{BlockPos, GameMode, Output, ServerPlayer, WorldView};
     use horizon_protocol::packets::play::{self, Clientbound as C};
-    use horizon_world::registry::BlockStateId;
+    use horizon_world::registry::{BlockRegistry, BlockStateId};
+
+    /// Blocks queued for levels that don't tick (another dimension, in-frame)
+    /// are kept up to this many; the oldest go first.
+    const MAX_QUEUED_WRITES: usize = 1 << 16;
+
+    /// Capability `world`'s view during a call: the levels' chunks, moved out
+    /// of the game for the call and back after it (no copy).
+    struct LentWorld {
+        registry: &'static BlockRegistry,
+        biomes: std::sync::Arc<horizon_client::biome::Biomes>,
+        dims: Vec<(&'static str, ChunkMap)>,
+    }
+    impl WorldView for LentWorld {
+        fn block(&self, dimension: &str, x: i32, y: i32, z: i32) -> Option<String> {
+            let (_, chunks) = self.dims.iter().find(|(d, _)| *d == dimension)?;
+            let chunk = chunks.get(&(x >> 4, z >> 4))?;
+            Some(state_string(self.registry, chunk.block(x & 15, y, z & 15)))
+        }
+        fn biome(&self, dimension: &str, x: i32, y: i32, z: i32) -> Option<String> {
+            let (_, chunks) = self.dims.iter().find(|(d, _)| *d == dimension)?;
+            let chunk = chunks.get(&(x >> 4, z >> 4))?;
+            Some(self.biomes.get(chunk.biome(x, y, z)).name.clone())
+        }
+        fn has_dimension(&self, dimension: &str) -> bool {
+            matches!(
+                dimension,
+                "minecraft:overworld" | "minecraft:the_nether" | "minecraft:the_end"
+            )
+        }
+        fn check_state(&self, state: &str) -> Result<(), String> {
+            crate::game::render_control::parse_state(self.registry, state)
+                .map(drop)
+                .map_err(|e| format!("{state}: {e}"))
+        }
+    }
+
+    /// `minecraft:oak_log[axis=y]`.
+    fn state_string(registry: &BlockRegistry, state: BlockStateId) -> String {
+        let Some(s) = registry.state(state) else {
+            return "minecraft:air".into();
+        };
+        if s.properties.is_empty() {
+            return s.name.clone();
+        }
+        let props: Vec<String> = s
+            .properties
+            .iter()
+            .map(|(k, v)| format!("{k}={v}"))
+            .collect();
+        format!("{}[{}]", s.name, props.join(","))
+    }
 
     /// `UUID.toString()`.
     fn uuid_string(u: u128) -> String {
@@ -144,6 +197,7 @@ mod run {
             let players = self.server_players(None);
             let snapshot = self.mod_snapshot_with(players.clone());
             self.mods.mods.set_snapshot(snapshot);
+            self.lend_world();
             let before = std::mem::take(&mut self.mods.players);
             for p in before
                 .iter()
@@ -197,8 +251,80 @@ mod run {
                 }
             }
             self.mods.mods.server_tick(self.ticks);
+            self.return_world();
             self.mods.players = players;
             self.show_mod_output();
+            self.apply_mod_block_writes();
+        }
+
+        /// Lends the levels' chunks to capability `world` for the calls up to
+        /// [`Game::return_world`], when a running server mod has it.
+        fn lend_world(&mut self) {
+            if !self.mods.world {
+                return;
+            }
+            let mut dims = vec![(self.dim.id(), std::mem::take(&mut self.world.chunks))];
+            for (dim, chunks) in self.levels.parked_chunks() {
+                dims.push((dim.id(), std::mem::take(chunks)));
+            }
+            let registry = self.pack.assets.registry;
+            let biomes = self.res.biomes().clone();
+            self.mods.mods.lend_world(Box::new(LentWorld {
+                registry,
+                biomes,
+                dims,
+            }));
+        }
+
+        /// Puts back the chunks [`Game::lend_world`] lent.
+        fn return_world(&mut self) {
+            let Some(view) = self.mods.mods.take_world() else {
+                return;
+            };
+            let view: Box<dyn std::any::Any> = view;
+            let Ok(lent) = view.downcast::<LentWorld>() else {
+                return;
+            };
+            let mut dims = lent.dims;
+            if let Some(i) = dims.iter().position(|(d, _)| *d == self.dim.id()) {
+                self.world.chunks = dims.swap_remove(i).1;
+            }
+            for (dim, chunks) in self.levels.parked_chunks() {
+                if let Some(i) = dims.iter().position(|(d, _)| *d == dim.id()) {
+                    *chunks = dims.swap_remove(i).1;
+                }
+            }
+        }
+
+        /// Makes the blocks server mods set in the level in place, in order,
+        /// as `/setblock` does. Those of other dimensions wait for their level.
+        pub(in crate::game) fn apply_mod_block_writes(&mut self) {
+            if self.mods.block_writes.is_empty() {
+                return;
+            }
+            let dim = self.dim.id();
+            let (now, later): (Vec<_>, Vec<_>) = std::mem::take(&mut self.mods.block_writes)
+                .into_iter()
+                .partition(|(d, _)| d == dim);
+            self.mods.block_writes = later;
+            let registry = self.pack.assets.registry;
+            for (_, b) in now {
+                let state = match crate::game::render_control::parse_state(registry, &b.state) {
+                    Ok(state) => state,
+                    Err(e) => {
+                        log::warn!("Horizon: a server mod set {}: {e}", b.state);
+                        continue;
+                    }
+                };
+                if let Err(e) = self.place_state([b.x, b.y, b.z], state, false) {
+                    log::debug!(
+                        "Horizon: a server mod's block at {} {} {}: {e:?}",
+                        b.x,
+                        b.y,
+                        b.z
+                    );
+                }
+            }
         }
 
         /// A player broke (or placed) `state` at `pos`: the player acting now.
@@ -240,8 +366,11 @@ mod run {
             };
             let snapshot = self.mod_snapshot_with(players);
             self.mods.mods.set_snapshot(snapshot);
+            self.lend_world();
             let owned = self.mods.mods.server_command(&me, line);
+            self.return_world();
             self.show_mod_output();
+            self.apply_mod_block_writes();
             owned
         }
 
@@ -266,10 +395,14 @@ mod run {
             };
             let snapshot = self.mod_snapshot_with(players);
             self.mods.mods.set_snapshot(snapshot);
-            if !self.mods.mods.server_command(&me, line) {
+            self.lend_world();
+            let owned = self.mods.mods.server_command(&me, line);
+            self.return_world();
+            if !owned {
                 return false;
             }
             self.route_mod_output(Some(host));
+            self.apply_mod_block_writes();
             true
         }
 
@@ -349,6 +482,21 @@ mod run {
                         self.tell_server_player(host.as_deref_mut(), &p.id, line);
                     }
                 }
+                Output::SetBlocks {
+                    name,
+                    dimension,
+                    blocks,
+                } => {
+                    let queued = &mut self.mods.block_writes;
+                    queued.extend(blocks.into_iter().map(|b| (dimension.clone(), b)));
+                    if queued.len() > MAX_QUEUED_WRITES {
+                        let over = queued.len() - MAX_QUEUED_WRITES;
+                        queued.drain(..over);
+                        log::warn!(
+                            "Horizon: mod {name} set more blocks than wait for their level: {over} dropped"
+                        );
+                    }
+                }
                 _ => {}
             }
         }
diff --git a/crates/horizon-mod-sdk/examples/beacons/Cargo.toml b/crates/horizon-mod-sdk/examples/beacons/Cargo.toml
new file mode 100644
index 000000000..c001614e8
--- /dev/null
+++ b/crates/horizon-mod-sdk/examples/beacons/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "beacons"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+publish = false
+description = "Example Horizon server mod: /beacon lights a pillar beside you, /ground says what you stand on"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+horizon-mod-sdk = { path = "../.." }
+
+[lints]
+workspace = true
diff --git a/crates/horizon-mod-sdk/examples/beacons/horizon-mod.toml b/crates/horizon-mod-sdk/examples/beacons/horizon-mod.toml
new file mode 100644
index 000000000..0c2004b5f
--- /dev/null
+++ b/crates/horizon-mod-sdk/examples/beacons/horizon-mod.toml
@@ -0,0 +1,8 @@
+id = "beacons"
+name = "Beacons"
+version = "0.1.0"
+description = "/beacon lights a pillar of glowstone beside you; /ground says what you are standing on, and in which biome."
+authors = ["Horizon"]
+api = "0.3"
+side = "server"
+capabilities = ["players", "world"]
diff --git a/crates/horizon-mod-sdk/examples/beacons/src/lib.rs b/crates/horizon-mod-sdk/examples/beacons/src/lib.rs
new file mode 100644
index 000000000..509431775
--- /dev/null
+++ b/crates/horizon-mod-sdk/examples/beacons/src/lib.rs
@@ -0,0 +1,87 @@
+//! Example Horizon server mod (`docs/mods.md`, "Server mods") with
+//! capability `world`: `/beacon` lights a pillar of glowstone two blocks east
+//! of the player, `/ground` reads the block under their feet and the biome.
+use horizon_mod_sdk::server::{BlockChange, Player, Registration, ServerMod, players, world};
+
+/// How tall `/beacon` builds.
+const HEIGHT: i32 = 4;
+
+struct Beacons;
+
+/// The block the player stands in: their feet, floored.
+fn feet(player: &Player) -> (i32, i32, i32) {
+    (
+        player.x.floor() as i32,
+        player.y.floor() as i32,
+        player.z.floor() as i32,
+    )
+}
+
+/// The pillar beside `player`: `HEIGHT` blocks of glowstone, from their feet up.
+fn pillar(player: &Player) -> Vec<BlockChange> {
+    let (x, y, z) = feet(player);
+    (0..HEIGHT)
+        .map(|dy| BlockChange {
+            x: x + 2,
+            y: y + dy,
+            z,
+            state: "minecraft:glowstone".into(),
+        })
+        .collect()
+}
+
+impl ServerMod for Beacons {
+    fn init() -> Result<(Self, Registration), String> {
+        Ok((
+            Beacons,
+            Registration::new().command("beacon").command("ground"),
+        ))
+    }
+
+    fn command(
+        &mut self,
+        player: &Player,
+        name: &str,
+        _args: &str,
+    ) -> Result<Option<String>, String> {
+        let (x, y, z) = feet(player);
+        if name == "beacon" {
+            world::set_blocks(&player.dimension, &pillar(player))?;
+            players::broadcast(&format!(
+                "{} lit a beacon at {} {y} {z}",
+                player.name,
+                x + 2
+            ));
+            return Ok(None);
+        }
+        let below = world::get_block(&player.dimension, x, y - 1, z)
+            .ok_or("The ground under you isn't loaded")?;
+        let biome = world::get_biome(&player.dimension, x, y, z).unwrap_or_default();
+        Ok(Some(format!("You are standing on {below} in {biome}")))
+    }
+}
+
+horizon_mod_sdk::export_server_mod!(Beacons);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_pillar_stands_two_blocks_east() {
+        let p = Player {
+            id: String::new(),
+            name: "Alex".into(),
+            x: -0.5,
+            y: 64.0,
+            z: 3.2,
+            dimension: "minecraft:overworld".into(),
+            game_mode: horizon_mod_sdk::server::GameMode::Survival,
+            health: 20.0,
+        };
+        let blocks = pillar(&p);
+        assert_eq!(blocks.len(), HEIGHT as usize);
+        assert_eq!((blocks[0].x, blocks[0].y, blocks[0].z), (1, 64, 3));
+        assert_eq!(blocks[3].y, 67);
+    }
+}
diff --git a/crates/horizon-mod-sdk/examples/beacons/tests/beacons.toml b/crates/horizon-mod-sdk/examples/beacons/tests/beacons.toml
new file mode 100644
index 000000000..e75caeb75
--- /dev/null
+++ b/crates/horizon-mod-sdk/examples/beacons/tests/beacons.toml
@@ -0,0 +1,22 @@
+# /ground reads the block under the player and the biome; /beacon sets four blocks of glowstone two to the east.
+
+[[step]]
+join = "Alex"
+blocks = [{ x = 0, y = 63, z = 0, state = "minecraft:grass_block[snowy=false]" }]
+command = "ground"
+expect.feedback = "You are standing on minecraft:grass_block[snowy=false] in minecraft:plains"
+
+[[step]]
+command = "beacon"
+expect.broadcast = ["Alex lit a beacon at 2 64 0"]
+expect.blocks = [
+    { x = 2, y = 64, z = 0, state = "minecraft:glowstone" },
+    { x = 2, y = 67, z = 0, state = "minecraft:glowstone" },
+    { x = 2, y = 68, z = 0, state = "minecraft:air" },
+]
+
+# Anywhere the script set nothing is air.
+[[step]]
+player = { x = 10.5, z = 10.5 }
+command = "ground"
+expect.feedback = "You are standing on minecraft:air in minecraft:plains"
diff --git a/crates/horizon-mod-sdk/src/lib.rs b/crates/horizon-mod-sdk/src/lib.rs
index 1cffcc183..98f6a5ef4 100644
--- a/crates/horizon-mod-sdk/src/lib.rs
+++ b/crates/horizon-mod-sdk/src/lib.rs
@@ -166,6 +166,7 @@ pub mod server {
 
     pub use exports::horizon::mods::server_events::{BlockPos, Guest as __Guest, Registration};
     pub use horizon::mods::players::{self, GameMode, Player};
+    pub use horizon::mods::world::{self, BlockChange};
 
     /// The server's calls into a mod. Only the hooks [`Registration`] asks
     /// for are called; the others may stay as their defaults.
diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit
index 3a9027bba..f0dd1c596 100644
--- a/crates/horizon-mod-sdk/wit/horizon.wit
+++ b/crates/horizon-mod-sdk/wit/horizon.wit
@@ -144,6 +144,33 @@ interface players {
     broadcast: func(text: string);
 }
 
+/// Capability `world`, server mods only (manifest `api = "0.3"`,
+/// experimental): the blocks of the server's loaded chunks, and changes to
+/// them through the server's own block updates.
+interface %world {
+    record block-change {
+        x: s32,
+        y: s32,
+        z: s32,
+        /// `minecraft:oak_log[axis=y]`; properties left out take the block's
+        /// defaults, `minecraft:stone` alone is the default state.
+        state: string,
+    }
+    /// The block state at a position in a dimension (`minecraft:overworld`,
+    /// ...), as `minecraft:oak_log[axis=y]`, as of this call: none where the
+    /// server has no chunk loaded there.
+    get-block: func(dimension: string, x: s32, y: s32, z: s32) -> option<string>;
+    /// The biome at a position (`minecraft:plains`, ...), as the server
+    /// stores it (one per 4 x 4 x 4 cell): none where no chunk is loaded.
+    get-biome: func(dimension: string, x: s32, y: s32, z: s32) -> option<string>;
+    /// Sets blocks as `/setblock` does: the old block entity removed,
+    /// neighbours and shapes updated, light, and every player told. Every
+    /// state is checked now (an error queues nothing); the changes are made
+    /// in order after this call returns, before that dimension's next tick;
+    /// one in a chunk not loaded then is skipped. At most 4096 per call.
+    set-blocks: func(dimension: string, blocks: list<block-change>) -> result<_, string>;
+}
+
 /// What the server calls in a server mod (manifest `api = "0.3"`,
 /// experimental). Only the hooks `init` asks for are ever called. The player
 /// in each event is as the server saw them when it happened.
@@ -205,5 +232,6 @@ world horizon-server-mod {
     import log;
     import storage;
     import players;
+    import %world;
     export server-events;
 }
diff --git a/crates/horizon-mods/src/manifest.rs b/crates/horizon-mods/src/manifest.rs
index 1caf2038f..ca7443186 100644
--- a/crates/horizon-mods/src/manifest.rs
+++ b/crates/horizon-mods/src/manifest.rs
@@ -80,19 +80,26 @@ pub enum Capability {
     Registries,
     /// The players on the server and messages to them (server mods).
     Players,
+    /// Blocks in the server's loaded chunks, and changes to them (server
+    /// mods; client mods later, where the game runs the world).
+    World,
 }
 impl Capability {
-    pub const ALL: [Capability; 6] = [
+    pub const ALL: [Capability; 7] = [
         Capability::GameRead,
         Capability::Chat,
         Capability::Hud,
         Capability::Storage,
         Capability::Registries,
         Capability::Players,
+        Capability::World,
     ];
     /// Whether a server mod may have it: the others act on a local player.
     pub fn on_server(self) -> bool {
-        matches!(self, Capability::Storage | Capability::Players)
+        matches!(
+            self,
+            Capability::Storage | Capability::Players | Capability::World
+        )
     }
     /// The WIT interface it grants, in `horizon:mods`.
     pub fn interface(self) -> &'static str {
@@ -103,6 +110,7 @@ impl Capability {
             Capability::Storage => "storage",
             Capability::Registries => "registries",
             Capability::Players => "players",
+            Capability::World => "world",
         }
     }
     /// What the player reads before turning the mod on: "May <this>".
@@ -114,6 +122,7 @@ impl Capability {
             Capability::Storage => "save its own settings to disk",
             Capability::Registries => "add blocks and items to your worlds",
             Capability::Players => "see who is on the server and message them",
+            Capability::World => "read and change the world's blocks",
         }
     }
     /// The capability a component import needs, `Ok(None)` for one every
@@ -145,6 +154,7 @@ impl fmt::Display for Capability {
             Capability::Storage => "storage",
             Capability::Registries => "registries",
             Capability::Players => "players",
+            Capability::World => "world",
         };
         f.write_str(name)
     }
diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs
index e80dbdc9f..fa0998614 100644
--- a/crates/horizon-mods/src/runtime.rs
+++ b/crates/horizon-mods/src/runtime.rs
@@ -1,12 +1,13 @@
 //! Loading and calling mods with wasmtime's component model.
 use crate::manifest::{Manifest, Package, Side};
 use server_bindings::{
-    HorizonServerMod, exports::horizon::mods::server_events::Registration as ServerRegistration,
-    horizon::mods::players,
+    HorizonServerMod,
+    exports::horizon::mods::server_events::Registration as ServerRegistration,
+    horizon::mods::{players, world as mod_world},
 };
 use std::{
     path::{Path, PathBuf},
-    sync::Arc,
+    sync::{Arc, Mutex},
     time::{Duration, Instant, SystemTime},
 };
 use wasmtime::{
@@ -25,6 +26,7 @@ mod server_bindings {
     wasmtime::component::bindgen!({
         path: "../horizon-mod-sdk/wit",
         world: "horizon-server-mod",
+        additional_derives: [PartialEq],
         with: {
             "horizon:mods/log": super::bindings::horizon::mods::log,
             "horizon:mods/storage": super::bindings::horizon::mods::storage,
@@ -43,6 +45,7 @@ use bindings::{
 pub use server_bindings::{
     exports::horizon::mods::server_events::BlockPos,
     horizon::mods::players::{GameMode, Player as ServerPlayer},
+    horizon::mods::world::BlockChange,
 };
 type ClientEvents = bindings::exports::horizon::mods::events::Guest;
 type ServerEvents = server_bindings::exports::horizon::mods::server_events::Guest;
@@ -55,6 +58,8 @@ const FUEL_INIT: u64 = 2_000_000_000;
 const FUEL_TICK: u64 = 50_000_000;
 const FUEL_FRAME: u64 = 10_000_000;
 const FUEL_EVENT: u64 = 100_000_000;
+/// Blocks a mod may set per `world.set-blocks` call.
+pub const BLOCKS_PER_CALL: usize = 4096;
 /// Chat lines a mod may show per call, HUD lines and their length.
 const CHAT_PER_CALL: usize = 8;
 const HUD_LINES: usize = 16;
@@ -121,8 +126,32 @@ pub enum Output {
         text: String,
         error: bool,
     },
+    /// `world.set-blocks`: changes to make in `dimension`, in order, each
+    /// state checked by the [`WorldView`] lent for the call.
+    SetBlocks {
+        name: String,
+        dimension: String,
+        blocks: Vec<BlockChange>,
+    },
 }
 
+/// The game's world as capability `world` reads it during a call: the
+/// game lends one with [`Mods::lend_world`] and takes it back after.
+pub trait WorldView: std::any::Any + Send {
+    /// The block state at a position, `minecraft:oak_log[axis=y]`; `None`
+    /// where no chunk of that dimension is loaded.
+    fn block(&self, dimension: &str, x: i32, y: i32, z: i32) -> Option<String>;
+    /// The biome at a position, `minecraft:plains`; `None` as for blocks.
+    fn biome(&self, dimension: &str, x: i32, y: i32, z: i32) -> Option<String>;
+    /// Whether `dimension` is one the server has.
+    fn has_dimension(&self, dimension: &str) -> bool;
+    /// `Err` (why) for a state string that names no block state.
+    fn check_state(&self, state: &str) -> Result<(), String>;
+}
+
+/// The view lent for the current calls, shared by every mod's store.
+type WorldSlot = Arc<Mutex<Option<Box<dyn WorldView>>>>;
+
 /// A mod's text panel, drawn every frame until it changes.
 #[derive(Clone, Debug)]
 pub struct Panel {
@@ -199,6 +228,7 @@ struct State {
     /// needs its own budget.
     storage_budget: u64,
     limits: StoreLimits,
+    world: WorldSlot,
 }
 
 /// The installed mods and the engine running them. `Mods::default()` is
@@ -209,9 +239,33 @@ pub struct Mods {
     entries: Vec<Entry>,
     snapshot: Arc<Snapshot>,
     out: Vec<Output>,
+    world: WorldSlot,
 }
 
 impl Mods {
+    /// Whether a running mod may use capability `world`: only then is a
+    /// view worth lending.
+    pub fn wants_world(&self) -> bool {
+        self.entries.iter().any(|e| {
+            e.status == Status::Running
+                && e.manifest
+                    .as_ref()
+                    .is_some_and(|m| m.capabilities.contains(&crate::Capability::World))
+        })
+    }
+    /// Lends the game's world to capability `world` for the calls until
+    /// [`Mods::take_world`]; with none lent, `get-block` finds nothing and
+    /// `set-blocks` checks only its count.
+    pub fn lend_world(&mut self, view: Box<dyn WorldView>) {
+        if let Ok(mut slot) = self.world.lock() {
+            *slot = Some(view);
+        }
+    }
+    /// The view [`Mods::lend_world`] lent, back to the game.
+    pub fn take_world(&mut self) -> Option<Box<dyn WorldView>> {
+        self.world.lock().ok()?.take()
+    }
+
     /// Reads every mod at `paths` and starts those `enabled` says are on,
     /// client and server mods alike. A command that `reserved` (vanilla's
     /// commands) or an earlier mod already uses is refused.
@@ -281,6 +335,8 @@ impl Mods {
                 .map_err(|e| e.to_string())?;
             players::add_to_linker::<State, HasSelf<State>>(&mut linker, |s| s)
                 .map_err(|e| e.to_string())?;
+            mod_world::add_to_linker::<State, HasSelf<State>>(&mut linker, |s| s)
+                .map_err(|e| e.to_string())?;
             self.engine = Some((engine, linker));
         }
         Ok(self.engine.as_ref().expect("made above"))
@@ -318,6 +374,7 @@ impl Mods {
             .flat_map(|r| r.hooks.commands().iter().cloned())
             .collect();
         let snapshot = self.snapshot.clone();
+        let world = self.world.clone();
         let (engine, linker) = self.engine()?;
         let component =
             Component::new(engine, wasm).map_err(|e| format!("not a component: {e}"))?;
@@ -344,6 +401,7 @@ impl Mods {
                 .memory_size(MEMORY)
                 .instances(16)
                 .build(),
+            world,
         };
         let mut store = Store::new(engine, state);
         store.limiter(|s| &mut s.limits);
@@ -731,6 +789,40 @@ impl chat::Host for State {
         });
     }
 }
+impl mod_world::Host for State {
+    fn get_block(&mut self, dimension: String, x: i32, y: i32, z: i32) -> Option<String> {
+        let view = self.world.lock().ok()?;
+        view.as_ref()?.block(&dimension, x, y, z)
+    }
+    fn get_biome(&mut self, dimension: String, x: i32, y: i32, z: i32) -> Option<String> {
+        let view = self.world.lock().ok()?;
+        view.as_ref()?.biome(&dimension, x, y, z)
+    }
+    fn set_blocks(&mut self, dimension: String, blocks: Vec<BlockChange>) -> Result<(), String> {
+        if blocks.len() > BLOCKS_PER_CALL {
+            return Err(format!(
+                "{} blocks: at most {BLOCKS_PER_CALL} per call",
+                blocks.len()
+            ));
+        }
+        if let Some(view) = self.world.lock().ok().as_ref().and_then(|v| v.as_ref()) {
+            if !view.has_dimension(&dimension) {
+                return Err(format!("no dimension {dimension}"));
+            }
+            for b in &blocks {
+                view.check_state(&b.state)?;
+            }
+        }
+        if !blocks.is_empty() {
+            self.out.push(Output::SetBlocks {
+                name: self.name.clone(),
+                dimension,
+                blocks,
+            });
+        }
+        Ok(())
+    }
+}
 impl players::Host for State {
     fn online(&mut self) -> Vec<ServerPlayer> {
         self.snapshot.players.clone()
diff --git a/crates/horizon-mods/src/testing.rs b/crates/horizon-mods/src/testing.rs
index 31ff27227..239642357 100644
--- a/crates/horizon-mods/src/testing.rs
+++ b/crates/horizon-mods/src/testing.rs
@@ -29,6 +29,54 @@ pub struct TestGame {
     /// Every name that joined, for their id.
     names: Vec<String>,
     tick: u64,
+    /// Capability `world`'s Overworld: the blocks a script set or the mod
+    /// changed; every other block, and the other dimensions, are air. Every
+    /// biome is the dimension's plainest: plains, nether wastes, the end.
+    pub world: std::collections::BTreeMap<(i32, i32, i32), String>,
+}
+
+/// The world a script's mod reads: [`TestGame::world`], copied for a step.
+struct ScriptWorld(std::collections::BTreeMap<(i32, i32, i32), String>);
+
+impl crate::WorldView for ScriptWorld {
+    fn block(&self, dimension: &str, x: i32, y: i32, z: i32) -> Option<String> {
+        let here = (dimension == "minecraft:overworld")
+            .then(|| self.0.get(&(x, y, z)).cloned())
+            .flatten();
+        Some(here.unwrap_or_else(|| "minecraft:air".into()))
+    }
+    fn biome(&self, dimension: &str, _x: i32, _y: i32, _z: i32) -> Option<String> {
+        let biome = match dimension {
+            "minecraft:overworld" => "minecraft:plains",
+            "minecraft:the_nether" => "minecraft:nether_wastes",
+            "minecraft:the_end" => "minecraft:the_end",
+            _ => return None,
+        };
+        Some(biome.into())
+    }
+    fn has_dimension(&self, dimension: &str) -> bool {
+        matches!(
+            dimension,
+            "minecraft:overworld" | "minecraft:the_nether" | "minecraft:the_end"
+        )
+    }
+    fn check_state(&self, state: &str) -> Result<(), String> {
+        // No registry here: the shape only (the game checks the names).
+        let name = state.split('[').next().unwrap_or_default();
+        let plain = |t: &str| {
+            !t.is_empty()
+                && t.bytes()
+                    .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b"_.-/".contains(&b))
+        };
+        let ok = match name.split_once(':') {
+            Some((ns, path)) => plain(ns) && plain(path),
+            None => plain(name),
+        };
+        let closed = !state.contains('[') || state.ends_with(']');
+        (ok && closed)
+            .then_some(())
+            .ok_or_else(|| format!("{state} is not a block state"))
+    }
 }
 
 /// Where a script starts: standing at 0.5 64 0.5 in the Overworld, facing
@@ -71,6 +119,7 @@ impl TestGame {
             players: Vec::new(),
             names: Vec::new(),
             tick: 0,
+            world: Default::default(),
         };
         copy_mod(hmod, &copy)?;
         game.start()?;
@@ -309,9 +358,10 @@ pub struct ClockSet {
 }
 
 /// One step. Its parts happen in this order: `reload`, `title-screen`,
-/// `join`, `player`, `clock`, `ticks`, `frames`, `chat`, `command`, `break`,
-/// `place`, `leave`; then `expect` is checked against what the mod showed
-/// during the step. For a server mod, `player`, `chat`, `command`, `break`
+/// `blocks`, `join`, `player`, `clock`, `ticks`, `frames`, `chat`, `command`,
+/// `break`, `place`, `leave`; then the blocks the mod set are made, and
+/// `expect` is checked against what the mod showed and changed during the
+/// step. For a server mod, `player`, `chat`, `command`, `break`
 /// and `place` are the doing of the player named by `as`, or of the first
 /// player on.
 #[derive(Debug, Default, Deserialize)]
@@ -338,6 +388,10 @@ pub struct Step {
     #[serde(rename = "break")]
     broken: Option<BlockSet>,
     place: Option<BlockSet>,
+    /// Blocks of the Overworld before the rest of the step (capability
+    /// `world`); every other block is air.
+    #[serde(default)]
+    blocks: Vec<BlockSet>,
     #[serde(default)]
     expect: Expect,
 }
@@ -360,6 +414,9 @@ pub struct Expect {
     /// The panel's lines (`[]`: no panel) and its corner.
     panel: Option<Vec<String>>,
     corner: Option<String>,
+    /// Blocks of the Overworld after the step, the mod's changes made
+    /// (capability `world`).
+    blocks: Option<Vec<BlockSet>>,
     /// The mod is turned off during this step, for a reason holding this text.
     /// Without it, a mod that stops fails the test.
     stopped: Option<String>,
@@ -464,6 +521,11 @@ impl Step {
             game.player = None;
             game.clock = None;
         }
+        for b in &self.blocks {
+            game.world.insert((b.x, b.y, b.z), b.state.clone());
+        }
+        game.mods
+            .lend_world(Box::new(ScriptWorld(game.world.clone())));
         if let Some(name) = &self.join {
             game.join(name);
         }
@@ -528,7 +590,19 @@ impl Step {
         {
             return Err(format!("{name} is not on the server"));
         }
+        game.mods.take_world();
         let out = game.drain();
+        for o in &out {
+            if let Output::SetBlocks {
+                dimension, blocks, ..
+            } = o
+                && dimension == "minecraft:overworld"
+            {
+                for b in blocks {
+                    game.world.insert((b.x, b.y, b.z), b.state.clone());
+                }
+            }
+        }
         let stopped = out.iter().find_map(|o| match o {
             Output::Stopped { reason, .. } => Some(reason.as_str()),
             _ => None,
@@ -612,6 +686,18 @@ impl Step {
                 .unwrap_or_default();
             same("panel", want, &got)?;
         }
+        if let Some(want) = &e.blocks {
+            for b in want {
+                let got = game.world.get(&(b.x, b.y, b.z));
+                let got = got.map_or("minecraft:air", String::as_str);
+                if got != b.state {
+                    return Err(format!(
+                        "block at {} {} {}: expected {}, got {got}",
+                        b.x, b.y, b.z, b.state
+                    ));
+                }
+            }
+        }
         if let Some(want) = &e.corner {
             let got = game.panel().map(|p| corner_name(p.corner).to_string());
             same("corner", &Some(want.clone()), &got)?;
diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs
index ca2b8896e..3647cca30 100644
--- a/crates/horizon-mods/tests/sandbox.rs
+++ b/crates/horizon-mods/tests/sandbox.rs
@@ -36,6 +36,8 @@ fn mods_dir() -> &'static Path {
                 "-p",
                 "welcome",
                 "-p",
+                "beacons",
+                "-p",
                 "horizon-mods-test-guest",
                 "--target-dir",
             ])
@@ -56,6 +58,7 @@ fn mods_dir() -> &'static Path {
         let mods = [
             ("coords_hud", example("coords-hud")),
             ("welcome", example("welcome")),
+            ("beacons", example("beacons")),
             ("horizon_mods_test_guest", GUEST_MANIFEST.to_string()),
         ];
         for (name, manifest) in mods {
@@ -412,7 +415,12 @@ capabilities = ["registries"]
 fn the_examples_test_scripts_pass() {
     let examples = Path::new(env!("CARGO_MANIFEST_DIR")).join("../horizon-mod-sdk/examples");
     let mut ran = 0;
-    for (example, hmod) in [("coords-hud", "coords_hud"), ("welcome", "welcome")] {
+    let examples_and_files = [
+        ("coords-hud", "coords_hud"),
+        ("welcome", "welcome"),
+        ("beacons", "beacons"),
+    ];
+    for (example, hmod) in examples_and_files {
         for entry in std::fs::read_dir(examples.join(example).join("tests")).unwrap() {
             let path = entry.unwrap().path();
             let script = Script::parse(&std::fs::read_to_string(&path).unwrap()).unwrap();
@@ -423,7 +431,24 @@ fn the_examples_test_scripts_pass() {
             ran += 1;
         }
     }
-    assert_eq!(ran, 4);
+    assert_eq!(ran, 5);
+}
+
+/// Capability `world` without a world lent (the registry's trial run):
+/// `get-block` finds nothing, `set-blocks` checks its count and queues.
+#[test]
+fn a_server_mod_without_a_world_reads_nothing() {
+    let mut game = TestGame::load(&mods_dir().join("beacons.hmod")).unwrap();
+    game.join("Alex");
+    let alex = game.players[0].clone();
+    assert!(game.player_command(&alex, "ground"));
+    let out = game.drain();
+    assert!(
+        out.iter()
+            .any(|o| matches!(o, Output::Reply { text, error: true, .. }
+            if text == "The ground under you isn't loaded")),
+        "{out:?}"
+    );
 }
 
 #[test]
diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md
index f179e99cc..3aaf29d0c 100644
--- a/docs/api/mods-reference.md
+++ b/docs/api/mods-reference.md
@@ -13,6 +13,7 @@ The contract between Horizon and its mods: the WIT package `horizon:mods@0.1.0`,
 | `storage` | [`storage`](#storage) | save its own settings to disk |
 | `registries` | data files (`assets/`, `data/`), no interface | add blocks and items to your worlds |
 | `players` | [`players`](#players) | see who is on the server and message them |
+| `world` | [`world`](#world) | read and change the world's blocks |
 
 ## World `horizon-mod`
 
@@ -25,7 +26,7 @@ A client mod: runs in the player's game.
 
 A server mod (manifest `side = "server"`, `api = "0.3"`, experimental): runs where the world is simulated, on the dedicated server, a LAN host and single player's own server.
 
-- Imports (what the game offers): `log`, `storage`, `players`
+- Imports (what the game offers): `log`, `storage`, `players`, `world`
 - Exports (what the mod provides): `server-events`
 
 ## `log`
@@ -184,6 +185,27 @@ Capability `players`, server mods only (manifest `api = "0.3"`, experimental): t
 | `tell` | `func(player: string, text: string) -> bool` | A system message to one player, after the mod's name; false when no player with that id is online. Up to 8 messages per call. |
 | `broadcast` | `func(text: string)` | A system message to every player and the server's log, after the mod's name. Counts toward the same 8 per call. |
 
+## `world`
+
+Access: capability `world`.
+
+Capability `world`, server mods only (manifest `api = "0.3"`, experimental): the blocks of the server's loaded chunks, and changes to them through the server's own block updates.
+
+### record `block-change`
+
+| Field | Type | |
+| --- | --- | --- |
+| `x` | `s32` |  |
+| `y` | `s32` |  |
+| `z` | `s32` |  |
+| `state` | `string` | `minecraft:oak_log[axis=y]`; properties left out take the block's defaults, `minecraft:stone` alone is the default state. |
+
+| Function | Signature | What it does |
+| --- | --- | --- |
+| `get-block` | `func(dimension: string, x: s32, y: s32, z: s32) -> option<string>` | The block state at a position in a dimension (`minecraft:overworld`, ...), as `minecraft:oak_log[axis=y]`, as of this call: none where the server has no chunk loaded there. |
+| `get-biome` | `func(dimension: string, x: s32, y: s32, z: s32) -> option<string>` | The biome at a position (`minecraft:plains`, ...), as the server stores it (one per 4 x 4 x 4 cell): none where no chunk is loaded. |
+| `set-blocks` | `func(dimension: string, blocks: list<block-change>) -> result<_, string>` | Sets blocks as `/setblock` does: the old block entity removed, neighbours and shapes updated, light, and every player told. Every state is checked now (an error queues nothing); the changes are made in order after this call returns, before that dimension's next tick; one in a chunk not loaded then is skipped. At most 4096 per call. |
+
 ## `server-events`
 
 Access: exported by the mod: the game calls it.
diff --git a/docs/api/mods.md b/docs/api/mods.md
index 5fb9d9c1e..76075e989 100644
--- a/docs/api/mods.md
+++ b/docs/api/mods.md
@@ -84,11 +84,11 @@ release.
 What real mods need next, in the order modpacks and servers need it:
 
 - **More for server mods** (`api = "0.3"`, [Server mods](../mods.md#server-mods-api-03-experimental)): they run
-  on the server thread, a LAN host and the dedicated server today, with joins, chat, commands and players' block
-  breaking and placing; next entity events, game rules, server commands with typed arguments sent to clients'
-  command trees.
-- **World and blocks**: read blocks, block states and biomes in loaded chunks; change them through the server's block
-  log, so clients and the parity harnesses see vanilla's updates.
+  on the server thread, a LAN host and the dedicated server today, with joins, chat, commands, players' block
+  breaking and placing, and `world` (read blocks and biomes, set blocks as `/setblock` does); next entity events, game rules,
+  server commands with typed arguments sent to clients' command trees.
+- **World and blocks**: blocks, block states and biomes are there for server mods (`world`); next block entities,
+  and `world` for client mods (raycasts, single player and LAN hosts).
 - **Items and inventories**: the player's inventory, held item and open container; item stacks with components.
 - **Entities**: query and change entities near a position; spawn from a mod's own entity types (data first).
 - **Block entities and menus**: ticking machines with slots and their screens.
@@ -102,6 +102,8 @@ What real mods need next, in the order modpacks and servers need it:
 
 ## Changelog
 
+- API 0.3: capability `world` (`get-block`, `get-biome`, `set-blocks`); example `beacons`; test scripts' `blocks` and
+  `expect.blocks`.
 - Server mods run in the game: single player (server thread and in-frame), LAN hosts, the dedicated server.
 - API 0.3 (server mods, experimental): world `horizon-server-mod`, capability `players`, the `server-events`
   hooks; SDK `server::ServerMod`; example `welcome`.
diff --git a/docs/mods.md b/docs/mods.md
index f0df45994..19b05f9ec 100644
--- a/docs/mods.md
+++ b/docs/mods.md
@@ -278,6 +278,7 @@ A step's parts happen in this order:
 | --- | --- |
 | `reload = true` | stops the mod and starts it again, as a rebuild does in the game: its memory starts over, its `storage` stays |
 | `title-screen = true` | no player and no clock until a step sets them |
+| `blocks = [{ x = 0, y = 63, z = 0, state = "minecraft:stone" }]` | server mods with `world`: those blocks of the Overworld, before the rest of the step (every other block is air, every biome the dimension's plainest: plains, nether wastes, the end) |
 | `player = { x = 3.0, ... }`, `clock = { day-time = 0 }` | changes those fields (`x y z yaw pitch health food dimension`, `game-time day-time`) |
 | `ticks = n`, `frames = n` | that many ticks (the game's tick counter and the clock move on), then frames 1/60 s apart |
 | `chat = "<Steve> hi"` | a chat line the player receives |
@@ -303,6 +304,7 @@ checked:
 | `feedback = "..."`, `error = "..."` | the command's answer, shown plain or in red |
 | `panel = ["..."]`, `corner = "top-left"` | its HUD panel's lines (`[]`: no panel) and corner |
 | `told = ["Alex: Welcome!"]`, `broadcast = ["..."]` | server mods: every `players.tell` (as `name: text`) and `players.broadcast`, in order |
+| `blocks = [{ x = 2, y = 64, z = 0, state = "minecraft:glowstone" }]` | server mods with `world`: those blocks of the Overworld after the step, the mod's `set-blocks` made (the script checks a state's shape; the game checks its name) |
 | `stopped = "panic"` | the mod was turned off, for a reason holding this text; without it, a mod that traps, panics or overruns fails the test |
 
 Unknown keys are errors, so a typo never passes silently. The same runner is
@@ -465,6 +467,7 @@ its component targets the WIT world `horizon-server-mod` instead of
 | `log` | always | as for client mods |
 | `storage` | `storage` | as for client mods, in the server's `horizon-mods/` |
 | `players` | `players` | `online()`: id, name, position, dimension, game mode, health of each player on; `tell(id, text)`, `broadcast(text)`: system messages after the mod's name, 8 per call |
+| `world` | `world` | `get-block(dimension, x, y, z)`: the state in a loaded chunk, `minecraft:oak_log[axis=y]`; `get-biome(dimension, x, y, z)`: `minecraft:plains`, ...; `set-blocks(dimension, changes)`: up to 4096 per call, checked at once, made as `/setblock` makes them (neighbours, light, block entities, every player told) after the call, before that dimension's next tick |
 
 | Hook (export `server-events`) | When |
 |---|---|
@@ -478,7 +481,20 @@ its component targets the WIT world `horizon-server-mod` instead of
 Capabilities that act on a local player (`game-read`, `chat`, `hud`) are for
 client mods; `players` is for server mods. In Rust: `impl
 horizon_mod_sdk::server::ServerMod` and `export_server_mod!`; the example is
-[`welcome`](../crates/horizon-mod-sdk/examples/welcome/src/lib.rs).
+[`welcome`](../crates/horizon-mod-sdk/examples/welcome/src/lib.rs), and with
+`world`, [`beacons`](../crates/horizon-mod-sdk/examples/beacons/src/lib.rs).
+
+**Capability `world`.** Reads are of the server's loaded chunks as they are
+during the call: the game lends a server mod's call the levels' chunk maps
+(moved, not copied, and only while a running mod has `world`), so a read
+costs a map lookup and no copy of the world. A dimension with no chunk loaded
+at a position reads as none. Writes go through the same code as `/setblock`,
+so block updates, light, block entities and every client (LAN guests,
+dedicated server players) see them as vanilla's; the parity harnesses test
+that code. Changes for a dimension whose level isn't ticking wait for it
+(in-frame single player ticks only the player's), up to 65,536 blocks; a
+change in a chunk that isn't loaded when it is made is skipped, as `/setblock`
+refuses one.
 
 **Where they run.** The game that simulates the world starts the server mods
 that are on, and only that one:

From c5bb51bb053a7f41acf7361f831091a7b54ce493 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Sun, 25 Oct 2026 19:19:50 +0100
Subject: [PATCH 002/475] Mod API 0.3: typed server commands, in players'
 command trees

A server mod's registration now lists each command's arguments: a name, a
kind (word, text, integer with bounds, number, boolean, player, block-pos)
and whether it is optional. The server adds them to the command tree every
player receives, after vanilla's commands, so a player's chat box completes
and colours them as vanilla's. When a player sends one, the server parses
the line as vanilla's parsers do (horizon-mods' commands.rs: ~ coordinates
from the player, @s/@p, integer bounds) and calls the mod's command hook
with the values by name, or answers with vanilla's error without calling
the mod.

The hub keeps the server mods' commands as a root in the commands report's
format and resends players' trees when they change (CommandTree::
packet_with); the game sets it when its mods start, stop or reload, or a
hub opens. In-frame, the window's own chat box lists them by name.

SDK: Registration::command_with(name, [Argument::...]), Argument builders,
Args (text(), integer(), player(), block_pos() ...); command(name) is free
text, an optional text argument. Examples: welcome's /mined [player],
beacons' /beacon [height] and /ground [pos], with scripts for values and
errors.

Docs: docs/mods.md (typed commands, kinds table), docs/api/mods.md and
the regenerated reference.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/cargo-horizon-mod/src/check.rs         |   2 +-
 crates/horizon-client/src/game/mods.rs        |   5 +-
 crates/horizon-client/src/game/server_mods.rs |  74 ++++-
 crates/horizon-client/src/lan/commands.rs     |  63 +++-
 crates/horizon-client/src/lan/hub.rs          |  29 +-
 .../examples/beacons/horizon-mod.toml         |   2 +-
 .../examples/beacons/src/lib.rs               |  46 ++-
 .../examples/beacons/tests/beacons.toml       |  19 +-
 .../examples/welcome/src/lib.rs               |  25 +-
 .../examples/welcome/tests/commands.toml      |  17 +-
 crates/horizon-mod-sdk/src/lib.rs             | 135 +++++++-
 crates/horizon-mod-sdk/wit/horizon.wit        |  68 +++-
 crates/horizon-mods/src/commands.rs           | 301 ++++++++++++++++++
 crates/horizon-mods/src/lib.rs                |   2 +
 crates/horizon-mods/src/runtime.rs            | 117 +++++--
 crates/horizon-mods/src/testing.rs            |   2 +-
 crates/horizon-mods/tests/sandbox.rs          |  12 +-
 docs/api/mods-reference.md                    |  65 +++-
 docs/api/mods.md                              |  11 +-
 docs/mods.md                                  |  36 ++-
 20 files changed, 923 insertions(+), 108 deletions(-)
 create mode 100644 crates/horizon-mods/src/commands.rs

diff --git a/crates/cargo-horizon-mod/src/check.rs b/crates/cargo-horizon-mod/src/check.rs
index 4d271e2c1..7e3091805 100644
--- a/crates/cargo-horizon-mod/src/check.rs
+++ b/crates/cargo-horizon-mod/src/check.rs
@@ -183,7 +183,7 @@ fn play(path: &Path, report: &mut Report) -> Result<(), String> {
         return Err(format!("it didn't start: {reason}"));
     }
     let client: Vec<String> = mods.commands().map(str::to_owned).collect();
-    let server: Vec<String> = mods.server_commands().map(str::to_owned).collect();
+    let server: Vec<String> = mods.server_commands().map(|c| c.name.clone()).collect();
     report.commands = [client.clone(), server.clone()].concat();
     // A server mod plays with one player on, who joins, chats and leaves.
     let steve = ServerPlayer {
diff --git a/crates/horizon-client/src/game/mods.rs b/crates/horizon-client/src/game/mods.rs
index 111b797ad..0c3d32a40 100644
--- a/crates/horizon-client/src/game/mods.rs
+++ b/crates/horizon-client/src/game/mods.rs
@@ -262,7 +262,10 @@ impl Game<'_> {
     }
     /// The chat's tree after the running mods changed.
     fn sync_mod_commands(&mut self) {
-        let mut names = self.mods.mods.commands().peekable();
+        // In-frame, the window runs server mods too: their names, free text
+        // here (the server parses their arguments).
+        let server = self.mods.mods.server_commands().map(|c| c.name.as_str());
+        let mut names = self.mods.mods.commands().chain(server).peekable();
         self.mods.tree = names
             .peek()
             .is_some()
diff --git a/crates/horizon-client/src/game/server_mods.rs b/crates/horizon-client/src/game/server_mods.rs
index f5ee5cdc2..a5a4b0f3f 100644
--- a/crates/horizon-client/src/game/server_mods.rs
+++ b/crates/horizon-client/src/game/server_mods.rs
@@ -59,9 +59,12 @@ mod run {
         lan::data::component_nbt,
         text::{self, Text},
     };
-    use horizon_mods::{BlockPos, GameMode, Output, ServerPlayer, WorldView};
+    use horizon_mods::{
+        ArgumentKind, BlockPos, GameMode, Output, ServerCommand, ServerPlayer, WorldView,
+    };
     use horizon_protocol::packets::play::{self, Clientbound as C};
     use horizon_world::registry::{BlockRegistry, BlockStateId};
+    use serde_json::{Value, json};
 
     /// Blocks queued for levels that don't tick (another dimension, in-frame)
     /// are kept up to this many; the oldest go first.
@@ -98,6 +101,60 @@ mod run {
         }
     }
 
+    /// Server mods' commands as a root of the commands report
+    /// (`lan::commands`): a literal per command, then its arguments in a
+    /// chain, each node runnable where only optional arguments follow.
+    fn command_tree<'a>(commands: impl Iterator<Item = &'a ServerCommand>) -> Value {
+        let mut root = serde_json::Map::new();
+        for c in commands {
+            let mut next: Option<(String, Value)> = None;
+            for (i, a) in c.arguments.iter().enumerate().rev() {
+                let executable = c.arguments.get(i + 1).is_none_or(|b| b.optional);
+                let (parser, properties) = match a.kind {
+                    ArgumentKind::Word => ("brigadier:string", json!({"type": "word"})),
+                    ArgumentKind::Text => ("brigadier:string", json!({"type": "greedy"})),
+                    ArgumentKind::Integer((min, max)) => {
+                        let mut p = serde_json::Map::new();
+                        if let Some(min) = min {
+                            p.insert("min".into(), min.into());
+                        }
+                        if let Some(max) = max {
+                            p.insert("max".into(), max.into());
+                        }
+                        ("brigadier:integer", Value::Object(p))
+                    }
+                    ArgumentKind::Number => ("brigadier:double", Value::Null),
+                    ArgumentKind::Boolean => ("brigadier:bool", Value::Null),
+                    ArgumentKind::Player => (
+                        "minecraft:entity",
+                        json!({"amount": "single", "type": "players"}),
+                    ),
+                    ArgumentKind::BlockPos => ("minecraft:block_pos", Value::Null),
+                };
+                let mut node = json!({
+                    "type": "argument",
+                    "parser": parser,
+                    "properties": properties,
+                    "executable": executable,
+                });
+                if let Some((name, child)) = next.take() {
+                    node["children"] = json!({ name: child });
+                }
+                next = Some((a.name.clone(), node));
+            }
+            let executable = c.arguments.first().is_none_or(|a| a.optional);
+            let mut literal = json!({"type": "literal", "executable": executable});
+            if let Some((name, child)) = next {
+                literal["children"] = json!({ name: child });
+            }
+            root.insert(c.name.clone(), literal);
+        }
+        if root.is_empty() {
+            return Value::Null;
+        }
+        json!({"type": "root", "children": root})
+    }
+
     /// `minecraft:oak_log[axis=y]`.
     fn state_string(registry: &BlockRegistry, state: BlockStateId) -> String {
         let Some(s) = registry.state(state) else {
@@ -191,6 +248,7 @@ mod run {
                 // A server has no frames to check its dev mods in.
                 self.reload_dev_mods();
             }
+            self.send_server_mod_commands();
             if !self.mods.server {
                 return;
             }
@@ -257,6 +315,20 @@ mod run {
             self.apply_mod_block_writes();
         }
 
+        /// Players' command trees list the running server mods' commands
+        /// after vanilla's, whenever they change (or a hub opens).
+        fn send_server_mod_commands(&mut self) {
+            let key = self.mods.mods.generation();
+            let Some(host) = self.lan.as_mut() else {
+                return;
+            };
+            if host.hub.mod_commands_key() == Some(key) {
+                return;
+            }
+            let tree = command_tree(self.mods.mods.server_commands());
+            host.hub.set_mod_commands(key, tree);
+        }
+
         /// Lends the levels' chunks to capability `world` for the calls up to
         /// [`Game::return_world`], when a running server mod has it.
         fn lend_world(&mut self) {
diff --git a/crates/horizon-client/src/lan/commands.rs b/crates/horizon-client/src/lan/commands.rs
index 71b7fa68d..c3e462348 100644
--- a/crates/horizon-client/src/lan/commands.rs
+++ b/crates/horizon-client/src/lan/commands.rs
@@ -86,6 +86,18 @@ impl CommandTree {
 
     /// The ClientboundCommandsPacket for a player with `level` permissions.
     pub fn packet(&self, level: u8, dedicated: bool, builtin: &Builtin) -> Commands {
+        self.packet_with(level, dedicated, builtin, &Value::Null)
+    }
+
+    /// [`CommandTree::packet`] with more commands after vanilla's: `extra`
+    /// is a root in the report's format (server mods' commands).
+    pub fn packet_with(
+        &self,
+        level: u8,
+        dedicated: bool,
+        builtin: &Builtin,
+        extra: &Value,
+    ) -> Commands {
         let mut nodes = vec![Node {
             name: String::new(),
             kind: 0,
@@ -99,16 +111,18 @@ impl CommandTree {
         let suggestions: HashMap<&str, &'static str> = SUGGESTIONS.iter().copied().collect();
         let mut paths: HashMap<Vec<String>, usize> = HashMap::new();
         paths.insert(Vec::new(), 0);
-        fill(
-            &self.root,
-            0,
-            &mut Vec::new(),
-            level,
-            dedicated,
-            &suggestions,
-            &mut nodes,
-            &mut paths,
-        );
+        for root in [&self.root, extra] {
+            fill(
+                root,
+                0,
+                &mut Vec::new(),
+                level,
+                dedicated,
+                &suggestions,
+                &mut nodes,
+                &mut paths,
+            );
+        }
         // enumerateNodes: breadth first from the root, each node's children
         // (in registration order) then its redirect target.
         let mut ids = vec![None; nodes.len()];
@@ -365,4 +379,33 @@ mod tests {
         );
         assert!(op.nodes[3].restricted);
     }
+
+    #[test]
+    fn server_mods_commands_follow_vanillas() {
+        let report: Value = serde_json::from_str(
+            r#"{"type":"root","children":{"me":{"type":"literal","children":{"action":{"type":"argument","parser":"minecraft:message","executable":true}}}}}"#,
+        )
+        .unwrap();
+        let mods: Value = serde_json::from_str(
+            r#"{"type":"root","children":{"beacon":{"type":"literal","executable":true,"children":{
+                "height":{"type":"argument","parser":"brigadier:integer","properties":{"min":1,"max":64},"executable":true}}}}}"#,
+        )
+        .unwrap();
+        let tree = CommandTree { root: report };
+        let packet = tree.packet_with(0, true, &Builtin::default(), &mods);
+        let names: Vec<_> = packet.nodes.iter().map(|n| n.name.as_str()).collect();
+        assert_eq!(names, ["", "me", "beacon", "action", "height"]);
+        let beacon = &packet.nodes[2];
+        assert!(beacon.executable && !beacon.restricted);
+        assert_eq!(beacon.children, [4]);
+        let height = packet.nodes[4].parser.as_ref().unwrap();
+        assert_eq!(height.1, vec![3, 0, 0, 0, 1, 0, 0, 0, 64]);
+        // No mods: vanilla's tree as it is.
+        assert_eq!(
+            tree.packet_with(0, true, &Builtin::default(), &Value::Null)
+                .nodes
+                .len(),
+            3
+        );
+    }
 }
diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs
index 761d31af4..2938e530b 100644
--- a/crates/horizon-client/src/lan/hub.rs
+++ b/crates/horizon-client/src/lan/hub.rs
@@ -174,6 +174,9 @@ pub struct Hub {
     entities: std::collections::HashMap<String, Entities>,
     /// What one tick of entity tracking sends each guest, kept between ticks.
     entity_out: Vec<Vec<Vec<u8>>>,
+    /// Server mods' commands, a root in the commands report's format, sent
+    /// after vanilla's; the key the game last set them for.
+    mod_commands: (serde_json::Value, Option<u64>),
 }
 
 fn string(s: &str) -> Tag {
@@ -320,6 +323,7 @@ impl Hub {
             entity_types: Default::default(),
             entities: Default::default(),
             entity_out: Vec::new(),
+            mod_commands: (serde_json::Value::Null, None),
         }
     }
 
@@ -815,13 +819,36 @@ impl Hub {
         }
     }
 
+    /// The key [`Hub::set_mod_commands`] last had: the game compares it
+    /// with its server mods' each tick.
+    pub fn mod_commands_key(&self) -> Option<u64> {
+        self.mod_commands.1
+    }
+    /// Server mods' commands changed: every player gets their tree again.
+    pub fn set_mod_commands(&mut self, key: u64, commands: serde_json::Value) {
+        let resend = self.mod_commands.0 != commands;
+        self.mod_commands = (commands, Some(key));
+        if resend {
+            for i in 0..self.guests.len() {
+                if self.guests[i].placed {
+                    self.send_commands(i);
+                }
+            }
+        }
+    }
+
     /// Commands.sendCommands: the command tree for this player.
     fn send_commands(&self, i: usize) {
         let g = &self.guests[i];
         let packet = match &self.sync.commands {
             Some(tree) => {
                 let dedicated = self.config.dedicated && !self.config.integrated;
-                tree.packet(g.permission, dedicated, &self.sync.builtin)
+                tree.packet_with(
+                    g.permission,
+                    dedicated,
+                    &self.sync.builtin,
+                    &self.mod_commands.0,
+                )
             }
             None => play::Commands {
                 nodes: vec![play::CommandNode {
diff --git a/crates/horizon-mod-sdk/examples/beacons/horizon-mod.toml b/crates/horizon-mod-sdk/examples/beacons/horizon-mod.toml
index 0c2004b5f..5b58273c6 100644
--- a/crates/horizon-mod-sdk/examples/beacons/horizon-mod.toml
+++ b/crates/horizon-mod-sdk/examples/beacons/horizon-mod.toml
@@ -1,7 +1,7 @@
 id = "beacons"
 name = "Beacons"
 version = "0.1.0"
-description = "/beacon lights a pillar of glowstone beside you; /ground says what you are standing on, and in which biome."
+description = "/beacon [height] lights a pillar of glowstone beside you; /ground [pos] says what you are standing on (or what is at pos), and in which biome."
 authors = ["Horizon"]
 api = "0.3"
 side = "server"
diff --git a/crates/horizon-mod-sdk/examples/beacons/src/lib.rs b/crates/horizon-mod-sdk/examples/beacons/src/lib.rs
index 509431775..4a4de5cc1 100644
--- a/crates/horizon-mod-sdk/examples/beacons/src/lib.rs
+++ b/crates/horizon-mod-sdk/examples/beacons/src/lib.rs
@@ -1,9 +1,12 @@
 //! Example Horizon server mod (`docs/mods.md`, "Server mods") with
-//! capability `world`: `/beacon` lights a pillar of glowstone two blocks east
-//! of the player, `/ground` reads the block under their feet and the biome.
-use horizon_mod_sdk::server::{BlockChange, Player, Registration, ServerMod, players, world};
+//! capability `world` and typed commands: `/beacon [height]` lights a
+//! pillar of glowstone two blocks east of the player, `/ground [pos]` reads
+//! the block under their feet (or at `pos`) and its biome.
+use horizon_mod_sdk::server::{
+    Args, Argument, BlockChange, Player, Registration, ServerMod, players, world,
+};
 
-/// How tall `/beacon` builds.
+/// How tall `/beacon` builds when no height is given.
 const HEIGHT: i32 = 4;
 
 struct Beacons;
@@ -17,10 +20,10 @@ fn feet(player: &Player) -> (i32, i32, i32) {
     )
 }
 
-/// The pillar beside `player`: `HEIGHT` blocks of glowstone, from their feet up.
-fn pillar(player: &Player) -> Vec<BlockChange> {
+/// The pillar beside `player`: `height` blocks of glowstone, from their feet up.
+fn pillar(player: &Player, height: i32) -> Vec<BlockChange> {
     let (x, y, z) = feet(player);
-    (0..HEIGHT)
+    (0..height)
         .map(|dy| BlockChange {
             x: x + 2,
             y: y + dy,
@@ -34,7 +37,12 @@ impl ServerMod for Beacons {
     fn init() -> Result<(Self, Registration), String> {
         Ok((
             Beacons,
-            Registration::new().command("beacon").command("ground"),
+            Registration::new()
+                .command_with(
+                    "beacon",
+                    [Argument::integer("height", Some(1), Some(64)).optional()],
+                )
+                .command_with("ground", [Argument::block_pos("pos").optional()]),
         ))
     }
 
@@ -42,11 +50,12 @@ impl ServerMod for Beacons {
         &mut self,
         player: &Player,
         name: &str,
-        _args: &str,
+        args: &Args,
     ) -> Result<Option<String>, String> {
         let (x, y, z) = feet(player);
         if name == "beacon" {
-            world::set_blocks(&player.dimension, &pillar(player))?;
+            let height = args.integer("height").unwrap_or(HEIGHT);
+            world::set_blocks(&player.dimension, &pillar(player, height))?;
             players::broadcast(&format!(
                 "{} lit a beacon at {} {y} {z}",
                 player.name,
@@ -54,10 +63,17 @@ impl ServerMod for Beacons {
             ));
             return Ok(None);
         }
-        let below = world::get_block(&player.dimension, x, y - 1, z)
-            .ok_or("The ground under you isn't loaded")?;
-        let biome = world::get_biome(&player.dimension, x, y, z).unwrap_or_default();
-        Ok(Some(format!("You are standing on {below} in {biome}")))
+        let (bx, by, bz) = match args.block_pos("pos") {
+            Some(p) => (p.x, p.y, p.z),
+            None => (x, y - 1, z),
+        };
+        let block =
+            world::get_block(&player.dimension, bx, by, bz).ok_or("That block isn't loaded")?;
+        let biome = world::get_biome(&player.dimension, bx, by, bz).unwrap_or_default();
+        if args.block_pos("pos").is_some() {
+            return Ok(Some(format!("{bx} {by} {bz} is {block} in {biome}")));
+        }
+        Ok(Some(format!("You are standing on {block} in {biome}")))
     }
 }
 
@@ -79,7 +95,7 @@ mod tests {
             game_mode: horizon_mod_sdk::server::GameMode::Survival,
             health: 20.0,
         };
-        let blocks = pillar(&p);
+        let blocks = pillar(&p, HEIGHT);
         assert_eq!(blocks.len(), HEIGHT as usize);
         assert_eq!((blocks[0].x, blocks[0].y, blocks[0].z), (1, 64, 3));
         assert_eq!(blocks[3].y, 67);
diff --git a/crates/horizon-mod-sdk/examples/beacons/tests/beacons.toml b/crates/horizon-mod-sdk/examples/beacons/tests/beacons.toml
index e75caeb75..bab4839f3 100644
--- a/crates/horizon-mod-sdk/examples/beacons/tests/beacons.toml
+++ b/crates/horizon-mod-sdk/examples/beacons/tests/beacons.toml
@@ -1,4 +1,4 @@
-# /ground reads the block under the player and the biome; /beacon sets four blocks of glowstone two to the east.
+# /ground [pos] reads the block under the player (or at pos) and the biome; /beacon [height] sets glowstone two to the east.
 
 [[step]]
 join = "Alex"
@@ -20,3 +20,20 @@ expect.blocks = [
 player = { x = 10.5, z = 10.5 }
 command = "ground"
 expect.feedback = "You are standing on minecraft:air in minecraft:plains"
+
+# Typed arguments: a height, a position relative to the player.
+[[step]]
+player = { x = 5.5, y = 64.0, z = 5.5 }
+command = "beacon 2"
+expect.blocks = [
+    { x = 7, y = 65, z = 5, state = "minecraft:glowstone" },
+    { x = 7, y = 66, z = 5, state = "minecraft:air" },
+]
+
+[[step]]
+command = "beacon 65"
+expect.error = "Integer must not be more than 64, found 65"
+
+[[step]]
+command = "ground ~2 ~1 ~"
+expect.feedback = "7 65 5 is minecraft:glowstone in minecraft:plains"
diff --git a/crates/horizon-mod-sdk/examples/welcome/src/lib.rs b/crates/horizon-mod-sdk/examples/welcome/src/lib.rs
index c45712c88..e5a5ef13e 100644
--- a/crates/horizon-mod-sdk/examples/welcome/src/lib.rs
+++ b/crates/horizon-mod-sdk/examples/welcome/src/lib.rs
@@ -1,9 +1,10 @@
 //! Example Horizon server mod (`docs/mods.md`, "Server mods"): greets each
 //! player who joins, announces a newcomer to everyone (the players it has
 //! seen are kept in `storage`), `/online` lists who is on and where, and
-//! `/mined` counts the blocks the player broke since the server started.
+//! `/mined [player]` counts the blocks a player broke since the server
+//! started (typed arguments: the chat box completes the player's name).
 use horizon_mod_sdk::{
-    server::{BlockPos, Player, Registration, ServerMod, players},
+    server::{Args, Argument, BlockPos, Player, Registration, ServerMod, players},
     storage,
 };
 use std::collections::HashMap;
@@ -25,8 +26,8 @@ impl ServerMod for Welcome {
             })
             .unwrap_or_default();
         let hooks = Registration::new()
-            .command("online")
-            .command("mined")
+            .command_with("online", [])
+            .command_with("mined", [Argument::player("player").optional()])
             .on_joins()
             .on_blocks();
         Ok((
@@ -55,7 +56,7 @@ impl ServerMod for Welcome {
         &mut self,
         player: &Player,
         name: &str,
-        _args: &str,
+        args: &Args,
     ) -> Result<Option<String>, String> {
         Ok(Some(match name {
             "online" => players::online()
@@ -69,10 +70,16 @@ impl ServerMod for Welcome {
                 })
                 .collect::<Vec<_>>()
                 .join(", "),
-            _ => {
-                let n = self.mined.get(&player.id).copied().unwrap_or(0);
-                format!("You broke {n} block(s)")
-            }
+            _ => match args.player("player") {
+                Some(other) if other.id != player.id => {
+                    let n = self.mined.get(&other.id).copied().unwrap_or(0);
+                    format!("{} broke {n} block(s)", other.name)
+                }
+                _ => {
+                    let n = self.mined.get(&player.id).copied().unwrap_or(0);
+                    format!("You broke {n} block(s)")
+                }
+            },
         }))
     }
 
diff --git a/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml b/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml
index 5f0018346..a55bd421d 100644
--- a/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml
+++ b/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml
@@ -1,4 +1,4 @@
-# /online lists the players and their dimension; /mined counts the acting player's blocks.
+# /online lists the players and their dimension; /mined [player] counts a player's blocks.
 
 [[step]]
 join = "Alex"
@@ -29,3 +29,18 @@ expect.feedback = "You broke 2 block(s)"
 as = "Steve"
 command = "mined"
 expect.feedback = "You broke 0 block(s)"
+
+[[step]]
+as = "Steve"
+command = "mined alex"
+expect.feedback = "Alex broke 2 block(s)"
+
+# The server parses the arguments before the mod: vanilla's errors.
+[[step]]
+as = "Steve"
+command = "mined Herobrine"
+expect.error = "No player was found"
+
+[[step]]
+command = "online now"
+expect.error = "Incorrect argument for command"
diff --git a/crates/horizon-mod-sdk/src/lib.rs b/crates/horizon-mod-sdk/src/lib.rs
index 98f6a5ef4..875113e94 100644
--- a/crates/horizon-mod-sdk/src/lib.rs
+++ b/crates/horizon-mod-sdk/src/lib.rs
@@ -164,7 +164,10 @@ pub mod server {
         },
     });
 
-    pub use exports::horizon::mods::server_events::{BlockPos, Guest as __Guest, Registration};
+    pub use exports::horizon::mods::server_events::{
+        Argument, ArgumentKind, ArgumentValue, BlockPos, Guest as __Guest, Registration,
+        ServerCommand,
+    };
     pub use horizon::mods::players::{self, GameMode, Player};
     pub use horizon::mods::world::{self, BlockChange};
 
@@ -181,13 +184,14 @@ pub mod server {
         fn player_left(&mut self, _player: &Player) {}
         /// A chat message a player sent, when [`Registration::chat`] is set.
         fn chat(&mut self, _player: &Player, _text: &str) {}
-        /// `/name args` typed by `player`. `Ok(Some(text))` is their
-        /// feedback, `Err(text)` their error in red.
+        /// `/name args` typed by `player`, parsed as the command's
+        /// arguments say ([`Registration::command_with`]). `Ok(Some(text))`
+        /// is their feedback, `Err(text)` their error in red.
         fn command(
             &mut self,
             _player: &Player,
             _name: &str,
-            _args: &str,
+            _args: &Args,
         ) -> Result<Option<String>, String> {
             Err("This command does nothing".into())
         }
@@ -207,9 +211,23 @@ pub mod server {
                 blocks: false,
             }
         }
-        /// Adds `/name`.
-        pub fn command(mut self, name: &str) -> Self {
-            self.commands.push(name.into());
+        /// Adds `/name`, taking free text ([`Args::text`]): one optional
+        /// `text` argument named `args`.
+        pub fn command(self, name: &str) -> Self {
+            self.command_with(name, [Argument::text("args").optional()])
+        }
+        /// Adds `/name` with typed arguments (none: nothing after the name):
+        /// players' chat boxes complete and check them, and the server
+        /// parses them into [`Args`].
+        pub fn command_with(
+            mut self,
+            name: &str,
+            arguments: impl IntoIterator<Item = Argument>,
+        ) -> Self {
+            self.commands.push(ServerCommand {
+                name: name.into(),
+                arguments: arguments.into_iter().collect(),
+            });
             self
         }
         pub fn on_tick(mut self) -> Self {
@@ -234,6 +252,105 @@ pub mod server {
             Self::new()
         }
     }
+
+    impl Argument {
+        fn of(name: &str, kind: ArgumentKind) -> Self {
+            Self {
+                name: name.into(),
+                kind,
+                optional: false,
+            }
+        }
+        /// One word: letters, digits and `_ - . +`.
+        pub fn word(name: &str) -> Self {
+            Self::of(name, ArgumentKind::Word)
+        }
+        /// The rest of the line: only last.
+        pub fn text(name: &str) -> Self {
+            Self::of(name, ArgumentKind::Text)
+        }
+        /// A whole number, at least `min` and at most `max` when given.
+        pub fn integer(name: &str, min: Option<i32>, max: Option<i32>) -> Self {
+            Self::of(name, ArgumentKind::Integer((min, max)))
+        }
+        pub fn number(name: &str) -> Self {
+            Self::of(name, ArgumentKind::Number)
+        }
+        pub fn boolean(name: &str) -> Self {
+            Self::of(name, ArgumentKind::Boolean)
+        }
+        /// One online player: a name, `@s` or `@p`.
+        pub fn player(name: &str) -> Self {
+            Self::of(name, ArgumentKind::Player)
+        }
+        /// `x y z`, each one also `~` or `~n`.
+        pub fn block_pos(name: &str) -> Self {
+            Self::of(name, ArgumentKind::BlockPos)
+        }
+        /// May be left out; optional arguments come after the required ones.
+        pub fn optional(mut self) -> Self {
+            self.optional = true;
+            self
+        }
+    }
+
+    /// A command's arguments: the line as typed, and the values the server
+    /// parsed from it, by argument name.
+    #[derive(Clone, Debug, Default)]
+    pub struct Args {
+        text: String,
+        values: Vec<(String, ArgumentValue)>,
+    }
+    impl Args {
+        pub fn new(text: String, values: Vec<(String, ArgumentValue)>) -> Self {
+            Self { text, values }
+        }
+        /// The line after the command's name, as typed.
+        pub fn text(&self) -> &str {
+            &self.text
+        }
+        /// The value of argument `name`; `None` when it was left out.
+        pub fn get(&self, name: &str) -> Option<&ArgumentValue> {
+            self.values.iter().find(|(n, _)| n == name).map(|(_, v)| v)
+        }
+        pub fn integer(&self, name: &str) -> Option<i32> {
+            match self.get(name)? {
+                ArgumentValue::Integer(n) => Some(*n),
+                _ => None,
+            }
+        }
+        pub fn number(&self, name: &str) -> Option<f64> {
+            match self.get(name)? {
+                ArgumentValue::Number(n) => Some(*n),
+                _ => None,
+            }
+        }
+        /// A `word` or `text` argument.
+        pub fn string(&self, name: &str) -> Option<&str> {
+            match self.get(name)? {
+                ArgumentValue::Word(s) | ArgumentValue::Text(s) => Some(s),
+                _ => None,
+            }
+        }
+        pub fn boolean(&self, name: &str) -> Option<bool> {
+            match self.get(name)? {
+                ArgumentValue::Boolean(b) => Some(*b),
+                _ => None,
+            }
+        }
+        pub fn player(&self, name: &str) -> Option<&Player> {
+            match self.get(name)? {
+                ArgumentValue::Player(p) => Some(p),
+                _ => None,
+            }
+        }
+        pub fn block_pos(&self, name: &str) -> Option<BlockPos> {
+            match self.get(name)? {
+                ArgumentValue::BlockPos(p) => Some(*p),
+                _ => None,
+            }
+        }
+    }
 }
 
 /// Exports a [`ServerMod`](server::ServerMod) as the component's
@@ -243,7 +360,7 @@ macro_rules! export_server_mod {
     ($t:ty) => {
         const _: () = {
             use ::std::cell::RefCell;
-            use $crate::server::{BlockPos, Player, Registration, ServerMod};
+            use $crate::server::{Args, ArgumentValue, BlockPos, Player, Registration, ServerMod};
             ::std::thread_local! {
                 static STATE: RefCell<Option<$t>> = const { RefCell::new(None) };
             }
@@ -277,8 +394,10 @@ macro_rules! export_server_mod {
                     player: Player,
                     name: String,
                     args: String,
+                    values: Vec<(String, ArgumentValue)>,
                 ) -> Result<Option<String>, String> {
                     let mut out = Err("The mod is not running".to_string());
+                    let args = Args::new(args, values);
                     with(|m| out = m.command(&player, &name, &args));
                     out
                 }
diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit
index f0dd1c596..e8cea0d02 100644
--- a/crates/horizon-mod-sdk/wit/horizon.wit
+++ b/crates/horizon-mod-sdk/wit/horizon.wit
@@ -177,10 +177,61 @@ interface %world {
 interface server-events {
     use players.{player};
 
+    record block-pos {
+        x: s32,
+        y: s32,
+        z: s32,
+    }
+    /// What an argument of a command takes. The server sends each command
+    /// and its arguments to players' games, whose chat box completes and
+    /// colours them as vanilla's; the server parses them before the mod's
+    /// `command` hook gets their values.
+    variant argument-kind {
+        /// One word: letters, digits and `_ - . +`.
+        word,
+        /// The rest of the line, spaces included: only last.
+        text,
+        /// A whole number, within the bounds given.
+        integer(tuple<option<s32>, option<s32>>),
+        /// A number with or without decimals.
+        number,
+        /// `true` or `false`.
+        boolean,
+        /// One online player: a name, or `@s` or `@p` (whoever typed it,
+        /// as vanilla picks for a player).
+        player,
+        /// A block position: three whole numbers, each one also `~` or
+        /// `~n`, relative to whoever typed it.
+        block-pos,
+    }
+    record argument {
+        /// Shown in the chat box's hint (`<height>`) and the key of its value.
+        name: string,
+        kind: argument-kind,
+        /// Optional arguments come after every required one.
+        optional: bool,
+    }
+    record server-command {
+        /// Without the slash. A name vanilla already uses is refused
+        /// (vanilla's command runs).
+        name: string,
+        /// In order; none: the command takes nothing after its name. Free
+        /// text is one optional `text` argument.
+        arguments: list<argument>,
+    }
+    /// An argument's value, parsed as its kind says.
+    variant argument-value {
+        word(string),
+        text(string),
+        integer(s32),
+        number(f64),
+        boolean(bool),
+        player(player),
+        block-pos(block-pos),
+    }
     record registration {
-        /// Commands players may type, without the slash. A name vanilla
-        /// already uses is refused (vanilla's command runs).
-        commands: list<string>,
+        /// Commands players may type.
+        commands: list<server-command>,
         /// Call `tick` every server tick (20 per second).
         tick: bool,
         /// Call `player-joined` and `player-left`.
@@ -190,11 +241,6 @@ interface server-events {
         /// Call `block-broken` and `block-placed`.
         blocks: bool,
     }
-    record block-pos {
-        x: s32,
-        y: s32,
-        z: s32,
-    }
     /// Once, after loading. An error keeps the mod off and is logged.
     init: func() -> result<registration, string>;
     /// Each server tick, with the server's tick counter.
@@ -206,8 +252,10 @@ interface server-events {
     /// A chat message a player sent, as plain text.
     chat: func(player: player, text: string);
     /// `/name args` typed by `player`: ok(some(text)) is their feedback,
-    /// err(text) their error in red.
-    command: func(player: player, name: string, args: string) -> result<option<string>, string>;
+    /// err(text) their error in red. `values` holds each argument given, by
+    /// name, in order (an optional one left out isn't there); a line that
+    /// doesn't parse never reaches the mod: the player gets vanilla's error.
+    command: func(player: player, name: string, args: string, values: list<tuple<string, argument-value>>) -> result<option<string>, string>;
     /// A player broke the block at `pos` in their dimension: `state` is what
     /// was there, as `minecraft:oak_log[axis=y]`.
     block-broken: func(player: player, pos: block-pos, state: string);
diff --git a/crates/horizon-mods/src/commands.rs b/crates/horizon-mods/src/commands.rs
new file mode 100644
index 000000000..4421b47ba
--- /dev/null
+++ b/crates/horizon-mods/src/commands.rs
@@ -0,0 +1,301 @@
+//! Server mods' typed commands: an argument line parsed as the command's
+//! arguments say, the way vanilla's Brigadier parsers read them, with
+//! vanilla's error messages. The game sends the same arguments to players'
+//! command trees, so their chat box checks them before the server does.
+use crate::runtime::{Argument, ArgumentKind, ArgumentValue, BlockPos, ServerPlayer};
+
+/// The values of `args`, typed by `player`, for `arguments` (in order;
+/// optional ones left out aren't there), or the error the player reads.
+pub fn parse(
+    arguments: &[Argument],
+    args: &str,
+    player: &ServerPlayer,
+    online: &[ServerPlayer],
+) -> Result<Vec<(String, ArgumentValue)>, String> {
+    let mut values = Vec::new();
+    let mut rest = args;
+    for (i, argument) in arguments.iter().enumerate() {
+        if i > 0 && !rest.is_empty() {
+            rest = rest.strip_prefix(' ').ok_or(
+                "Expected whitespace to end one argument, but found trailing data".to_string(),
+            )?;
+        }
+        if rest.is_empty() {
+            if argument.optional {
+                break;
+            }
+            return Err("Unknown or incomplete command, see below for error".into());
+        }
+        let (value, after) = one(&argument.kind, rest, player, online)?;
+        values.push((argument.name.clone(), value));
+        rest = after;
+    }
+    if !rest.is_empty() {
+        return Err("Incorrect argument for command".into());
+    }
+    Ok(values)
+}
+
+/// StringReader.isAllowedInUnquotedString.
+fn unquoted(c: char) -> bool {
+    c.is_ascii_alphanumeric() || matches!(c, '_' | '-' | '.' | '+')
+}
+
+/// The unquoted string at the start of `s`, and what follows it.
+fn word(s: &str) -> (&str, &str) {
+    let end = s.find(|c: char| !unquoted(c)).unwrap_or(s.len());
+    s.split_at(end)
+}
+
+/// One argument from the start of `s`, and what follows it.
+fn one<'a>(
+    kind: &ArgumentKind,
+    s: &'a str,
+    player: &ServerPlayer,
+    online: &[ServerPlayer],
+) -> Result<(ArgumentValue, &'a str), String> {
+    Ok(match kind {
+        ArgumentKind::Word => {
+            let (w, rest) = word(s);
+            if w.is_empty() {
+                return Err("Expected string".into());
+            }
+            (ArgumentValue::Word(w.into()), rest)
+        }
+        ArgumentKind::Text => (ArgumentValue::Text(s.into()), ""),
+        ArgumentKind::Integer((min, max)) => {
+            let (n, rest) = integer(s)?;
+            if let Some(min) = min.filter(|m| n < *m) {
+                return Err(format!("Integer must not be less than {min}, found {n}"));
+            }
+            if let Some(max) = max.filter(|m| n > *m) {
+                return Err(format!("Integer must not be more than {max}, found {n}"));
+            }
+            (ArgumentValue::Integer(n), rest)
+        }
+        ArgumentKind::Number => {
+            let (n, rest) = double(s)?;
+            (ArgumentValue::Number(n), rest)
+        }
+        ArgumentKind::Boolean => {
+            let (w, rest) = word(s);
+            let b = match w {
+                "true" => true,
+                "false" => false,
+                "" => return Err("Expected bool".into()),
+                _ => {
+                    return Err(format!(
+                        "Invalid boolean, expected 'true' or 'false' but found '{w}'"
+                    ));
+                }
+            };
+            (ArgumentValue::Boolean(b), rest)
+        }
+        ArgumentKind::Player => {
+            if let Some(selector) = s.strip_prefix('@') {
+                let (kind, rest) = word(selector);
+                return match kind {
+                    // A player's @p is themselves (the nearest to where they are).
+                    "s" | "p" => Ok((ArgumentValue::Player(player.clone()), rest)),
+                    "a" | "e" | "r" | "n" => {
+                        Err("Only one player is allowed, but the provided selector allows more than one".into())
+                    }
+                    _ => Err(format!("Unknown selector type '@{kind}'")),
+                };
+            }
+            let (name, rest) = word(s);
+            if name.is_empty() {
+                return Err("Invalid name or UUID".into());
+            }
+            let found = online
+                .iter()
+                .find(|p| p.name.eq_ignore_ascii_case(name))
+                .ok_or("No player was found")?;
+            (ArgumentValue::Player(found.clone()), rest)
+        }
+        ArgumentKind::BlockPos => {
+            let (x, rest) = coordinate(s, player.x)?;
+            let rest = rest
+                .strip_prefix(' ')
+                .ok_or("Incomplete (expected 3 coordinates)")?;
+            let (y, rest) = coordinate(rest, player.y)?;
+            let rest = rest
+                .strip_prefix(' ')
+                .ok_or("Incomplete (expected 3 coordinates)")?;
+            let (z, rest) = coordinate(rest, player.z)?;
+            (ArgumentValue::BlockPos(BlockPos { x, y, z }), rest)
+        }
+    })
+}
+
+/// StringReader.readInt.
+fn integer(s: &str) -> Result<(i32, &str), String> {
+    let end = s
+        .find(|c: char| !(c.is_ascii_digit() || c == '-' || c == '.'))
+        .unwrap_or(s.len());
+    let (n, rest) = s.split_at(end);
+    if n.is_empty() {
+        return Err("Expected integer".into());
+    }
+    let n = n.parse().map_err(|_| format!("Invalid integer '{n}'"))?;
+    Ok((n, rest))
+}
+
+/// StringReader.readDouble.
+fn double(s: &str) -> Result<(f64, &str), String> {
+    let end = s
+        .find(|c: char| !(c.is_ascii_digit() || c == '-' || c == '.'))
+        .unwrap_or(s.len());
+    let (n, rest) = s.split_at(end);
+    if n.is_empty() {
+        return Err("Expected double".into());
+    }
+    let n = n.parse().map_err(|_| format!("Invalid double '{n}'"))?;
+    Ok((n, rest))
+}
+
+/// WorldCoordinate.parseInt, then BlockPos.containing: `~` and `~n` from
+/// `base`, a whole number as it is.
+fn coordinate(s: &str, base: f64) -> Result<(i32, &str), String> {
+    if s.starts_with('^') {
+        return Err(
+            "Cannot mix world & local coordinates (everything must either use ^ or not)".into(),
+        );
+    }
+    if let Some(offset) = s.strip_prefix('~') {
+        if offset.is_empty() || offset.starts_with(' ') {
+            return Ok((base.floor() as i32, offset));
+        }
+        let (n, rest) = double(offset)?;
+        return Ok(((base + n).floor() as i32, rest));
+    }
+    integer(s)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::runtime::GameMode;
+
+    fn player(name: &str) -> ServerPlayer {
+        ServerPlayer {
+            id: format!("id-{name}"),
+            name: name.into(),
+            x: 10.7,
+            y: 64.0,
+            z: -3.2,
+            dimension: "minecraft:overworld".into(),
+            game_mode: GameMode::Survival,
+            health: 20.0,
+        }
+    }
+    fn arg(name: &str, kind: ArgumentKind, optional: bool) -> Argument {
+        Argument {
+            name: name.into(),
+            kind,
+            optional,
+        }
+    }
+
+    #[test]
+    fn values_in_order_and_optional_ones_left_out() {
+        let alex = player("Alex");
+        let online = [alex.clone(), player("Steve")];
+        let args = [
+            arg("who", ArgumentKind::Player, false),
+            arg("height", ArgumentKind::Integer((Some(1), Some(64))), true),
+            arg("note", ArgumentKind::Text, true),
+        ];
+        let v = parse(&args, "steve 5 hello there", &alex, &online).unwrap();
+        assert_eq!(v[0].0, "who");
+        assert!(matches!(&v[0].1, ArgumentValue::Player(p) if p.name == "Steve"));
+        assert_eq!(v[1], ("height".into(), ArgumentValue::Integer(5)));
+        assert_eq!(
+            v[2],
+            ("note".into(), ArgumentValue::Text("hello there".into()))
+        );
+        let v = parse(&args, "@s", &alex, &online).unwrap();
+        assert_eq!(v.len(), 1);
+        assert!(matches!(&v[0].1, ArgumentValue::Player(p) if p.name == "Alex"));
+    }
+
+    #[test]
+    fn vanilla_errors() {
+        let alex = player("Alex");
+        let online = [alex.clone()];
+        let height = [arg(
+            "height",
+            ArgumentKind::Integer((Some(1), Some(64))),
+            false,
+        )];
+        let err = |a: &[Argument], s| parse(a, s, &alex, &online).unwrap_err();
+        assert_eq!(
+            err(&height, "0"),
+            "Integer must not be less than 1, found 0"
+        );
+        assert_eq!(
+            err(&height, "65"),
+            "Integer must not be more than 64, found 65"
+        );
+        assert_eq!(err(&height, "x"), "Expected integer");
+        assert_eq!(err(&height, "1.5"), "Invalid integer '1.5'");
+        assert_eq!(
+            err(&height, ""),
+            "Unknown or incomplete command, see below for error"
+        );
+        assert_eq!(err(&height, "3 4"), "Incorrect argument for command");
+        let who = [arg("who", ArgumentKind::Player, false)];
+        assert_eq!(err(&who, "Herobrine"), "No player was found");
+        assert_eq!(err(&who, "@q"), "Unknown selector type '@q'");
+        let flag = [arg("on", ArgumentKind::Boolean, false)];
+        assert_eq!(
+            err(&flag, "yes"),
+            "Invalid boolean, expected 'true' or 'false' but found 'yes'"
+        );
+        let pos = [arg("at", ArgumentKind::BlockPos, false)];
+        assert_eq!(err(&pos, "1 2"), "Incomplete (expected 3 coordinates)");
+    }
+
+    #[test]
+    fn block_positions_relative_to_the_player() {
+        let alex = player("Alex");
+        let pos = [arg("at", ArgumentKind::BlockPos, false)];
+        let v = parse(&pos, "~ ~1 ~-0.5", &alex, &[]).unwrap();
+        assert_eq!(
+            v[0].1,
+            ArgumentValue::BlockPos(BlockPos {
+                x: 10,
+                y: 65,
+                z: -4
+            })
+        );
+        let v = parse(&pos, "-5 70 ~", &alex, &[]).unwrap();
+        assert_eq!(
+            v[0].1,
+            ArgumentValue::BlockPos(BlockPos {
+                x: -5,
+                y: 70,
+                z: -4
+            })
+        );
+    }
+
+    #[test]
+    fn free_text_is_an_optional_text_argument() {
+        let alex = player("Alex");
+        let free = [arg("args", ArgumentKind::Text, true)];
+        assert_eq!(parse(&free, "", &alex, &[]), Ok(Vec::new()));
+        assert_eq!(
+            parse(&free, "anything at all", &alex, &[]),
+            Ok(vec![(
+                "args".into(),
+                ArgumentValue::Text("anything at all".into())
+            )])
+        );
+        assert_eq!(
+            parse(&[], "more", &alex, &[]),
+            Err("Incorrect argument for command".into())
+        );
+        assert_eq!(parse(&[], "", &alex, &[]), Ok(Vec::new()));
+    }
+}
diff --git a/crates/horizon-mods/src/lib.rs b/crates/horizon-mods/src/lib.rs
index 3c5fe74f6..d352f8c90 100644
--- a/crates/horizon-mods/src/lib.rs
+++ b/crates/horizon-mods/src/lib.rs
@@ -5,6 +5,8 @@
 //!
 //! Nothing here runs unless a mod is installed and turned on: an empty
 //! [`Mods`] makes no engine and every hook returns at once.
+#[cfg(feature = "runtime")]
+pub mod commands;
 pub mod content;
 #[cfg(feature = "index")]
 pub mod index;
diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs
index fa0998614..f4ab5c4dd 100644
--- a/crates/horizon-mods/src/runtime.rs
+++ b/crates/horizon-mods/src/runtime.rs
@@ -43,7 +43,9 @@ use bindings::{
     horizon::mods::{chat, game, hud, log as mod_log, storage},
 };
 pub use server_bindings::{
-    exports::horizon::mods::server_events::BlockPos,
+    exports::horizon::mods::server_events::{
+        Argument, ArgumentKind, ArgumentValue, BlockPos, ServerCommand,
+    },
     horizon::mods::players::{GameMode, Player as ServerPlayer},
     horizon::mods::world::BlockChange,
 };
@@ -206,10 +208,10 @@ impl Hooks {
             Hooks::Client(..) => None,
         }
     }
-    fn commands(&self) -> &[String] {
+    fn commands(&self) -> Vec<&str> {
         match self {
-            Hooks::Client(_, r) => &r.commands,
-            Hooks::Server(_, r) => &r.commands,
+            Hooks::Client(_, r) => r.commands.iter().map(String::as_str).collect(),
+            Hooks::Server(_, r) => r.commands.iter().map(|c| c.name.as_str()).collect(),
         }
     }
 }
@@ -240,9 +242,16 @@ pub struct Mods {
     snapshot: Arc<Snapshot>,
     out: Vec<Output>,
     world: WorldSlot,
+    /// Moves on whenever a mod starts or stops: the game resends the server
+    /// mods' commands to players when it changes.
+    generation: u64,
 }
 
 impl Mods {
+    /// Changes whenever the running mods (so their commands) change.
+    pub fn generation(&self) -> u64 {
+        self.generation
+    }
     /// Whether a running mod may use capability `world`: only then is a
     /// view worth lending.
     pub fn wants_world(&self) -> bool {
@@ -371,7 +380,8 @@ impl Mods {
             .iter()
             .filter_map(|e| e.run.as_ref())
             .filter(|r| r.hooks.server().is_some() == server)
-            .flat_map(|r| r.hooks.commands().iter().cloned())
+            .flat_map(|r| r.hooks.commands())
+            .map(str::to_owned)
             .collect();
         let snapshot = self.snapshot.clone();
         let world = self.world.clone();
@@ -423,17 +433,30 @@ impl Mods {
                 .map_err(|e| reason(&e))??;
             Hooks::Client(exports, r)
         };
-        let commands = match &mut hooks {
-            Hooks::Client(_, r) => &mut r.commands,
-            Hooks::Server(_, r) => &mut r.commands,
-        };
-        commands.retain(|c| {
-            let free = !reserved(c) && !taken.contains(c);
+        let free = |c: &str| {
+            let free = !reserved(c) && !taken.iter().any(|t| t == c);
             if !free {
                 log::warn!("Horizon: mod {} cannot take /{c}: already a command", m.id);
             }
             free
-        });
+        };
+        match &mut hooks {
+            Hooks::Client(_, r) => r.commands.retain(|c| free(c)),
+            Hooks::Server(_, r) => {
+                r.commands.retain(|c| free(&c.name));
+                for c in &mut r.commands {
+                    if let Err(e) = check_arguments(&c.arguments) {
+                        log::warn!(
+                            "Horizon: mod {}'s /{}: {e}; it takes free text",
+                            m.id,
+                            c.name
+                        );
+                        c.arguments.clear();
+                    }
+                }
+            }
+        }
+        self.generation += 1;
         self.out.append(&mut store.data_mut().out);
         Ok(Some(Running { store, hooks }))
     }
@@ -537,6 +560,7 @@ impl Mods {
                 });
                 entry.status = Status::Failed(reason);
                 entry.run = None;
+                self.generation += 1;
                 None
             }
         }
@@ -561,7 +585,7 @@ impl Mods {
     fn command_owner(&self, server: bool, name: &str) -> Option<usize> {
         self.entries.iter().position(|e| {
             e.run.as_ref().is_some_and(|r| {
-                r.hooks.server().is_some() == server && r.hooks.commands().iter().any(|c| c == name)
+                r.hooks.server().is_some() == server && r.hooks.commands().contains(&name)
             })
         })
     }
@@ -592,7 +616,7 @@ impl Mods {
             .iter()
             .filter_map(|e| e.run.as_ref())
             .filter(move |r| r.hooks.server().is_some() == server)
-            .flat_map(|r| r.hooks.commands().iter().map(String::as_str))
+            .flat_map(|r| r.hooks.commands())
     }
 
     /// A server tick.
@@ -635,9 +659,13 @@ impl Mods {
             |m, s| m.call_block_placed(s, player, pos, state),
         );
     }
-    /// The commands running server mods own, for the server's command tree.
-    pub fn server_commands(&self) -> impl Iterator<Item = &str> {
-        self.owned_commands(true)
+    /// The commands running server mods own and their arguments, for the
+    /// server's command tree.
+    pub fn server_commands(&self) -> impl Iterator<Item = &ServerCommand> {
+        self.entries
+            .iter()
+            .filter_map(|e| e.run.as_ref()?.hooks.server())
+            .flat_map(|r| r.commands.iter())
     }
     /// Runs `line` (without its slash), typed by `player`, if a server mod
     /// owns its command; its feedback is an [`Output::Reply`]. False when
@@ -647,17 +675,31 @@ impl Mods {
         let Some(i) = self.command_owner(true, name) else {
             return false;
         };
-        let result = self.call(i, FUEL_EVENT, |h, s| match h {
-            Hooks::Server(m, _) => m
-                .horizon_mods_server_events()
-                .call_command(s, player, name, args),
-            Hooks::Client(..) => Ok(Ok(None)),
-        });
         let reply = |text, error| Output::Reply {
             player: player.id.clone(),
             text,
             error,
         };
+        let arguments = self.entries[i]
+            .run
+            .as_ref()
+            .and_then(|r| r.hooks.server())
+            .and_then(|r| r.commands.iter().find(|c| c.name == name))
+            .map(|c| c.arguments.as_slice())
+            .unwrap_or_default();
+        let values = match crate::commands::parse(arguments, args, player, &self.snapshot.players) {
+            Ok(values) => values,
+            Err(e) => {
+                self.out.push(reply(e, true));
+                return true;
+            }
+        };
+        let result = self.call(i, FUEL_EVENT, |h, s| match h {
+            Hooks::Server(m, _) => m
+                .horizon_mods_server_events()
+                .call_command(s, player, name, args, &values),
+            Hooks::Client(..) => Ok(Ok(None)),
+        });
         match result {
             Some(Ok(Some(text))) => self.out.push(reply(text, false)),
             Some(Err(text)) => self.out.push(reply(text, true)),
@@ -688,6 +730,7 @@ impl Mods {
                 continue;
             }
             any = true;
+            self.generation += 1;
             self.entries[i].modified = now;
             self.entries[i].run = None;
             let path = self.entries[i].path.clone();
@@ -713,6 +756,34 @@ impl Mods {
     }
 }
 
+/// A command's arguments are well formed: names given and distinct,
+/// optional ones last, free text only last.
+fn check_arguments(arguments: &[Argument]) -> Result<(), String> {
+    for (i, a) in arguments.iter().enumerate() {
+        if a.name.is_empty()
+            || !a
+                .name
+                .chars()
+                .all(|c| c.is_ascii_alphanumeric() || c == '_')
+        {
+            return Err(format!("argument name '{}' isn't [A-Za-z0-9_]+", a.name));
+        }
+        if arguments[..i].iter().any(|b| b.name == a.name) {
+            return Err(format!("two arguments are named {}", a.name));
+        }
+        if i > 0 && arguments[i - 1].optional && !a.optional {
+            return Err(format!("{} is required after an optional argument", a.name));
+        }
+        if a.kind == ArgumentKind::Text && i + 1 < arguments.len() {
+            return Err(format!(
+                "{} takes the rest of the line, so it must be last",
+                a.name
+            ));
+        }
+    }
+    Ok(())
+}
+
 fn modified(path: &Path) -> Option<SystemTime> {
     let meta = std::fs::metadata(path).ok()?;
     if meta.is_dir() {
diff --git a/crates/horizon-mods/src/testing.rs b/crates/horizon-mods/src/testing.rs
index 239642357..5a18d4cb8 100644
--- a/crates/horizon-mods/src/testing.rs
+++ b/crates/horizon-mods/src/testing.rs
@@ -250,7 +250,7 @@ impl TestGame {
     }
     /// The commands the mod registered.
     pub fn commands(&self) -> Vec<String> {
-        let server = self.mods.server_commands();
+        let server = self.mods.server_commands().map(|c| c.name.as_str());
         self.mods
             .commands()
             .chain(server)
diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs
index 3647cca30..c9cd60bdc 100644
--- a/crates/horizon-mods/tests/sandbox.rs
+++ b/crates/horizon-mods/tests/sandbox.rs
@@ -446,7 +446,7 @@ fn a_server_mod_without_a_world_reads_nothing() {
     assert!(
         out.iter()
             .any(|o| matches!(o, Output::Reply { text, error: true, .. }
-            if text == "The ground under you isn't loaded")),
+            if text == "That block isn't loaded")),
         "{out:?}"
     );
 }
@@ -545,10 +545,12 @@ fn a_server_mod_runs_only_where_the_world_does() {
 
     let mut mods = Mods::load_for(Runs::Server, paths, |_| true, |c| c == "give");
     assert!(mods.runs_server());
-    assert_eq!(
-        mods.server_commands().collect::<Vec<_>>(),
-        ["online", "mined"]
-    );
+    let commands: Vec<_> = mods.server_commands().map(|c| c.name.as_str()).collect();
+    assert_eq!(commands, ["online", "mined"]);
+    // `/mined [player]`: its argument travels with it, for the command tree.
+    let mined = mods.server_commands().nth(1).unwrap();
+    assert_eq!(mined.arguments[0].kind, horizon_mods::ArgumentKind::Player);
+    assert!(mined.arguments[0].optional);
     assert_eq!(mods.commands().count(), 0, "not the window's chat commands");
     let alex = alex();
     mods.set_snapshot(Snapshot {
diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md
index 3aaf29d0c..7f0beeee6 100644
--- a/docs/api/mods-reference.md
+++ b/docs/api/mods-reference.md
@@ -216,16 +216,6 @@ What the server calls in a server mod (manifest `api = "0.3"`, experimental). On
 
 `type player = player`
 
-### record `registration`
-
-| Field | Type | |
-| --- | --- | --- |
-| `commands` | `list<string>` | Commands players may type, without the slash. A name vanilla already uses is refused (vanilla's command runs). |
-| `tick` | `bool` | Call `tick` every server tick (20 per second). |
-| `joins` | `bool` | Call `player-joined` and `player-left`. |
-| `chat` | `bool` | Call `chat` for each chat message a player sends. |
-| `blocks` | `bool` | Call `block-broken` and `block-placed`. |
-
 ### record `block-pos`
 
 | Field | Type | |
@@ -234,6 +224,59 @@ What the server calls in a server mod (manifest `api = "0.3"`, experimental). On
 | `y` | `s32` |  |
 | `z` | `s32` |  |
 
+### variant `argument-kind`
+
+What an argument of a command takes. The server sends each command and its arguments to players' games, whose chat box completes and colours them as vanilla's; the server parses them before the mod's `command` hook gets their values.
+
+| Case | Payload | |
+| --- | --- | --- |
+| `word` |  | One word: letters, digits and `_ - . +`. |
+| `text` |  | The rest of the line, spaces included: only last. |
+| `integer` | `tuple<option<s32>, option<s32>>` | A whole number, within the bounds given. |
+| `number` |  | A number with or without decimals. |
+| `boolean` |  | `true` or `false`. |
+| `player` |  | One online player: a name, or `@s` or `@p` (whoever typed it, as vanilla picks for a player). |
+| `block-pos` |  | A block position: three whole numbers, each one also `~` or `~n`, relative to whoever typed it. |
+
+### record `argument`
+
+| Field | Type | |
+| --- | --- | --- |
+| `name` | `string` | Shown in the chat box's hint (`<height>`) and the key of its value. |
+| `kind` | `argument-kind` |  |
+| `optional` | `bool` | Optional arguments come after every required one. |
+
+### record `server-command`
+
+| Field | Type | |
+| --- | --- | --- |
+| `name` | `string` | Without the slash. A name vanilla already uses is refused (vanilla's command runs). |
+| `arguments` | `list<argument>` | In order; none: the command takes nothing after its name. Free text is one optional `text` argument. |
+
+### variant `argument-value`
+
+An argument's value, parsed as its kind says.
+
+| Case | Payload | |
+| --- | --- | --- |
+| `word` | `string` |  |
+| `text` | `string` |  |
+| `integer` | `s32` |  |
+| `number` | `f64` |  |
+| `boolean` | `bool` |  |
+| `player` | `player` |  |
+| `block-pos` | `block-pos` |  |
+
+### record `registration`
+
+| Field | Type | |
+| --- | --- | --- |
+| `commands` | `list<server-command>` | Commands players may type. |
+| `tick` | `bool` | Call `tick` every server tick (20 per second). |
+| `joins` | `bool` | Call `player-joined` and `player-left`. |
+| `chat` | `bool` | Call `chat` for each chat message a player sends. |
+| `blocks` | `bool` | Call `block-broken` and `block-placed`. |
+
 | Function | Signature | What it does |
 | --- | --- | --- |
 | `init` | `func() -> result<registration, string>` | Once, after loading. An error keeps the mod off and is logged. |
@@ -241,6 +284,6 @@ What the server calls in a server mod (manifest `api = "0.3"`, experimental). On
 | `player-joined` | `func(player: player)` | A player joined the server; they are in `players.online` already. |
 | `player-left` | `func(player: player)` | A player left the server; they are no longer in `players.online`. |
 | `chat` | `func(player: player, text: string)` | A chat message a player sent, as plain text. |
-| `command` | `func(player: player, name: string, args: string) -> result<option<string>, string>` | `/name args` typed by `player`: ok(some(text)) is their feedback, err(text) their error in red. |
+| `command` | `func(player: player, name: string, args: string, values: list<tuple<string, argument-value>>) -> result<option<string>, string>` | `/name args` typed by `player`: ok(some(text)) is their feedback, err(text) their error in red. `values` holds each argument given, by name, in order (an optional one left out isn't there); a line that doesn't parse never reaches the mod: the player gets vanilla's error. |
 | `block-broken` | `func(player: player, pos: block-pos, state: string)` | A player broke the block at `pos` in their dimension: `state` is what was there, as `minecraft:oak_log[axis=y]`. |
 | `block-placed` | `func(player: player, pos: block-pos, state: string)` | A player placed `state` at `pos` in their dimension. |
diff --git a/docs/api/mods.md b/docs/api/mods.md
index 76075e989..6e7a87205 100644
--- a/docs/api/mods.md
+++ b/docs/api/mods.md
@@ -18,7 +18,7 @@ the player before the mod is turned on, and checked against the component's real
 | Hooks a mod exports | 5: `init`, `tick`, `frame`, `command`, `chat`; a server mod 8: `init`, `tick`, `player-joined`, `player-left`, `chat`, `command`, `block-broken`, `block-placed` |
 | Capabilities | 6: `game-read`, `chat`, `hud`, `storage`, `registries`, `players` |
 | Manifest `api` lines served | 3: `0.1` (code), `0.2` (content), `0.3` (server mods, experimental) |
-| SDK | the `Mod` trait (5 methods), `Registration` (4 builders), `export_mod!`, log helpers; `server::ServerMod` (8 methods), `server::Registration` (5 builders), `export_server_mod!` |
+| SDK | the `Mod` trait (5 methods), `Registration` (4 builders), `export_mod!`, log helpers; `server::ServerMod` (8 methods), `server::Registration` (6 builders), `server::Argument`, `server::Args`, `export_server_mod!` |
 | `cargo horizon-mod` | `new`, `build`, `run`, `test`, `check` |
 | Example mods | `coords-hud` (code), `ruby-content` (content), `welcome` (server) |
 
@@ -84,9 +84,9 @@ release.
 What real mods need next, in the order modpacks and servers need it:
 
 - **More for server mods** (`api = "0.3"`, [Server mods](../mods.md#server-mods-api-03-experimental)): they run
-  on the server thread, a LAN host and the dedicated server today, with joins, chat, commands, players' block
-  breaking and placing, and `world` (read blocks and biomes, set blocks as `/setblock` does); next entity events, game rules,
-  server commands with typed arguments sent to clients' command trees.
+  on the server thread, a LAN host and the dedicated server today, with joins, chat, typed commands in players'
+  command trees, players' block breaking and placing, and `world` (read blocks and biomes, set blocks as `/setblock`
+  does); next entity events, game rules, entity, item and block-state arguments.
 - **World and blocks**: blocks, block states and biomes are there for server mods (`world`); next block entities,
   and `world` for client mods (raycasts, single player and LAN hosts).
 - **Items and inventories**: the player's inventory, held item and open container; item stacks with components.
@@ -102,6 +102,9 @@ What real mods need next, in the order modpacks and servers need it:
 
 ## Changelog
 
+- API 0.3: typed server commands: `registration.commands` lists each command's arguments (`argument-kind`: word,
+  text, integer, number, boolean, player, block-pos), sent in players' command trees and parsed by the server;
+  `command` gets their values. SDK `Registration::command_with`, `Argument`, `Args`.
 - API 0.3: capability `world` (`get-block`, `get-biome`, `set-blocks`); example `beacons`; test scripts' `blocks` and
   `expect.blocks`.
 - Server mods run in the game: single player (server thread and in-frame), LAN hosts, the dedicated server.
diff --git a/docs/mods.md b/docs/mods.md
index 19b05f9ec..5d0378a34 100644
--- a/docs/mods.md
+++ b/docs/mods.md
@@ -475,7 +475,7 @@ its component targets the WIT world `horizon-server-mod` instead of
 | `tick(tick)` | each server tick |
 | `player-joined(player)`, `player-left(player)` | `registration.joins` |
 | `chat(player, text)` | `registration.chat`: each chat message a player sends |
-| `command(player, name, args)` | `/name args` typed by a player, for a command it registered; `ok(some)` is that player's feedback, `err` their red error |
+| `command(player, name, args, values)` | `/name args` typed by a player, for a command it registered, with its arguments' values (below); `ok(some)` is that player's feedback, `err` their red error |
 | `block-broken(player, pos, state)`, `block-placed(player, pos, state)` | `registration.blocks`, with the state as `minecraft:oak_log[axis=y]` |
 
 Capabilities that act on a local player (`game-read`, `chat`, `hud`) are for
@@ -484,6 +484,31 @@ horizon_mod_sdk::server::ServerMod` and `export_server_mod!`; the example is
 [`welcome`](../crates/horizon-mod-sdk/examples/welcome/src/lib.rs), and with
 `world`, [`beacons`](../crates/horizon-mod-sdk/examples/beacons/src/lib.rs).
 
+**Typed commands.** Each command in `registration.commands` lists its
+arguments, in order: a name and a kind, required or optional (optional ones
+last). The server adds them to the command tree every player receives, after
+vanilla's commands, so a player's chat box completes and colours them as it
+does vanilla's (player names, coordinates, bounds); when a player sends one,
+the server parses the line the way vanilla's parsers do and gives the mod the
+values, by argument name, or answers with vanilla's error (`Integer must not
+be more than 64, found 65`, `No player was found`) without calling the mod.
+
+| Kind | Takes | Value | Chat box parser |
+|---|---|---|---|
+| `word` | one word: letters, digits, `_ - . +` | `word(string)` | `brigadier:string` (word) |
+| `text` | the rest of the line, only last | `text(string)` | `brigadier:string` (greedy) |
+| `integer(min, max)` | a whole number within the bounds given | `integer(s32)` | `brigadier:integer` |
+| `number` | a number | `number(f64)` | `brigadier:double` |
+| `boolean` | `true` or `false` | `boolean(bool)` | `brigadier:bool` |
+| `player` | an online player's name, `@s` or `@p` (whoever typed it) | `player(player)` | `minecraft:entity` (one player) |
+| `block-pos` | `x y z`, each a whole number, `~` or `~n` (from whoever typed it) | `block-pos(block-pos)` | `minecraft:block_pos` |
+
+A command with no arguments takes nothing after its name. In Rust,
+`Registration::command_with("beacon", [Argument::integer("height", Some(1),
+Some(64)).optional()])`, read with `args.integer("height")`; `command(name)`
+alone takes free text, an optional `text` argument named `args`
+(`args.text()` is the line as typed either way).
+
 **Capability `world`.** Reads are of the server's loaded chunks as they are
 during the call: the game lends a server mod's call the levels' chunk maps
 (moved, not copied, and only while a running mod has `world`), so a read
@@ -524,10 +549,11 @@ chat for the in-frame player and a system message for a connection;
 on, each of these points costs one branch (measured in the PR that added
 them).
 
-**Not yet.** Clients aren't sent server mods' commands with vanilla's
-command tree, so a player's chat box doesn't complete or colour them; typing
-them works. Block events are a player's own breaking and placing, not
-explosions, pistons or other mods.
+**Not yet.** Block events are a player's own breaking and placing, not
+explosions, pistons or other mods. Command arguments don't take entities,
+items or block states yet, and `^` coordinates; in-frame single player's chat
+box lists server mods' commands by name only (the server still parses their
+arguments).
 
 ## Versions and compatibility
 

From 574d65a03ca86775593d52472da4b1802f0a7d2a Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Sun, 25 Oct 2026 20:08:47 +0100
Subject: [PATCH 003/475] stability.md: server mods' row names world and typed
 commands

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/api/stability.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/api/stability.md b/docs/api/stability.md
index 30d8c699c..f5b2da632 100644
--- a/docs/api/stability.md
+++ b/docs/api/stability.md
@@ -88,7 +88,7 @@ Deprecations and breaking changes are in bold. The release notes of the game rel
 | --- | --- | --- |
 | Mod API: `log`, `game`, `chat`, `hud`, `storage`, `events` | preview | 0.1.0 |
 | Content mods (`registries`: data-driven blocks and items) | preview | manifest `api = "0.2"` |
-| Server mods: world `horizon-server-mod`, `players`, `server-events` | experimental | manifest `api = "0.3"` |
+| Server mods: world `horizon-server-mod`, `players`, `server-events`, `world`, typed `server-command`s | experimental | manifest `api = "0.3"` |
 | Script mods (Lua run by an interpreter mod, [mods.md](mods.md#ways-in)) | not started | |
 | `cargo horizon-mod` (`new`, `build`, `run`), `horizon-mod-sdk` | preview | 0.1.0 |
 | Shader API | not started | |

From a7ff22eea05de72275341d7346252fc5d2ecdbb6 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Sun, 25 Oct 2026 23:05:12 +0100
Subject: [PATCH 004/475] Give a server player's new body its effects at once
 after a level change

A server's player gets a new body when it joins, respawns or changes
level, but what the old body had been given by its effects (the applied
attribute modifiers and the armor protection table) was kept in its
per-player record. apply_effect_status then saw nothing to change, so
after a trip to another dimension Speed kept its icon while the body's
movement speed fell back from 0.14 to 0.10, until the effect was
reapplied.

Vanilla keeps the same ServerPlayer through ServerPlayer.teleport into
another level, with its attributes and MobEffect modifiers. A new body
now starts with nothing applied, and its effects are applied as soon as
it is created, before the movement that brought it is handled.
---
 crates/horizon-client/src/game/lan_actions.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 9d4d868e0..41f92106c 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -250,8 +250,10 @@ impl Game<'_> {
         }
         let mut play = host.play.remove(&conn).unwrap_or_default();
         if fresh {
-            // A new body (joined, respawned, changed level): nothing on it yet.
+            // A new body (joined, respawned, changed level): nothing on it yet,
+            // its effects' modifiers and armor protection included.
             play.equipped = None;
+            play.potions = Default::default();
         }
         let g = &mut host.hub.guests[i];
         // The guest's body.
@@ -384,6 +386,12 @@ impl Game<'_> {
             self.apply_equipment();
             play.equipped = Some(equipped);
         }
+        // The player's effects are on the new body before anything it does
+        // (the movement that brought it, a landing): vanilla keeps the same
+        // entity through a level change, with its attributes and effects.
+        if fresh {
+            self.apply_effect_status();
+        }
         self.update_totem_ready();
         Some(GuestSwap {
             conn,

From 19a5098b140f4ca6eab01b0e73f5d8688cd52d85 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 01:03:41 +0100
Subject: [PATCH 005/475] Leave a respawned body's reset to the swap that
 builds it

Respawning drops the guest's body, so the next swap builds a fresh one,
which now clears what the old body was given (equipment, effects and
armor protection) itself.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/lan_actions.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 41f92106c..00ea51de8 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -1707,10 +1707,6 @@ impl Game<'_> {
         };
         xp.respawn(self.ui.rules.bool("keep_inventory") || g.game_mode == SPECTATOR);
         (g.xp_level, g.xp_progress, g.xp_total) = (xp.level, xp.progress, xp.total);
-        // A new body: nothing given to the old one carries over.
-        if let Some(play) = host.play.get_mut(&conn) {
-            play.potions = Default::default();
-        }
         let clock_rate = self.network_clock_rate();
         let ctx = TickCtx {
             world: &mut self.world,

From f98528bbfc49fbe1c92deef00b953623903302c8 Mon Sep 17 00:00:00 2001
From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com>
Date: Mon, 26 Oct 2026 10:46:18 +0000
Subject: [PATCH 006/475] Fix evoker fangs rendering on server clients

Track fang entities and deliver their start event to the existing client renderer. Exercise warmup, animation, authoritative positions and removal in the LAN harness.

Co-Authored-By: OpenAI Codex GPT-6.1 Sol <noreply@openai.com>
---
 crates/horizon-client/src/game/control.rs     |  3 +
 crates/horizon-client/src/game/fangs.rs       | 42 ++++++++--
 .../horizon-client/src/game/lan_entities.rs   |  3 +
 crates/horizon-client/src/game/remote.rs      |  1 +
 .../src/game/remote_projectiles.rs            | 10 +++
 tools/lan_e2e.py                              | 83 +++++++++++++++++++
 6 files changed, 137 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs
index 7a632e308..6139ccd37 100644
--- a/crates/horizon-client/src/game/control.rs
+++ b/crates/horizon-client/src/game/control.rs
@@ -1023,6 +1023,9 @@ impl Game<'_> {
             "flashes": self.lightning_seen[1], "flash": self.flash});
         // Primed TNT, falling blocks, projectiles, tridents and end crystals.
         status["projectiles"] = json!(self.projectiles_status());
+        let mut fangs_vertices = Vec::new();
+        self.fangs_geometry(glam::DVec3::ZERO, 0.5, &mut fangs_vertices);
+        status["fangs_vertices"] = json!(fangs_vertices.len());
         status["maps"] = json!(self.maps_status());
         // The particles made so far, by type.
         status["particles"] = json!(self.particles.made());
diff --git a/crates/horizon-client/src/game/fangs.rs b/crates/horizon-client/src/game/fangs.rs
index cdf2d17a5..9aa687032 100644
--- a/crates/horizon-client/src/game/fangs.rs
+++ b/crates/horizon-client/src/game/fangs.rs
@@ -7,12 +7,13 @@ use std::sync::Arc;
 
 #[derive(Clone, Debug)]
 pub(super) struct Fangs {
-    pos: [f64; 3],
-    yaw: f32,
+    pub id: u32,
+    pub pos: [f64; 3],
+    pub yaw: f32,
     warmup: i32,
-    life: i32,
+    pub life: i32,
     owner: u32,
-    started: bool,
+    pub started: bool,
 }
 #[derive(Default)]
 pub(super) struct FangState {
@@ -21,6 +22,11 @@ pub(super) struct FangState {
 }
 impl Game<'_> {
     pub(super) fn add_fangs(&mut self, at: [f64; 3], yaw: f32, delay: i32, owner: u32) {
+        self.next_entity += 1;
+        self.insert_fangs(self.next_entity, at, yaw, delay, owner);
+    }
+
+    pub(super) fn insert_fangs(&mut self, id: u32, at: [f64; 3], yaw: f32, delay: i32, owner: u32) {
         if self.fangs.model.is_none() {
             self.fangs.model = horizon_client::mobs::load_model(
                 &self.options.resources,
@@ -29,6 +35,7 @@ impl Game<'_> {
             .map(Arc::new);
         }
         self.fangs.list.push(Fangs {
+            id,
             pos: at,
             yaw,
             warmup: delay,
@@ -37,6 +44,30 @@ impl Game<'_> {
             started: false,
         });
     }
+    /// `EvokerFangs.handleEntityEvent`: only event 4 starts a client attack.
+    pub(super) fn remote_fangs_event(&mut self, id: u32, event: i8) {
+        if event == 4
+            && let Some(f) = self.fangs.list.iter_mut().find(|f| f.id == id)
+        {
+            f.started = true;
+            self.audio.play_unshared(
+                "minecraft:entity.evoker_fangs.attack",
+                Some(f.pos),
+                1.0,
+                1.0,
+            );
+        }
+    }
+
+    /// `EvokerFangs.tick`: clients only advance animation, never damage or discard.
+    pub(super) fn tick_remote_fangs(&mut self) {
+        for f in &mut self.fangs.list {
+            if f.started {
+                f.life -= 1;
+            }
+        }
+    }
+
     /// `EvokerFangs.tick`.
     pub(super) fn tick_fangs(&mut self) {
         let mut list = std::mem::take(&mut self.fangs.list);
@@ -50,7 +81,8 @@ impl Game<'_> {
             }
             if !f.started {
                 f.started = true;
-                self.audio.play(
+                self.lan_entity_event(f.id as i32, 4, f.pos);
+                self.audio.play_unshared(
                     "minecraft:entity.evoker_fangs.attack",
                     Some(f.pos),
                     1.0,
diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs
index cd4ba2fb8..a389e6a99 100644
--- a/crates/horizon-client/src/game/lan_entities.rs
+++ b/crates/horizon-client/src/game/lan_entities.rs
@@ -290,6 +290,9 @@ impl Game<'_> {
             None => 0,
         };
         let at = |p: horizon_core::geometry::Vec3| [p.x, p.y, p.z];
+        for f in &self.fangs.list {
+            out.push(state(f.id, "minecraft:evoker_fangs", f.pos, f.yaw, false));
+        }
         // LightningBolt: each client draws and flashes its own.
         for b in self.bolts.iter().filter(|b| b.id != 0) {
             out.push(state(b.id, "minecraft:lightning_bolt", b.at, 0.0, false));
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 20c307720..88f36bdf2 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -2050,6 +2050,7 @@ impl Game<'_> {
                 }
             }
             C::EntityEvent(p) => {
+                self.remote_fangs_event(p.id as u32, p.event);
                 // LocalPlayer.setPermissions also refreshes an open World Options screen.
                 if (24..=28).contains(&p.event)
                     && self.remote.as_ref().is_some_and(|r| r.entity_id == p.id)
diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs
index 2ba4510ea..f033c5a8b 100644
--- a/crates/horizon-client/src/game/remote_projectiles.rs
+++ b/crates/horizon-client/src/game/remote_projectiles.rs
@@ -54,6 +54,7 @@ impl Game<'_> {
         let (yaw, pitch) = rotation;
         self.remove_remote_projectile(id);
         match kind {
+            "minecraft:evoker_fangs" => self.insert_fangs(id, position, yaw, 0, 0),
             "minecraft:tnt" => self.tnts.push(super::tnt::PrimedTnt {
                 id,
                 position: at,
@@ -220,6 +221,7 @@ impl Game<'_> {
 
     /// One tick of interpolation, as `tick_remote_objects`.
     pub(super) fn tick_remote_projectiles(&mut self, mut step: impl FnMut(u32, Vec3) -> Vec3) {
+        self.tick_remote_fangs();
         // PrimedTnt.tick runs on a client too: it falls, bounces and burns its
         // fuse down (the swell and flash follow it) between the server's
         // updates (every 10 ticks), and a client discards it when the fuse
@@ -311,6 +313,7 @@ impl Game<'_> {
     }
 
     pub(super) fn remove_remote_projectile(&mut self, id: u32) {
+        self.fangs.list.retain(|f| f.id != id);
         self.tnts.retain(|t| t.id != id);
         self.falling.retain(|f| f.id != id);
         self.creatures.projectiles.retain(|p| p.id != id);
@@ -324,6 +327,7 @@ impl Game<'_> {
 
     /// Every one a server sent (a new connection, level or dimension).
     pub(super) fn clear_remote_projectiles(&mut self) {
+        self.fangs.list.clear();
         self.tnts.clear();
         self.falling.clear();
         self.creatures.projectiles.clear();
@@ -340,6 +344,12 @@ impl Game<'_> {
         use serde_json::json;
         let at = |p: Vec3| [p.x, p.y, p.z];
         let mut out = Vec::new();
+        for f in &self.fangs.list {
+            out.push(
+                json!({"id": f.id, "kind": "minecraft:evoker_fangs", "position": f.pos,
+                "yaw": f.yaw, "started": f.started, "life": f.life}),
+            );
+        }
         for t in &self.tnts {
             out.push(json!({"id": t.id, "kind": "minecraft:tnt", "position": at(t.position), "fuse": t.fuse}));
         }
diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index 804add98a..b4a89eb1d 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -6591,5 +6591,88 @@ CHECKS += ['replant']
 CHECK_FNS['replant'] = check_replant
 
 
+
+def check_fangs(host, guest, out):
+    """EvokerFangs: authoritative spawn, event 4, client animation and server removal (#1482)."""
+    x, y, z = (int(v // 1) for v in pos_of(host))
+    tag = 'lan_evoker_fangs'
+    selector = f'@e[type=minecraft:evoker,tag={tag},limit=1]'
+    paths = {g.name: {} for g in (host, guest)}
+    warmup = dict.fromkeys(paths, False)
+    drawn = dict.fromkeys(paths, False)
+    stopped = False
+    photographed = False
+
+    def fangs(status):
+        return [p for p in status['projectiles'] if p['kind'] == 'minecraft:evoker_fangs']
+
+    try:
+        host('command', command='difficulty normal')
+        host('command', command='gamemode creative')
+        guest('command', command='gamemode survival')
+        guest('command', command='effect give @s minecraft:resistance 120 4 true')
+        host('command', command=f'fill {x - 10} {y - 1} {z - 10} {x + 10} {y - 1} {z + 18} minecraft:stone')
+        host('command', command=f'fill {x - 10} {y} {z - 10} {x + 10} {y + 8} {z + 18} minecraft:air')
+        host('command', command=f'tp @s {x + 4.5} {y} {z - 2.5}')
+        guest('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}')
+        guest.wait(10)
+        host('command', command=f'summon minecraft:evoker {x + 0.5} {y} {z + 9.5} '
+                                f'{{PersistenceRequired:1b,Tags:["{tag}"]}}')
+        for game in (host, guest):
+            game.raw('look-at', x + 0.5, y + 0.5, z + 5.5)
+        for _ in range(200):
+            guest.wait(2)
+            statuses = {g.name: g('status') for g in (host, guest)}
+            for name, status in statuses.items():
+                live = fangs(status)
+                ids = [f['id'] for f in live]
+                assert all(ids) and len(ids) == len(set(ids)), f'{name}: invalid fang ids {ids}'
+                warmup[name] |= any(not f['started'] for f in live)
+                drawn[name] |= status['fangs_vertices'] > 0
+                for f in live:
+                    paths[name].setdefault(f['id'], []).append(f)
+            if paths['host'] and not stopped:
+                host('command', command=f'data merge entity {selector} {{NoAI:1b}}')
+                stopped = True
+            if (all(drawn.values()) and not photographed
+                    and any(f['started'] and 8 <= f['life'] <= 16
+                            for f in fangs(statuses['guest']))):
+                host('command', command='tick freeze')
+                try:
+                    for game in (host, guest):
+                        game.raw('key', 'f1', 'tap')
+                        try:
+                            game.shot(out, 'evoker-fangs')
+                        finally:
+                            game.raw('key', 'f1', 'tap')
+                finally:
+                    host('command', command='tick unfreeze')
+                photographed = True
+            if stopped and not any(fangs(s) for s in statuses.values()):
+                break
+        lab.write_json(out / 'evoker-fangs.json', {'paths': paths, 'warmup': warmup, 'drawn': drawn})
+        assert all(warmup.values()), f'fang warmup not received: {warmup}'
+        assert all(drawn.values()), f'fang renderer produced no geometry: {drawn}'
+        assert paths['host'].keys() == paths['guest'].keys(), 'clients received different fang ids'
+        for id, samples in paths['host'].items():
+            other = paths['guest'][id]
+            assert all(f['position'] == samples[0]['position'] for f in samples + other), \
+                f'fang {id} is not at its authoritative position'
+            for name, frames in (('host', samples), ('guest', other)):
+                life = {f['life'] for f in frames if f['started']}
+                assert len(life) > 1, f'{name}: fang {id} did not animate: {frames}'
+        assert not any(fangs(g('status')) for g in (host, guest)), 'fangs survived server removal'
+    finally:
+        host('command', command='tick unfreeze')
+        host('command', command=f'kill @e[tag={tag}]')
+        guest('command', command='effect clear @s')
+        face_each_other(host, guest)
+    return {'fangs': len(paths['host']), 'warmup': warmup, 'drawn': drawn, 'removed': True}
+
+
+CHECKS += ['fangs']
+CHECK_FNS.update(fangs=check_fangs)
+
+
 if __name__ == '__main__':
     main()

From 9e3956282abf29f49ba9e0e1f0f04b3622a9b900 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 12:18:36 +0100
Subject: [PATCH 007/475] Send a deflected fireball's new direction to the
 player at once

A ghast fireball or wind charge hit back by a player was turned on the server, but the player kept seeing it fly on until its next update ten ticks later. Mark the turn to be sent right away, as vanilla does with needsSync, and reset the acceleration power to 0.1 as an attack deflection does.
---
 crates/horizon-client/src/game/deflect.rs      | 5 +++++
 crates/horizon-client/src/game/lan.rs          | 3 +++
 crates/horizon-client/src/game/lan_entities.rs | 1 +
 crates/horizon-client/src/projectiles.rs       | 4 ++++
 4 files changed, 13 insertions(+)

diff --git a/crates/horizon-client/src/game/deflect.rs b/crates/horizon-client/src/game/deflect.rs
index a08de87b3..088374a34 100644
--- a/crates/horizon-client/src/game/deflect.rs
+++ b/crates/horizon-client/src/game/deflect.rs
@@ -120,6 +120,11 @@ impl Game<'_> {
         p.guest = guest;
         // Not into the one who turned it on its way out.
         p.left_owner = false;
+        // `AbstractHurtingProjectile.onDeflection` by an attack, and the
+        // `needsSync` that `AIM_DEFLECT` sets: a server's players see it turn
+        // at once, not at the fireball's next update ten ticks later.
+        p.acceleration = 0.1;
+        p.needs_sync = true;
         self.reset_attack_strength();
         self.swing_arm();
         let from = self
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 50fa222e6..721fea5cd 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -912,6 +912,9 @@ impl Game<'_> {
             for m in &mut self.mobs {
                 m.needs_sync = false;
             }
+            for p in &mut self.creatures.projectiles {
+                p.needs_sync = false;
+            }
             let entities = states.as_slice();
             let spawn = self.spawn.map_or([0.5, 80.0, 0.5], |s| [s.x, s.y, s.z]);
             let events = {
diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs
index cd4ba2fb8..a5c925a65 100644
--- a/crates/horizon-client/src/game/lan_entities.rs
+++ b/crates/horizon-client/src/game/lan_entities.rs
@@ -325,6 +325,7 @@ impl Game<'_> {
             let mut e = state(p.id, kind, at(p.position), p.yaw, false);
             e.pitch = p.pitch;
             e.velocity = at(p.velocity);
+            e.needs_sync = p.needs_sync;
             // Projectile.getAddEntityPacket: the owner's id.
             e.data = match p.guest.and_then(|conn| hub.guest(conn)) {
                 Some(g) => g.entity_id,
diff --git a/crates/horizon-client/src/projectiles.rs b/crates/horizon-client/src/projectiles.rs
index 219d59b6b..ef50c30a4 100644
--- a/crates/horizon-client/src/projectiles.rs
+++ b/crates/horizon-client/src/projectiles.rs
@@ -104,6 +104,9 @@ pub struct Projectile {
     pub arrow: Option<Box<crate::arrows::ArrowState>>,
     /// `AbstractHurtingProjectile.accelerationPower`.
     pub acceleration: f64,
+    /// `Entity.needsSync`: a server tells its clients about the change this
+    /// tick instead of at the next update interval.
+    pub needs_sync: bool,
 }
 /// What a projectile struck this tick.
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -168,6 +171,7 @@ impl Projectile {
             left_owner: false,
             bonus: Default::default(),
             acceleration: 0.1,
+            needs_sync: false,
             arrow: kind_is_arrow.then(|| {
                 // Entity.random: seeded unpredictably, the position stands in.
                 Box::new(crate::arrows::ArrowState::new(

From f5f7448909e1dfe7db76ff0c9a565bc59f786967 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 12:31:40 +0100
Subject: [PATCH 008/475] Lingering potions leave an effect cloud

A thrown lingering potion used to act as one weaker splash. It now leaves an area effect cloud like vanilla: radius 3, a 10 tick wait, 600 ticks, shrinking as it goes and by 0.5 each time it affects someone. Every 5 ticks it affects the mobs and players inside, with a 20 tick delay per entity, at a quarter of the duration (instant effects at half strength). Server players see it as an area_effect_cloud, like the dragon's breath clouds.
---
 crates/horizon-client/src/game/dragon.rs      |  38 ++-
 .../horizon-client/src/game/lan_entities.rs   |  10 +-
 crates/horizon-client/src/game/potions.rs     | 248 ++++++++++++++++--
 .../src/game/remote_projectiles.rs            |  98 +++----
 4 files changed, 310 insertions(+), 84 deletions(-)

diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index e1880f9aa..c55e3ec9d 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -289,11 +289,11 @@ pub(super) enum FightWho {
 }
 /// A player in the End as the dragon sees it.
 #[derive(Clone, Copy, Debug)]
-struct FightPlayer {
-    who: FightWho,
-    position: Vec3,
-    bounds: Aabb,
-    alive: bool,
+pub(super) struct FightPlayer {
+    pub(super) who: FightWho,
+    pub(super) position: Vec3,
+    pub(super) bounds: Aabb,
+    pub(super) alive: bool,
     creative: bool,
     spectator: bool,
 }
@@ -691,7 +691,7 @@ impl Game<'_> {
     }
     /// The players in the level the dragon sees (`level.players()`): the
     /// window's own, then every guest in the level.
-    fn fight_players(&self) -> Vec<FightPlayer> {
+    pub(super) fn fight_players(&self) -> Vec<FightPlayer> {
         let mut out = Vec::new();
         if let Some(p) = self.player.as_ref() {
             out.push(FightPlayer {
@@ -720,7 +720,7 @@ impl Game<'_> {
     }
     /// Run `f` as the fight's player `who` (a guest's turn, its knockback
     /// sent to its client).
-    fn as_fight_player(&mut self, who: FightWho, f: impl FnOnce(&mut Self)) {
+    pub(super) fn as_fight_player(&mut self, who: FightWho, f: impl FnOnce(&mut Self)) {
         match who {
             FightWho::Host => f(self),
             FightWho::Guest(conn) => {
@@ -1564,6 +1564,7 @@ impl Game<'_> {
                         age: 0,
                         duration: 200,
                         from_dragon: true,
+                        potion: None,
                     });
                 }
             }
@@ -2091,6 +2092,7 @@ impl Game<'_> {
                     age: 0,
                     duration: 600,
                     from_dragon: false,
+                    potion: None,
                 });
                 self.audio.play(
                     "minecraft:entity.dragon_fireball.explode",
@@ -2123,6 +2125,10 @@ impl Game<'_> {
         let mut harmed: Vec<(FightWho, f32)> = Vec::new();
         let mut clouds = std::mem::take(&mut self.breath_clouds);
         clouds.retain_mut(|c| {
+            // Lingering potions' clouds tick with the potions.
+            if c.potion.is_some() {
+                return true;
+            }
             c.age += 1;
             if c.age >= c.duration {
                 return false;
@@ -2250,8 +2256,22 @@ pub(super) struct Breath {
     pub(super) at: [f64; 3],
     pub(super) radius: f32,
     pub(super) age: i32,
-    duration: i32,
-    from_dragon: bool,
+    pub(super) duration: i32,
+    pub(super) from_dragon: bool,
+    /// A lingering potion's cloud (`ThrownLingeringPotion`): what it applies.
+    pub(super) potion: Option<super::potions::PotionCloud>,
+}
+impl Breath {
+    /// `AreaEffectCloud.isWaiting`: before its wait time (20 ticks, 10 for a
+    /// lingering potion's).
+    pub(super) fn waiting(&self) -> bool {
+        self.age
+            < if self.potion.is_some() {
+                super::potions::LINGERING_WAIT
+            } else {
+                20
+            }
+    }
 }
 impl Game<'_> {
     /// `EnderDragonRenderer` and `EnderDragonModel.setupAnim`.
diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs
index 574f5303e..d8e2a09a6 100644
--- a/crates/horizon-client/src/game/lan_entities.rs
+++ b/crates/horizon-client/src/game/lan_entities.rs
@@ -439,7 +439,7 @@ impl Game<'_> {
             }
             out.push(e);
         }
-        // The dragon's breath clouds (AreaEffectCloud's DATA_RADIUS,
+        // The dragon's breath and lingering potion clouds (AreaEffectCloud's DATA_RADIUS,
         // DATA_WAITING for its 20-tick wait, and DATA_PARTICLE): the
         // client draws them from these (`tick_remote_clouds`).
         let breath = self.network_particle(
@@ -457,10 +457,14 @@ impl Game<'_> {
         for b in self.breath_clouds.iter().filter(|b| b.id != 0) {
             let mut e = state(b.id, "minecraft:area_effect_cloud", b.at, 0.0, false);
             e.meta.push((8, serializer::FLOAT, Value::Float(b.radius)));
-            if b.age < 20 {
+            if b.waiting() {
                 e.meta.push((9, serializer::BOOLEAN, Value::Bool(true)));
             }
-            if let Some(p) = &breath {
+            let particle = match &b.potion {
+                Some(p) => self.network_particle(&p.particle(), None),
+                None => breath.clone(),
+            };
+            if let Some(p) = &particle {
                 e.meta
                     .push((10, serializer::PARTICLE, Value::Particle(p.clone())));
             }
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index 74c4ccd0c..bfffff5ee 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -2,7 +2,12 @@
 //! `Consumable`), throwing splash/lingering potions (`ThrownSplashPotion`),
 //! filling glass bottles (`BottleItem`), the per-tick effect application,
 //! effect attribute modifiers and the HUD effect icons (`Hud.extractEffects`).
-use super::{Game, Screen, item_draw::owner_at};
+use super::{
+    Game, Screen,
+    dragon::{Breath, FightPlayer, FightWho},
+    item_draw::owner_at,
+    remote_projectiles::cloud_client_tick,
+};
 use horizon_assets::item_model::DisplayContext;
 use horizon_client::{
     block_entity_render::vertex_light,
@@ -12,8 +17,12 @@ use horizon_client::{
     hud_layout, hud_overlays, inventory_effects,
     items::ItemStack,
     mesher::Vertex,
+    particles::{ParticleOptions, ParticleType},
+};
+use horizon_core::{
+    geometry::{Aabb, Vec3},
+    random::RandomSource,
 };
-use horizon_core::{geometry::Vec3, random::RandomSource};
 
 /// A thrown splash or lingering potion in flight.
 #[derive(Clone, Debug)]
@@ -27,6 +36,32 @@ pub(super) struct ThrownPotion {
     velocity: Vec3,
     age: u32,
 }
+/// `AreaEffectCloud` wait time set by `ThrownLingeringPotion.onHitAsPotion`.
+pub(super) const LINGERING_WAIT: i32 = 10;
+/// `AreaEffectCloud.DEFAULT_REAPPLICATION_DELAY`.
+const REAPPLICATION_DELAY: i32 = 20;
+/// An entity a cloud has affected (`AreaEffectCloud.victims`).
+#[derive(Clone, Copy, PartialEq)]
+enum Victim {
+    Mob(u32),
+    Player(FightWho),
+}
+/// What a lingering potion's `AreaEffectCloud` applies: the potion's effects
+/// (at the lingering item's 0.25 duration scale) and who it has affected.
+pub(super) struct PotionCloud {
+    effects: &'static [(&'static str, i32, i32)],
+    /// The potion's colour (`PotionContents.getColor`).
+    color: u32,
+    /// Each victim and the tick it can be affected again.
+    victims: Vec<(Victim, i32)>,
+}
+impl PotionCloud {
+    /// `AreaEffectCloud.updateParticle`: an entity effect in the potion's colour.
+    pub(super) fn particle(&self) -> ParticleOptions {
+        let c = |shift: u32| (self.color >> shift & 255) as f32 / 255.0;
+        ParticleOptions::colored(ParticleType::EntityEffect, [c(16), c(8), c(0), 1.0])
+    }
+}
 /// A mob's effect ids carry the `minecraft:` namespace.
 fn mob_effect_id(id: &str) -> Option<&'static str> {
     use std::{collections::HashMap, sync::OnceLock};
@@ -368,6 +403,7 @@ impl Game<'_> {
         self.tick_mob_effects();
         if running {
             self.tick_thrown_potions();
+            self.tick_potion_clouds();
         }
     }
     /// `LivingEntity.tickEffects` (server side) for `self.player`, the local
@@ -504,21 +540,20 @@ impl Game<'_> {
                 let state =
                     self.world
                         .block(p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32);
-                if self.res.facts().get(state).full_collision
-                    || self.mobs.iter().any(|m| {
-                        m.alive()
-                            && (m.position.x - p.x).abs() < m.kind.width / 2.0 + 0.125
-                            && (m.position.z - p.z).abs() < m.kind.width / 2.0 + 0.125
-                            && p.y >= m.position.y
-                            && p.y <= m.position.y + m.kind.height
-                    })
-                {
-                    hit = Some(p);
+                let mob = self.mobs.iter().find(|m| {
+                    m.alive()
+                        && (m.position.x - p.x).abs() < m.kind.width / 2.0 + 0.125
+                        && (m.position.z - p.z).abs() < m.kind.width / 2.0 + 0.125
+                        && p.y >= m.position.y
+                        && p.y <= m.position.y + m.kind.height
+                });
+                if self.res.facts().get(state).full_collision || mob.is_some() {
+                    hit = Some((p, mob.map(|m| m.position)));
                     break;
                 }
             }
-            if let Some(p) = hit {
-                landed.push((t.stack.clone(), p));
+            if let Some((p, mob)) = hit {
+                landed.push((t.stack.clone(), p, mob));
                 return false;
             }
             t.position = next;
@@ -537,8 +572,148 @@ impl Game<'_> {
             t.age < 1200 && t.position.y > -128.0
         });
         self.potions.thrown = thrown;
-        for (stack, at) in landed {
-            self.splash(&stack, at);
+        for (stack, at, mob) in landed {
+            self.splash(&stack, at, mob);
+        }
+    }
+    /// `AreaEffectCloud.tick` for the lingering potions' clouds: the client
+    /// tick's particles, then the server tick.
+    fn tick_potion_clouds(&mut self) {
+        if self.breath_clouds.iter().all(|c| c.potion.is_none()) {
+            return;
+        }
+        let players: Vec<FightPlayer> = self
+            .fight_players()
+            .into_iter()
+            .filter(|p| p.alive)
+            .collect();
+        let mut clouds = std::mem::take(&mut self.breath_clouds);
+        clouds.retain_mut(|c| c.potion.is_none() || self.tick_potion_cloud(c, &players));
+        self.breath_clouds.append(&mut clouds);
+    }
+    /// `AreaEffectCloud.serverTick` for a lingering potion's cloud: after its
+    /// wait it shrinks, and every 5 ticks it affects the living entities in
+    /// its box and radius that were not affected in the last 20 ticks, each
+    /// taking some of its radius. False once it is gone.
+    fn tick_potion_cloud(&mut self, c: &mut Breath, players: &[FightPlayer]) -> bool {
+        c.age += 1;
+        let Some(potion) = c.potion.as_mut() else {
+            return true;
+        };
+        if c.age - LINGERING_WAIT >= c.duration {
+            return false;
+        }
+        let waiting = c.age < LINGERING_WAIT;
+        cloud_client_tick(
+            &mut self.particles,
+            c.at,
+            c.radius,
+            waiting,
+            &potion.particle(),
+        );
+        if waiting {
+            return true;
+        }
+        // setRadiusPerTick(-radius / duration).
+        c.radius += -3.0 / 600.0;
+        if c.radius < 0.5 {
+            return false;
+        }
+        if c.age % 5 != 0 {
+            return true;
+        }
+        potion.victims.retain(|(_, until)| c.age < *until);
+        let r = f64::from(c.radius);
+        let area = Aabb::new(
+            Vec3::new(c.at[0] - r, c.at[1], c.at[2] - r),
+            Vec3::new(c.at[0] + r, c.at[1] + 0.5, c.at[2] + r),
+        );
+        let mut inside = Vec::new();
+        for p in players.iter().filter(|p| p.bounds.intersects(area)) {
+            inside.push((Victim::Player(p.who), p.position.x, p.position.z));
+        }
+        for m in self
+            .mobs
+            .iter()
+            .filter(|m| m.alive() && m.bounds().intersects(area))
+        {
+            inside.push((Victim::Mob(m.id), m.position.x, m.position.z));
+        }
+        let effects = potion.effects;
+        for (victim, x, z) in inside {
+            let (dx, dz) = (x - c.at[0], z - c.at[2]);
+            if potion.victims.iter().any(|(v, _)| *v == victim)
+                || dx * dx + dz * dz > f64::from(c.radius * c.radius)
+            {
+                continue;
+            }
+            potion.victims.push((victim, c.age + REAPPLICATION_DELAY));
+            self.cloud_affect(victim, effects, c.at);
+            // setRadiusOnUse(-0.5).
+            c.radius -= 0.5;
+            if c.radius < 0.5 {
+                return false;
+            }
+        }
+        true
+    }
+    /// What a cloud puts on one entity: instant effects at half strength
+    /// (`applyInstantaneousEffect` with 0.5), the others for their duration
+    /// at the lingering item's 0.25 scale (`PotionContents.forEachEffect`).
+    fn cloud_affect(
+        &mut self,
+        victim: Victim,
+        effects: &'static [(&'static str, i32, i32)],
+        at: [f64; 3],
+    ) {
+        let scaled = |duration: i32| ((f64::from(duration) * 0.25) as i32).max(1);
+        match victim {
+            Victim::Player(who) => self.as_fight_player(who, |g| {
+                for (id, duration, amp) in effects {
+                    let Some(e) = brewing::effect(id) else {
+                        continue;
+                    };
+                    if e.instant {
+                        if let Some(a) = horizon_client::effects::instant(id, *amp, 0.5) {
+                            g.apply_effect_action(a);
+                        }
+                    } else {
+                        g.add_player_effect(EffectInstance::new(e.id, scaled(*duration), *amp));
+                    }
+                }
+            }),
+            Victim::Mob(mob) => {
+                let Some(i) = self.mobs.iter().position(|m| m.id == mob) else {
+                    return;
+                };
+                // Undead invert healing and harming.
+                let inverted = self
+                    .res
+                    .stations()
+                    .enchantments
+                    .entity_tags
+                    .get("minecraft:inverted_healing_and_harm")
+                    .is_some_and(|t| t.contains(&self.mobs[i].kind.id));
+                for (id, duration, amp) in effects {
+                    let m = &mut self.mobs[i];
+                    match *id {
+                        "instant_damage" | "instant_health" => {
+                            let amount =
+                                |base: i32| (0.5 * f64::from(base << amp) + 0.5) as i32 as f32;
+                            if (*id == "instant_damage") != inverted {
+                                m.hurt(amount(6), Some(at), &mut self.world.random);
+                            } else {
+                                m.health = (m.health + amount(4)).min(m.kind.max_health);
+                            }
+                        }
+                        _ => {
+                            if let Some(name) = mob_effect_id(id) {
+                                m.add_effect(name, scaled(*duration), *amp);
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
     /// `ThrownItemRenderer` for thrown splash and lingering potions and
@@ -587,12 +762,7 @@ impl Game<'_> {
         }
     }
     /// A splash potion's effects on the player in place, by their distance.
-    fn splash_on_player(
-        &mut self,
-        effects: &'static [(&'static str, i32, i32)],
-        at: Vec3,
-        scale: f64,
-    ) {
+    fn splash_on_player(&mut self, effects: &'static [(&'static str, i32, i32)], at: Vec3) {
         if let Some(p) = self.player.as_ref() {
             let center = Vec3::new(
                 p.position.x,
@@ -610,7 +780,7 @@ impl Game<'_> {
                             self.apply_effect_action(a);
                         }
                     } else {
-                        let d = (intensity * f64::from(*duration) * scale + 0.5) as i32;
+                        let d = (intensity * f64::from(*duration) + 0.5) as i32;
                         if d > 20
                             && let Some(e) = brewing::effect(id)
                         {
@@ -621,8 +791,9 @@ impl Game<'_> {
             }
         }
     }
-    /// `ThrownSplashPotion.onHitAsPotion` (lingering clouds apply as a weaker splash).
-    fn splash(&mut self, stack: &ItemStack, at: Vec3) {
+    /// `ThrownSplashPotion.onHitAsPotion`, or `ThrownLingeringPotion.onHitAsPotion`
+    /// for a lingering potion; `mob` is where it hit a mob.
+    fn splash(&mut self, stack: &ItemStack, at: Vec3, mob: Option<Vec3>) {
         if &*stack.item == "minecraft:experience_bottle" {
             // ThrownExperienceBottle.onHit: the water-coloured splash (level
             // event 2002) and 3 to 11 experience.
@@ -677,13 +848,34 @@ impl Game<'_> {
             );
             self.particles.push(p);
         }
-        let scale = if lingering { 0.25 } else { 1.0 };
         let Some(def) = stack.potion().and_then(brewing::potion) else {
             return;
         };
+        if lingering {
+            // The cloud sits at the mob it hit (its feet), else the impact;
+            // radius 3, wait 10, 600 ticks, shrinking to nothing, and a
+            // potion with no effects leaves none.
+            if !def.effects.is_empty() {
+                let at = mob.unwrap_or(at);
+                self.breath_clouds.push(Breath {
+                    id: 0,
+                    at: [at.x, at.y, at.z],
+                    radius: 3.0,
+                    age: 0,
+                    duration: 600,
+                    from_dragon: false,
+                    potion: Some(PotionCloud {
+                        effects: def.effects,
+                        color,
+                        victims: Vec::new(),
+                    }),
+                });
+            }
+            return;
+        }
         // Every player in range (`ThrownSplashPotion.applySplash` over
         // `LivingEntity`s, the players among them).
-        self.for_each_player(|g| g.splash_on_player(def.effects, at, scale));
+        self.for_each_player(|g| g.splash_on_player(def.effects, at));
         // Mobs take the instant effects (undead invert healing and harming).
         let undead = &self.res.stations().enchantments.entity_tags;
         let mut hits = Vec::new();
@@ -706,7 +898,7 @@ impl Game<'_> {
                     _ => {
                         // `Potion.applySplash`: timed effects last in
                         // proportion to how close the mob was.
-                        let d = (intensity * f64::from(*duration) * scale + 0.5) as i32;
+                        let d = (intensity * f64::from(*duration) + 0.5) as i32;
                         if d > 20
                             && let Some(name) = mob_effect_id(id)
                         {
diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs
index bbb7b7cde..f6fff2ca2 100644
--- a/crates/horizon-client/src/game/remote_projectiles.rs
+++ b/crates/horizon-client/src/game/remote_projectiles.rs
@@ -23,6 +23,58 @@ fn default_cloud_particle() -> ParticleOptions {
     ParticleOptions::colored(ParticleType::EntityEffect, [1.0; 4])
 }
 
+/// `AreaEffectCloud.clientTick`: while waiting, now and then two particles
+/// near the middle; then about one per square block of the disc, drifting
+/// (an entity effect stays still).
+pub(super) fn cloud_client_tick(
+    particles: &mut horizon_client::particles::ParticleEngine,
+    at: [f64; 3],
+    radius: f32,
+    waiting: bool,
+    particle: &ParticleOptions,
+) {
+    if waiting && particles.random().next_boolean() {
+        return;
+    }
+    let (count, spread) = if waiting {
+        (2, 0.2)
+    } else {
+        (
+            (std::f32::consts::PI * radius * radius).ceil() as i32,
+            radius,
+        )
+    };
+    for _ in 0..count {
+        let r = particles.random();
+        let angle = r.next_float() * std::f32::consts::TAU;
+        let distance = r.next_float().sqrt() * spread;
+        let at = [
+            at[0] + f64::from(angle.cos() * distance),
+            at[1],
+            at[2] + f64::from(angle.sin() * distance),
+        ];
+        let (options, velocity) = if particle.ty == ParticleType::EntityEffect {
+            let default = waiting && r.next_boolean();
+            let options = if default {
+                default_cloud_particle()
+            } else {
+                particle.clone()
+            };
+            (options, [0.0; 3])
+        } else if waiting {
+            (particle.clone(), [0.0; 3])
+        } else {
+            let v = [
+                (0.5 - r.next_double()) * 0.15,
+                f64::from(0.01f32),
+                (0.5 - r.next_double()) * 0.15,
+            ];
+            (particle.clone(), v)
+        };
+        particles.add(&options, at, velocity);
+    }
+}
+
 /// The projectile a type id names, as Horizon models it.
 fn projectile_kind(kind: &str) -> Option<ProjectileKind> {
     Some(match kind {
@@ -380,52 +432,10 @@ impl Game<'_> {
         }
     }
 
-    /// `AreaEffectCloud.clientTick`: while waiting, now and then two
-    /// particles near the middle; then about one per square block of the
-    /// disc, drifting (an entity effect stays still).
+    /// `AreaEffectCloud.clientTick` for each cloud a server tracks.
     fn tick_remote_clouds(&mut self) {
         for c in &self.potions.clouds {
-            let r = self.particles.random();
-            if c.waiting && r.next_boolean() {
-                continue;
-            }
-            let (count, spread) = if c.waiting {
-                (2, 0.2)
-            } else {
-                (
-                    (std::f32::consts::PI * c.radius * c.radius).ceil() as i32,
-                    c.radius,
-                )
-            };
-            for _ in 0..count {
-                let r = self.particles.random();
-                let angle = r.next_float() * std::f32::consts::TAU;
-                let distance = r.next_float().sqrt() * spread;
-                let at = [
-                    c.at[0] + f64::from(angle.cos() * distance),
-                    c.at[1],
-                    c.at[2] + f64::from(angle.sin() * distance),
-                ];
-                let (options, velocity) = if c.particle.ty == ParticleType::EntityEffect {
-                    let default = c.waiting && r.next_boolean();
-                    let options = if default {
-                        default_cloud_particle()
-                    } else {
-                        c.particle.clone()
-                    };
-                    (options, [0.0; 3])
-                } else if c.waiting {
-                    (c.particle.clone(), [0.0; 3])
-                } else {
-                    let v = [
-                        (0.5 - r.next_double()) * 0.15,
-                        f64::from(0.01f32),
-                        (0.5 - r.next_double()) * 0.15,
-                    ];
-                    (c.particle.clone(), v)
-                };
-                self.particles.add(&options, at, velocity);
-            }
+            cloud_client_tick(&mut self.particles, c.at, c.radius, c.waiting, &c.particle);
         }
     }
 

From 265965445d471e0dedba02d998362e8642443b78 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 12:34:59 +0100
Subject: [PATCH 009/475] Save the world when the game gets SIGTERM, Ctrl+C or
 SIGHUP, and disconnect on native quit

---
 crates/horizon-client/src/game.rs | 22 +++++++++++++++++++++
 crates/horizon-threads/src/lib.rs | 32 +++++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index cdbd72d7b..e8e6a6bcb 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -8207,6 +8207,10 @@ impl Game<'_> {
         }
         self.lan_close(false);
         self.save_game()?;
+        if let Some(mut remote) = self.remote.take() {
+            // Minecraft.disconnect closes the connection, so the host sees a clean leave.
+            remote.session.disconnect();
+        }
         self.saved_for_exit = true;
         Ok(())
     }
@@ -11960,6 +11964,16 @@ impl ApplicationHandler for Game<'_> {
         }
     }
     fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        if horizon_threads::stop_requests() > 0
+            && self.pending_save.as_ref().is_none_or(|save| !save.quit)
+        {
+            // SIGTERM, SIGINT or SIGHUP: the shutdown hook's server halt, as a window close.
+            if let Err(error) = self.begin_closing_save(true) {
+                self.error = Some(error);
+                event_loop.exit();
+                return;
+            }
+        }
         if self.pending_save.is_some() {
             match self.poll_closing_save() {
                 Ok(true) => event_loop.exit(),
@@ -13405,6 +13419,11 @@ impl Loading {
         }
     }
     fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        if horizon_threads::stop_requests() > 0 {
+            // No world is open yet: nothing to save.
+            event_loop.exit();
+            return;
+        }
         if let Err(error) = self.poll_menu_resources() {
             self.error = Some(error);
             event_loop.exit();
@@ -13682,6 +13701,9 @@ pub fn run() -> Result<()> {
     {
         horizon_client::heartbeat::start();
     }
+    if options.execution_role.is_client() {
+        horizon_threads::catch_stop_signals();
+    }
     let started = Instant::now();
     horizon_client::spans::enable(options.spikes.is_some());
     let vanilla_root = options.resources.clone();
diff --git a/crates/horizon-threads/src/lib.rs b/crates/horizon-threads/src/lib.rs
index 90c8d128e..ec98b1690 100644
--- a/crates/horizon-threads/src/lib.rs
+++ b/crates/horizon-threads/src/lib.rs
@@ -126,6 +126,38 @@ fn idle() -> bool {
     false
 }
 
+/// How many stop requests (Ctrl-C, SIGTERM, SIGHUP) arrived since `catch_stop_signals`.
+pub fn stop_requests() -> u32 {
+    STOP_REQUESTS.load(std::sync::atomic::Ordering::SeqCst)
+}
+
+static STOP_REQUESTS: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+
+/// Count stop requests from outside instead of dying on them: vanilla's "Client Shutdown Thread"
+/// (`Main.java`) halts the integrated server when the JVM shuts down, and the JVM does that on
+/// these signals, so a killed game still saves. The caller's event loop turns the first request
+/// into a normal quit; a second one (the save is stuck) ends the process at once.
+#[cfg(any(target_vendor = "apple", target_os = "linux", target_os = "android"))]
+pub fn catch_stop_signals() {
+    extern "C" fn handle(_: libc::c_int) {
+        if STOP_REQUESTS.fetch_add(1, Ordering::SeqCst) >= 1 {
+            // SAFETY: _exit is async-signal-safe; 130 is the shell's code for a Ctrl-C death.
+            unsafe { libc::_exit(130) }
+        }
+    }
+    let handler = handle as extern "C" fn(libc::c_int);
+    for signal in [libc::SIGINT, libc::SIGTERM, libc::SIGHUP] {
+        // SAFETY: the handler only touches an atomic and calls _exit, both async-signal-safe.
+        unsafe {
+            libc::signal(signal, handler as libc::sighandler_t);
+        }
+    }
+}
+
+/// Windows and the other systems keep their default: a closed window is a `CloseRequested`.
+#[cfg(not(any(target_vendor = "apple", target_os = "linux", target_os = "android")))]
+pub fn catch_stop_signals() {}
+
 #[cfg(test)]
 mod tests {
     /// The hint holds on the platforms that take it.

From 09078949d784d48ae928c59038cb79674a86a538 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 12:36:29 +0100
Subject: [PATCH 010/475] Send a guest's explosion to the players once their
 turn ends

An end crystal (or minecart) hit by a player on the server thread blew up
with sound and damage but no explosion particles. The blast runs inside the
guest's turn, while the host holds the players, so lan_explode had no hub to
send the explosion packet through and dropped it. Queue it like a wind burst
and send it when the turn is over.
---
 crates/horizon-client/src/game/creatures.rs    |  4 ++++
 crates/horizon-client/src/game/lan.rs          |  3 ++-
 .../horizon-client/src/game/lan_particles.rs   | 18 +++++++++++++++++-
 3 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 3a8562ee1..db6fca100 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -45,6 +45,9 @@ pub(super) struct Creatures {
     pub projectiles: Vec<Projectile>,
     /// Wind bursts from a guest's turn, waiting for it to end (game/wind.rs).
     pub wind_bursts: Vec<super::wind::Burst>,
+    /// Explosion packets from a guest's turn, waiting for it to end
+    /// (centre, radius, blocks hit; game/lan_particles.rs).
+    pub lan_explosions: Vec<([f64; 3], f32, usize)>,
     /// Ticks left of the elder guardian's apparition (MobAppearanceParticle).
     pub elder_apparition: i32,
     /// The wandering trader spawner's clock.
@@ -1839,6 +1842,7 @@ impl Game<'_> {
                 _ => self.projectile_hit(&p, hit)?,
             }
         }
+        self.flush_lan_explosions();
         self.flush_wind_bursts()
     }
     /// `projectile_hit` for a projectile the guest `conn` shot, run as them;
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 50fa222e6..29c405674 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -1044,7 +1044,8 @@ impl Game<'_> {
         drop(holding);
         lan::flush_all(host.hub.guests.iter().map(|g| &g.sender));
         self.lan = Some(host);
-        // A mace's wind burst from a guest's attack.
+        // A blast from a guest's attack, and a mace's wind burst.
+        self.flush_lan_explosions();
         let _ = self.flush_wind_bursts();
     }
 
diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs
index 0e35392bf..d58f18f5f 100644
--- a/crates/horizon-client/src/game/lan_particles.rs
+++ b/crates/horizon-client/src/game/lan_particles.rs
@@ -194,7 +194,16 @@ impl Game<'_> {
     /// `ServerLevel.explode`'s packet to each player within 64 blocks. The
     /// sound and the push reach them on their own (the level's sounds, the
     /// motion a hurt player is sent), so the packet carries neither.
-    pub(super) fn lan_explode(&self, center: [f64; 3], radius: f32, block_count: usize) {
+    pub(super) fn lan_explode(&mut self, center: [f64; 3], radius: f32, block_count: usize) {
+        // In a guest's turn (their hit on an end crystal or a minecart) the
+        // host holds the players (`as_guest`): the packet waits for the turn
+        // to end so that it reaches every player, the guest too.
+        if self.lan_acting.is_some() && self.lan.is_none() {
+            self.creatures
+                .lan_explosions
+                .push((center, radius, block_count));
+            return;
+        }
         let emitter = if radius < 2.0 {
             "minecraft:explosion"
         } else {
@@ -208,6 +217,13 @@ impl Game<'_> {
         }
     }
 
+    /// The explosions guests' turns put off.
+    pub(super) fn flush_lan_explosions(&mut self) {
+        for (center, radius, block_count) in std::mem::take(&mut self.creatures.lan_explosions) {
+            self.lan_explode(center, radius, block_count);
+        }
+    }
+
     /// A wind charge's burst (`AbstractWindCharge.explode`): gust emitters,
     /// no block particles, and for each player it pushed the push
     /// (`ServerExplosion.hitPlayers`), which only that client applies, as

From 3287a74d64e64ac8b3aa976276987b9b4b93f83f Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:00:40 +0100
Subject: [PATCH 011/475] Send fence knots to server players so leads tied to
 fences are drawn

---
 crates/horizon-client/src/game.rs             |  8 ++++++
 crates/horizon-client/src/game/lan.rs         |  4 +--
 .../horizon-client/src/game/lan_entities.rs   | 28 +++++++++++++++++++
 crates/horizon-client/src/game/remote.rs      | 10 +++++--
 .../horizon-client/src/game/remote_objects.rs | 16 +++++++++--
 5 files changed, 60 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index cdbd72d7b..0134dd9a1 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -1459,6 +1459,12 @@ struct Game<'a> {
     /// Map textures waiting for the next HUD batch to upload them.
     map_patches: Vec<horizon_client::font::Patch>,
     text_displays: std::collections::HashMap<i32, text_displays::RemoteTextDisplay>,
+    /// The fence knots a server tracks to this client, by entity id, at their
+    /// block (`LeashFenceKnotEntity`).
+    remote_knots: HashMap<u32, [i32; 3]>,
+    /// The entity ids a hosted server gives the knots its mobs hang on, by
+    /// block, while a lead is tied there.
+    knot_ids: HashMap<[i32; 3], u32>,
     text_display_vertices: usize,
     /// Player skin downloads, and which skin each atlas skin slot holds
     /// (least recently shown first).
@@ -12291,6 +12297,8 @@ impl<'a> Game<'a> {
             dragon_model: prepared.dragon_model,
             map_patches: Vec::new(),
             text_displays: Default::default(),
+            remote_knots: Default::default(),
+            knot_ids: Default::default(),
             text_display_vertices: 0,
             skin_downloads: RefCell::new(horizon_client::skins::Downloader::new(
                 std::env::current_dir()
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 50fa222e6..c698e969e 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -819,7 +819,7 @@ impl Game<'_> {
         out.clear();
         for m in self.mobs.iter().filter(|m| !m.removed) {
             // The lead's holder: the player the mob sees (a guest, else the
-            // host) or another mob. A fence knot isn't an entity here.
+            // host), another mob or a fence knot (game/lan_entities.rs).
             let leash = m.extra.leash.and_then(|h| match h {
                 Holder::Player => mob_players
                     .get(&m.id)
@@ -827,7 +827,7 @@ impl Game<'_> {
                     .map(|g| g.entity_id)
                     .or(host_entity),
                 Holder::Mob(id) => Some(id as i32),
-                Holder::Knot(_) => None,
+                Holder::Knot(p) => self.knot_ids.get(&p).map(|&id| id as i32),
             });
             let e = out.add(m.id as i32, entity_uuid(m.id), m.kind.id.as_str());
             e.position = [m.position.x, m.position.y, m.position.z];
diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs
index cd4ba2fb8..e161b9a2b 100644
--- a/crates/horizon-client/src/game/lan_entities.rs
+++ b/crates/horizon-client/src/game/lan_entities.rs
@@ -225,6 +225,16 @@ impl Game<'_> {
             }
             out.push(e);
         }
+        for (p, &id) in &self.knot_ids {
+            // LeashFenceKnotEntity.getAddEntityPacket: the fence's block.
+            out.push(state(
+                id,
+                "minecraft:leash_knot",
+                p.map(f64::from),
+                0.0,
+                false,
+            ));
+        }
         for p in &self.paintings {
             let mut e = state(p.id, "minecraft:painting", p.pos.map(f64::from), 0.0, false);
             // Direction.get2DDataValue (south 0, west 1, north 2, east 3) to its
@@ -260,6 +270,24 @@ impl Game<'_> {
     /// Gives the entities Horizon keeps without an id one (`Entity.id`, from
     /// the same counter as the rest) before they are first tracked.
     pub(super) fn lan_assign_ids(&mut self) {
+        // LeashFenceKnotEntity: one per fence post with a lead on it
+        // (`notifyLeasheeRemoved` discards it once the last lead is gone).
+        let knots: Vec<[i32; 3]> = self
+            .mobs
+            .iter()
+            .filter(|m| !m.removed)
+            .filter_map(|m| match m.extra.leash {
+                Some(horizon_client::mobs::leash::Holder::Knot(p)) => Some(p),
+                _ => None,
+            })
+            .collect();
+        self.knot_ids.retain(|p, _| knots.contains(p));
+        for p in knots {
+            self.knot_ids.entry(p).or_insert_with(|| {
+                self.next_entity += 1;
+                self.next_entity
+            });
+        }
         let next = &mut self.next_entity;
         let mut give = |id: &mut u32| {
             if *id == 0 {
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 5651647b7..849d6dfab 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -1808,7 +1808,8 @@ impl Game<'_> {
             }
             C::SetPassengers(p) => self.remote_set_passengers(p.vehicle, &p.passengers),
             // ClientPacketListener.handleEntityLinkPacket: who holds a mob's
-            // lead (this player, another player or a mob), for the rope.
+            // lead (this player, another player, a mob or a fence knot), for
+            // the rope.
             C::SetEntityLink(p) => {
                 let me = self.remote.as_ref().map(|r| r.entity_id);
                 if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.source as u32) {
@@ -1816,7 +1817,12 @@ impl Game<'_> {
                     m.extra.leash = match p.dest {
                         0 => None,
                         d if Some(d) == me => Some(Holder::Player),
-                        d => Some(Holder::Mob(d as u32)),
+                        d => match self.remote_knots.get(&(d as u32)) {
+                            Some(&block) => Some(Holder::Knot(block)),
+                            // Not a known knot yet: kept by id until the knot
+                            // arrives (game/remote_objects.rs).
+                            None => Some(Holder::Mob(d as u32)),
+                        },
                     };
                 }
             }
diff --git a/crates/horizon-client/src/game/remote_objects.rs b/crates/horizon-client/src/game/remote_objects.rs
index 251d277f3..3f39072e9 100644
--- a/crates/horizon-client/src/game/remote_objects.rs
+++ b/crates/horizon-client/src/game/remote_objects.rs
@@ -1,9 +1,10 @@
-//! Boats, minecarts, armor stands, item frames and paintings on a server's
+//! Boats, minecarts, armor stands, item frames, paintings and fence knots on a server's
 //! client (`ClientPacketListener.handleAddEntity`, `handleSetEntityData`,
 //! `handleSetEquipment`): the server simulates them, the client places them
 //! where it says and interpolates their moves like a mob's.
 use super::Game;
 use horizon_client::entities::{ArmorStand, ItemFrame, Painting};
+use horizon_client::mobs::leash::Holder;
 use horizon_core::geometry::Vec3;
 use horizon_protocol::entity_data::Value;
 use std::sync::Arc;
@@ -24,7 +25,17 @@ impl Game<'_> {
         let at = Vec3::new(position[0], position[1], position[2]);
         let block = position.map(|v| v.floor() as i32);
         self.remove_remote_object(id);
-        if kind == "minecraft:text_display" {
+        if kind == "minecraft:leash_knot" {
+            // A lead that came before its knot waits as a mob holder with the
+            // knot's id (handleEntityLinkPacket's delayed holder); now it can
+            // be tied to the fence.
+            self.remote_knots.insert(id, block);
+            for m in &mut self.mobs {
+                if m.extra.leash == Some(Holder::Mob(id)) {
+                    m.extra.leash = Some(Holder::Knot(block));
+                }
+            }
+        } else if kind == "minecraft:text_display" {
             self.text_displays.insert(
                 id as i32,
                 super::text_displays::RemoteTextDisplay::new(position, yaw),
@@ -292,6 +303,7 @@ impl Game<'_> {
 
     pub(super) fn remove_remote_object(&mut self, id: u32) {
         self.text_displays.remove(&(id as i32));
+        self.remote_knots.remove(&id);
         self.carts.retain(|c| c.id != id);
         self.boats.retain(|b| b.id != id);
         self.armor_stands.retain(|a| a.id != id);

From 5c0f7142f36cad8e1a1e7adffe3c6c5902328edb Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:03:44 +0100
Subject: [PATCH 012/475] Draw the level events the client dropped: lava and
 torch smoke, drips, chorus, sniffer eggs, dragon fireball burst

---
 crates/horizon-client/src/game.rs             |  51 ++++-
 crates/horizon-client/src/game/dragon.rs      |  15 +-
 .../src/game/level_particles.rs               | 205 ++++++++++++++++--
 crates/horizon-client/src/particles.rs        |  13 +-
 4 files changed, 261 insertions(+), 23 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index cdbd72d7b..f042bc28d 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2800,6 +2800,34 @@ impl Game<'_> {
                     pos,
                     data,
                 } => self.composter_fill_event(pos, data == 1),
+                // LevelEventHandler 1504: the stalactite's drip particle.
+                LevelEvent::LevelEvent { id: 1504, pos, .. } => self.dripstone_drip_particle(pos),
+                // LevelEventHandler 2006: the dragon fireball's burst.
+                LevelEvent::LevelEvent {
+                    id: 2006,
+                    pos,
+                    data,
+                } => self.dragon_fireball_burst(pos, data),
+                // LevelEventHandler 2009: a wet sponge drying.
+                LevelEvent::LevelEvent { id: 2009, pos, .. } => {
+                    self.puffs_above_block(pos, horizon_client::particles::ParticleType::Cloud)
+                }
+                // LevelEventHandler 2012: a turtle egg laid.
+                LevelEvent::LevelEvent {
+                    id: 2012,
+                    pos,
+                    data,
+                } => self.turtle_egg_particles(pos, data),
+                // LevelEventHandler 2014: a straw bed destroyed, with no sound.
+                LevelEvent::LevelEvent {
+                    id: 2014,
+                    pos,
+                    data,
+                } => self.destroy_particles([pos.x, pos.y, pos.z], BlockStateId(data as u32)),
+                // LevelEventHandler 3009: a sniffer egg cracking.
+                LevelEvent::LevelEvent { id: 3009, pos, .. } => {
+                    self.sniffer_egg_crack_particles(pos)
+                }
                 LevelEvent::LevelEvent {
                     id: id @ 3011..=3021,
                     pos,
@@ -2815,6 +2843,16 @@ impl Game<'_> {
                         1501 => Some(("minecraft:block.lava.extinguish", 0.5)),
                         1009 => Some(("minecraft:block.fire.extinguish", 0.5)),
                         1502 => Some(("minecraft:block.redstone_torch.burnout", 0.5)),
+                        1033 => Some(("minecraft:block.chorus_flower.grow", 1.0)),
+                        1034 => Some(("minecraft:block.chorus_flower.death", 1.0)),
+                        1046 => Some((
+                            "minecraft:block.pointed_dripstone.drip_lava_into_cauldron",
+                            2.0,
+                        )),
+                        1047 => Some((
+                            "minecraft:block.pointed_dripstone.drip_water_into_cauldron",
+                            2.0,
+                        )),
                         1030 => Some(("minecraft:block.anvil.use", 1.0)),
                         1029 => Some(("minecraft:block.anvil.destroy", 1.0)),
                         1031 => Some(("minecraft:block.anvil.land", 0.3)),
@@ -2826,12 +2864,12 @@ impl Game<'_> {
                     };
                     if let Some((name, volume)) = sound {
                         let pitch = match id {
-                            1009 => {
+                            1009 | 1501 | 1502 => {
                                 2.6 + (self.world.random.next_float()
                                     - self.world.random.next_float())
                                     * 0.8
                             }
-                            1029 | 1030 | 1042 | 1043 | 1044 => {
+                            1029 | 1030 | 1042 | 1043 | 1044 | 1046 | 1047 => {
                                 self.world.random.next_float() * 0.1 + 0.9
                             }
                             _ => 1.0,
@@ -2844,6 +2882,15 @@ impl Game<'_> {
                             self.audio.play(name, c, volume, pitch);
                         }
                     }
+                    // LevelEventHandler 1501 and 1502 draw their smoke after the sound.
+                    match id {
+                        1501 => self.puffs_above_block(
+                            pos,
+                            horizon_client::particles::ParticleType::LargeSmoke,
+                        ),
+                        1502 => self.torch_burnout_smoke(pos),
+                        _ => {}
+                    }
                 }
                 LevelEvent::Sound {
                     pos,
diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index 8c316deeb..c83018c82 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -2089,11 +2089,16 @@ impl Game<'_> {
                     duration: 600,
                     from_dragon: false,
                 });
-                self.audio.play(
-                    "minecraft:entity.dragon_fireball.explode",
-                    Some([next.x, next.y, next.z]),
-                    1.0,
-                    1.0,
+                // DragonFireball.onHit: level event 2006 (the burst of dragon
+                // breath and the explosion sound) at its block position.
+                self.level_event_at(
+                    2006,
+                    [
+                        next.x.floor() as i32,
+                        next.y.floor() as i32,
+                        next.z.floor() as i32,
+                    ],
+                    1,
                 );
                 return false;
             }
diff --git a/crates/horizon-client/src/game/level_particles.rs b/crates/horizon-client/src/game/level_particles.rs
index f12aedc5b..e6593e7b9 100644
--- a/crates/horizon-client/src/game/level_particles.rs
+++ b/crates/horizon-client/src/game/level_particles.rs
@@ -1,11 +1,13 @@
 //! Level events whose client handler (`LevelEventHandler`) spawns particles
 //! on a block: bone meal's growth (1505), dragon egg teleportation (2015), a
 //! consumable's teleport (2017), electric sparks (3002), waxing (3003), wax
-//! off (3004) and scraping (3005).
+//! off (3004) and scraping (3005), plus the smoke, drips, egg and dragon
+//! fireball particles of 1501, 1502, 1504, 2006, 2009, 2012 and 3009.
 use super::Game;
 use horizon_client::particles::{self, ParticleOptions, ParticleType};
-use horizon_core::{position::BlockPos, random::RandomSource};
+use horizon_core::{geometry::trig, position::BlockPos, random::RandomSource};
 use horizon_world::level::LevelEvent;
+use horizon_world::registry::BlockStateId;
 
 impl Game<'_> {
     pub(super) fn dragon_egg_particles(&mut self, pos: [i32; 3], data: i32) {
@@ -65,24 +67,42 @@ impl Game<'_> {
                 } else {
                     // ParticleUtils.spawnParticleInBlock: up to the
                     // block's shape (a full block when air).
-                    let inside = self.world.block(at[0], at[1], at[2]);
-                    let height = if facts.is_air(inside) {
-                        1.0
-                    } else {
-                        facts
-                            .get(inside)
-                            .outline
-                            .iter()
-                            .map(|b| b[4])
-                            .fold(0.0, f64::max)
-                    };
-                    (at, count, 0.5, height, true)
+                    (at, count, 0.5, self.block_shape_top(at), true)
                 }
             }
             None if &*facts.get(state).name == "minecraft:water" => (p, count * 3, 3.0, 1.0, false),
             None => return,
         };
-        let options = ParticleOptions::simple(ParticleType::HappyVillager);
+        self.spawn_particles(at, count, xz, height, floating, ParticleType::HappyVillager);
+    }
+    /// `BlockState.getShape(..).max(Y)` of the block at `at`, 1.0 for air.
+    fn block_shape_top(&self, at: [i32; 3]) -> f64 {
+        let facts = self.res.facts();
+        let inside = self.world.block(at[0], at[1], at[2]);
+        if facts.is_air(inside) {
+            1.0
+        } else {
+            facts
+                .get(inside)
+                .outline
+                .iter()
+                .map(|b| b[4])
+                .fold(0.0, f64::max)
+        }
+    }
+    /// `ParticleUtils.spawnParticles`: `count` slow particles spread over
+    /// `xz` blocks around `at` and `height` up, only above solid ground
+    /// unless floating ones are allowed.
+    fn spawn_particles(
+        &mut self,
+        at: [i32; 3],
+        count: i32,
+        xz: f64,
+        height: f64,
+        floating: bool,
+        ty: ParticleType,
+    ) {
+        let options = ParticleOptions::simple(ty);
         for _ in 0..count.max(0) {
             let r = self.particles.level_random();
             let v = [0.0; 3].map(|_: f64| r.next_gaussian() * 0.02);
@@ -101,6 +121,161 @@ impl Game<'_> {
             }
         }
     }
+    /// `LevelEventHandler` 2012 (a turtle egg laid on sand):
+    /// `ParticleUtils.spawnParticleInBlock` with happy villager sparks.
+    pub(super) fn turtle_egg_particles(&mut self, pos: BlockPos, count: i32) {
+        let at = [pos.x, pos.y, pos.z];
+        let height = self.block_shape_top(at);
+        self.spawn_particles(at, count, 0.5, height, true, ParticleType::HappyVillager);
+    }
+    /// `LevelEventHandler` 3009 (a sniffer egg cracking on moss):
+    /// `spawnParticlesOnBlockFaces(.., EGG_CRACK, UniformInt.of(3, 6))`.
+    pub(super) fn sniffer_egg_crack_particles(&mut self, pos: BlockPos) {
+        let mut spawned = Vec::new();
+        particles::on_block_faces_between(
+            self.particles.level_random(),
+            [pos.x, pos.y, pos.z],
+            3,
+            6,
+            |p, v| spawned.push((p, v)),
+        );
+        let options = ParticleOptions::simple(ParticleType::EggCrack);
+        for (p, v) in spawned {
+            self.particles.add(&options, p, v);
+        }
+    }
+    /// `LevelEventHandler` 1501 (lava put out) and 2009 (a wet sponge dried):
+    /// eight puffs just above the block, drawn after the sound.
+    pub(super) fn puffs_above_block(&mut self, pos: BlockPos, ty: ParticleType) {
+        let options = ParticleOptions::simple(ty);
+        for _ in 0..8 {
+            let r = self.particles.level_random();
+            let x = f64::from(pos.x) + r.next_double();
+            let z = f64::from(pos.z) + r.next_double();
+            self.particles
+                .add(&options, [x, f64::from(pos.y) + 1.2, z], [0.0; 3]);
+        }
+    }
+    /// `LevelEventHandler` 1502 (a redstone torch burning out): five smoke
+    /// puffs inside the block, drawn after the sound.
+    pub(super) fn torch_burnout_smoke(&mut self, pos: BlockPos) {
+        let options = ParticleOptions::simple(ParticleType::Smoke);
+        for _ in 0..5 {
+            let r = self.particles.level_random();
+            let x = f64::from(pos.x) + r.next_double() * 0.6 + 0.2;
+            let y = f64::from(pos.y) + r.next_double() * 0.6 + 0.2;
+            let z = f64::from(pos.z) + r.next_double() * 0.6 + 0.2;
+            self.particles.add(&options, [x, y, z], [0.0; 3]);
+        }
+    }
+    /// `LevelEventHandler` 2006 (`DragonFireball.onHit`): 200 dragon breath
+    /// particles thrown outwards, then the explosion sound when `data` is 1.
+    pub(super) fn dragon_fireball_burst(&mut self, pos: BlockPos, data: i32) {
+        for _ in 0..200 {
+            let r = self.particles.level_random();
+            let dist = r.next_float() * 4.0;
+            let angle = r.next_float() * std::f32::consts::TAU;
+            let vx = f64::from(trig::cos(f64::from(angle)) * dist);
+            let vy = 0.01 + r.next_double() * 0.5;
+            let vz = f64::from(trig::sin(f64::from(angle)) * dist);
+            let options = ParticleOptions {
+                scale: dist,
+                ..ParticleOptions::simple(ParticleType::DragonBreath)
+            };
+            self.particles.add(
+                &options,
+                [
+                    f64::from(pos.x) + vx * 0.1,
+                    f64::from(pos.y) + 0.3,
+                    f64::from(pos.z) + vz * 0.1,
+                ],
+                [vx, vy, vz],
+            );
+        }
+        if data == 1 {
+            let at = [pos.x, pos.y, pos.z].map(|v| f64::from(v) + 0.5);
+            let pitch = self.world.random.next_float() * 0.1 + 0.9;
+            self.audio.play(
+                "minecraft:entity.dragon_fireball.explode",
+                Some(at),
+                1.0,
+                pitch,
+            );
+        }
+    }
+    /// `SpeleothemBlock.isStalactite`: a speleothem whose tip points down.
+    fn is_stalactite(&self, state: BlockStateId) -> bool {
+        self.res.facts().get(state).has_class("SpeleothemBlock")
+            && self
+                .pack
+                .assets
+                .registry
+                .state(state)
+                .and_then(|s| s.properties.get("vertical_direction"))
+                .is_some_and(|d| d == "down")
+    }
+    /// `LevelEventHandler` 1504: `PointedDripstoneBlock.spawnDripParticle` at
+    /// the tip `pos`. The fluid above the stalactite's root picks the drip;
+    /// with none, the dimension's default (lava in the Nether).
+    pub(super) fn dripstone_drip_particle(&mut self, pos: BlockPos) {
+        let tip_state = self.world.block(pos.x, pos.y, pos.z);
+        if !self.is_stalactite(tip_state) {
+            return;
+        }
+        // findRootBlock: up through the same stalactite, at most 11 steps.
+        let tip_name = self.res.facts().get(tip_state).name.clone();
+        let mut root = None;
+        for step in 1..11 {
+            let y = pos.y + step;
+            if !(horizon_client::chunk::MIN_Y
+                ..horizon_client::chunk::MIN_Y + horizon_client::chunk::HEIGHT)
+                .contains(&y)
+            {
+                break;
+            }
+            let state = self.world.block(pos.x, y, pos.z);
+            if self.res.facts().get(state).name != tip_name {
+                root = Some(y);
+                break;
+            }
+            if !self.is_stalactite(state) {
+                break;
+            }
+        }
+        let Some(root_y) = root else {
+            return;
+        };
+        let above = self.world.block(pos.x, root_y + 1, pos.z);
+        let above_facts = self.res.facts().get(above);
+        let nether = self.dim == super::Dim::Nether;
+        let fluid = if &*above_facts.name == "minecraft:mud" && !nether {
+            horizon_client::blocks::Fluid::Water
+        } else {
+            above_facts.fluid
+        };
+        let ty = match fluid {
+            horizon_client::blocks::Fluid::Water => ParticleType::DrippingDripstoneWater,
+            horizon_client::blocks::Fluid::Lava => ParticleType::DrippingDripstoneLava,
+            horizon_client::blocks::Fluid::None if nether => ParticleType::DrippingDripstoneLava,
+            horizon_client::blocks::Fluid::None => ParticleType::DrippingDripstoneWater,
+        };
+        let offset = self
+            .pack
+            .context
+            .tables
+            .offset(tip_state, pos.x, pos.z)
+            .unwrap_or([0.0; 3]);
+        // The tip shape starts 5/16 up; the particle sits a pixel below that.
+        self.particles.add(
+            &ParticleOptions::simple(ty),
+            [
+                f64::from(pos.x) + 0.5 + offset[0],
+                f64::from(pos.y) + 5.0 / 16.0 - 0.0625,
+                f64::from(pos.z) + 0.5 + offset[2],
+            ],
+            [0.0; 3],
+        );
+    }
     /// `ServerLevel.globalLevelEvent`: heard by every player on the server
     /// (an end portal opening, the dragon's death roar): here, and sent to
     /// every guest whatever their dimension.
diff --git a/crates/horizon-client/src/particles.rs b/crates/horizon-client/src/particles.rs
index fa9dc9c6e..3099069ba 100644
--- a/crates/horizon-client/src/particles.rs
+++ b/crates/horizon-client/src/particles.rs
@@ -751,6 +751,17 @@ fn next_double_between(random: &mut impl RandomSource, min: f64, max: f64) -> f6
 pub fn on_block_faces(
     random: &mut impl RandomSource,
     pos: [i32; 3],
+    emit: impl FnMut([f64; 3], [f64; 3]),
+) {
+    on_block_faces_between(random, pos, 3, 5, emit);
+}
+/// `ParticleUtils.spawnParticlesOnBlockFaces` with `UniformInt.of(min, max)`
+/// particles per face (3009 sniffer egg cracks use 3 to 6).
+pub fn on_block_faces_between(
+    random: &mut impl RandomSource,
+    pos: [i32; 3],
+    min: i32,
+    max: i32,
     mut emit: impl FnMut([f64; 3], [f64; 3]),
 ) {
     const FACES: [[i32; 3]; 6] = [
@@ -762,7 +773,7 @@ pub fn on_block_faces(
         [1, 0, 0],
     ];
     for face in FACES {
-        let count = random.next_int_bound(5 - 3 + 1).unwrap_or(0) + 3;
+        let count = random.next_int_bound(max - min + 1).unwrap_or(0) + min;
         for _ in 0..count {
             // getRandomSpeedRanges, then spawnParticleOnFace with step factor 0.55.
             let speed: [f64; 3] = std::array::from_fn(|_| next_double_between(random, -0.5, 0.5));

From 2e91bd84e9ee9f0ddbca7bd9e53bdc7edd9ca0f7 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:05:47 +0100
Subject: [PATCH 013/475] Send villager, taming, love, spawn poof and snowball
 entity events to server clients

Single player on the server thread drew these particles only into the server's own engine. The server now sends the entity event byte where vanilla does (20, 12/13/14, 6/7, 18 and 3), and the client draws it in handleEntityEvent's way.
---
 crates/horizon-client/src/game/allays.rs      |  2 +-
 crates/horizon-client/src/game/creatures.rs   | 47 ++++++++++---------
 crates/horizon-client/src/game/lan.rs         | 10 ++++
 crates/horizon-client/src/game/llamas.rs      |  6 +++
 crates/horizon-client/src/game/mounts.rs      | 21 ++++++---
 crates/horizon-client/src/game/nautili.rs     |  9 ++--
 crates/horizon-client/src/game/remote.rs      | 31 ++++++++++++
 crates/horizon-client/src/game/spawner.rs     | 11 ++++-
 crates/horizon-client/src/game/villagers.rs   | 35 ++++++++++----
 crates/horizon-client/src/mobs.rs             |  5 +-
 .../horizon-client/src/mobs/villager_brain.rs | 15 ++++--
 11 files changed, 145 insertions(+), 47 deletions(-)

diff --git a/crates/horizon-client/src/game/allays.rs b/crates/horizon-client/src/game/allays.rs
index bed835663..a1d2ba1df 100644
--- a/crates/horizon-client/src/game/allays.rs
+++ b/crates/horizon-client/src/game/allays.rs
@@ -160,7 +160,7 @@ impl Game<'_> {
             }
             // Allay.duplicateAllay: entity event 18, three spawnHeartParticle.
             let id = self.mobs[index].id;
-            self.particles_around_mob(id, "heart", horizon_client::particles::Burst::ALLAY);
+            self.mob_event_particles(id, 18);
             self.audio
                 .play("minecraft:block.amethyst_block.chime", Some(at), 2.0, 1.0);
             self.consume_held();
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 3a8562ee1..0d7b1f1bc 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1105,12 +1105,17 @@ impl Game<'_> {
                     }
                 }
                 MobEvent::AroundSelf {
+                    mob,
+                    event,
                     kind,
                     feet,
                     width,
                     height,
                     burst,
-                } => self.particles_around(kind, feet, [width, height], burst),
+                } => {
+                    self.lan_entity_event(mob as i32, event, feet);
+                    self.particles_around(kind, feet, [width, height], burst)
+                }
                 MobEvent::ParticleAt { kind, at, velocity } => {
                     if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) {
                         let options = horizon_client::particles::ParticleOptions::simple(ty);
@@ -1302,6 +1307,8 @@ impl Game<'_> {
             q.extra.in_love = 0;
         }
         let q = self.mobs.iter().find(|m| m.id == partner).cloned();
+        // Animal.finalizeSpawnChildFromBreeding: entity event 18 for the parent.
+        self.mob_event_particles(parent, 18);
         // Sniffer.spawnChildFromBreeding: an egg instead of a baby.
         if p.species() == Species::Sniffer {
             self.lay_sniffer_egg(&p);
@@ -2148,6 +2155,7 @@ impl Game<'_> {
                     };
                     m.damage(amount, source);
                 }
+                self.thrown_break_event(p.id, atp);
                 self.item_burst(atp, "minecraft:snowball");
             }
             (ProjectileKind::Egg, hit) => {
@@ -2173,6 +2181,7 @@ impl Game<'_> {
                         }
                     }
                 }
+                self.thrown_break_event(p.id, atp);
                 self.item_burst(atp, "minecraft:egg");
             }
             (ProjectileKind::EnderPearl, hit) => {
@@ -2402,10 +2411,17 @@ impl Game<'_> {
         }
         Ok(())
     }
+    /// `Snowball`/`ThrownEgg.onHit`: entity event 3 for the guests, before the
+    /// projectile is discarded (the clients lose it when the tracker next runs).
+    fn thrown_break_event(&mut self, id: u32, at: [f64; 3]) {
+        if id != 0 {
+            self.lan_entity_event(id as i32, 3, at);
+        }
+    }
     /// `Snowball`/`ThrownEgg.handleEntityEvent(3)`: eight crumbs of the
     /// thrown item where it broke, at rest for a snowball, scattered by the
     /// client entity's random (the particle engine's here) for an egg.
-    fn item_burst(&mut self, at: [f64; 3], item: &str) {
+    pub(super) fn item_burst(&mut self, at: [f64; 3], item: &str) {
         let options = self.item_particle(&horizon_client::items::ItemStack::new(item, 1));
         let egg = item != "minecraft:snowball";
         for _ in 0..8 {
@@ -2662,14 +2678,8 @@ impl Game<'_> {
                     m.ai.target = None;
                     m.extra.sitting = true;
                 }
-                // TamableAnimal.spawnTamingParticles.
-                let kind = if tamed { "heart" } else { "smoke" };
                 // TamableAnimal.spawnTamingParticles (entity event 7 or 6).
-                self.particles_around_mob(
-                    self.mobs[index].id,
-                    kind,
-                    horizon_client::particles::Burst::TAMING,
-                );
+                self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 });
                 if tamed {
                     let view = self.mob_entity(&self.mobs[index]);
                     self.trigger_entity("minecraft:tame_animal", "entity", &view);
@@ -2736,13 +2746,8 @@ impl Game<'_> {
                     m.extra.sitting = true;
                 }
                 eat = eating_sound(m, &mut self.world.random);
-                let kind = if tamed { "heart" } else { "smoke" };
                 // TamableAnimal.spawnTamingParticles (entity event 7 or 6).
-                self.particles_around_mob(
-                    self.mobs[index].id,
-                    kind,
-                    horizon_client::particles::Burst::TAMING,
-                );
+                self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 });
                 if tamed {
                     let view = self.mob_entity(&self.mobs[index]);
                     self.trigger_entity("minecraft:tame_animal", "entity", &view);
@@ -2779,13 +2784,8 @@ impl Game<'_> {
                     m.extra.tame = true;
                     m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1]));
                 }
-                let kind = if tamed { "heart" } else { "smoke" };
                 // TamableAnimal.spawnTamingParticles (entity event 7 or 6).
-                self.particles_around_mob(
-                    self.mobs[index].id,
-                    kind,
-                    horizon_client::particles::Burst::TAMING,
-                );
+                self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 });
                 if tamed {
                     let view = self.mob_entity(&self.mobs[index]);
                     self.trigger_entity("minecraft:tame_animal", "entity", &view);
@@ -2803,6 +2803,11 @@ impl Game<'_> {
                     Some(sound) => {
                         consume = true;
                         eat = sound;
+                        // Animal.setInLove: entity event 18 (a baby that
+                        // only grew is not in love).
+                        if self.mobs[index].extra.in_love > 0 {
+                            self.mob_event_particles(self.mobs[index].id, 18);
+                        }
                     }
                     // Animal.mobInteract still consumes the client click when
                     // an adult cannot breed, without swinging or taking food.
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 50fa222e6..0f946161f 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -913,6 +913,16 @@ impl Game<'_> {
                 m.needs_sync = false;
             }
             let entities = states.as_slice();
+            // An entity that left the level since the last tick (a snowball
+            // that hit) is dropped by the tracker below: its event goes out
+            // first, as `Level.broadcastEntityEvent` precedes the discard.
+            let (gone, later): (Vec<_>, Vec<_>) = std::mem::take(&mut self.lan_entity_events)
+                .into_iter()
+                .partition(|(id, ..)| !entities.iter().any(|e| e.id == *id));
+            self.lan_entity_events = later;
+            for (id, event, at) in gone {
+                host.hub.entity_event(id, event, at);
+            }
             let spawn = self.spawn.map_or([0.5, 80.0, 0.5], |s| [s.x, s.y, s.z]);
             let events = {
                 let clock_rate = self.network_clock_rate();
diff --git a/crates/horizon-client/src/game/llamas.rs b/crates/horizon-client/src/game/llamas.rs
index 1ce518f31..080343952 100644
--- a/crates/horizon-client/src/game/llamas.rs
+++ b/crates/horizon-client/src/game/llamas.rs
@@ -25,11 +25,13 @@ impl Game<'_> {
         };
         let m = &mut self.mobs[index];
         let mut used = false;
+        let mut loved = false;
         if item == "minecraft:hay_block" && m.extra.tame && m.extra.age == 0 && m.extra.in_love <= 0
         {
             m.extra.in_love = 600;
             m.extra.love_player = true;
             used = true;
+            loved = true;
         }
         if m.health < m.attrs.max_health {
             m.health = (m.health + heal).min(m.attrs.max_health);
@@ -57,6 +59,10 @@ impl Game<'_> {
         if !used {
             return false;
         }
+        // Animal.setInLove: entity event 18.
+        if loved {
+            self.mob_event_particles(self.mobs[index].id, 18);
+        }
         self.llama_sound(index, "entity.llama.eat", 1.0);
         self.consume_held();
         true
diff --git a/crates/horizon-client/src/game/mounts.rs b/crates/horizon-client/src/game/mounts.rs
index fa4bbc209..60c6d143c 100644
--- a/crates/horizon-client/src/game/mounts.rs
+++ b/crates/horizon-client/src/game/mounts.rs
@@ -215,10 +215,12 @@ impl Game<'_> {
             return false;
         }
         let mut used = false;
+        let mut loved = false;
         if love && m.extra.tame && m.extra.age == 0 && m.extra.in_love <= 0 {
             m.extra.in_love = 600;
             m.extra.love_player = true;
             used = true;
+            loved = true;
         }
         if m.health < m.attrs.max_health && heal > 0.0 {
             m.health = (m.health + heal).min(m.attrs.max_health);
@@ -238,6 +240,7 @@ impl Game<'_> {
         // eating(): the mouth opens and the horse eats.
         m.anim.v[2] = 1.0;
         let at = m.center();
+        let id = m.id;
         let sound = match m.species() {
             Species::Camel => "minecraft:entity.camel.eat",
             Species::CamelHusk => "minecraft:entity.camel_husk.eat",
@@ -247,6 +250,10 @@ impl Game<'_> {
         };
         let pitch = (self.world.random.next_float() - self.world.random.next_float()) * 0.2 + 1.0;
         self.audio.play(sound, Some(at), 1.0, pitch);
+        // Animal.setInLove: entity event 18.
+        if loved {
+            self.mob_event_particles(id, 18);
+        }
         self.consume_held();
         true
     }
@@ -452,14 +459,16 @@ impl Game<'_> {
                     m.extra.owner = owner;
                     m.persistent = true;
                     // AbstractHorse.tameWithName: entity event 7, spawnTamingParticles(true).
-                    self.particles_around_mob(
-                        mob,
-                        "heart",
-                        horizon_client::particles::Burst::TAMING,
-                    );
+                    self.mob_event_particles(mob, 7);
                 }
             }
-            MobEvent::Buck { mob } if self.riding == Some(mob) => self.dismount_mount(),
+            MobEvent::Buck { mob } => {
+                if self.riding == Some(mob) {
+                    self.dismount_mount();
+                }
+                // RunAroundLikeCrazyGoal.tick: entity event 6, smoke.
+                self.mob_event_particles(mob, 6);
+            }
             _ => {}
         }
     }
diff --git a/crates/horizon-client/src/game/nautili.rs b/crates/horizon-client/src/game/nautili.rs
index e7f16ca18..5e384db98 100644
--- a/crates/horizon-client/src/game/nautili.rs
+++ b/crates/horizon-client/src/game/nautili.rs
@@ -85,13 +85,8 @@ impl Game<'_> {
                     m.ai.target = None;
                 }
                 let sound = nautilus::eat_sound(m);
-                let kind = if tamed { "heart" } else { "smoke" };
                 // TamableAnimal.spawnTamingParticles (entity event 7 or 6).
-                self.particles_around_mob(
-                    self.mobs[index].id,
-                    kind,
-                    horizon_client::particles::Burst::TAMING,
-                );
+                self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 });
                 self.nautilus_sound(index, sound);
                 if tamed {
                     let view = self.mob_entity(&self.mobs[index]);
@@ -145,6 +140,8 @@ impl Game<'_> {
             let sound = nautilus::eat_sound(m);
             self.use_nautilus_food(item);
             self.nautilus_sound(index, sound);
+            // Animal.setInLove: entity event 18.
+            self.mob_event_particles(self.mobs[index].id, 18);
             return true;
         }
         false
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 5651647b7..2fe1a3344 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -2072,6 +2072,37 @@ impl Game<'_> {
                 if p.event == super::totem::TOTEM_EVENT {
                     self.remote_totem(p.id);
                 }
+                // Mob.handleEntityEvent 20: the spawn poof.
+                if p.event == 20 && self.mobs.iter().any(|m| m.id == p.id as u32) {
+                    self.poof_particles(p.id as u32);
+                }
+                // Villager 12, 13 and 14, TamableAnimal and AbstractHorse 6 and
+                // 7, Animal and Allay 18: the particles about the mob.
+                if matches!(p.event, 6 | 7 | 12 | 13 | 14 | 18) {
+                    self.entity_event_particles(p.id as u32, p.event);
+                }
+                // Snowball and ThrownEgg.handleEntityEvent 3: the crumbs where
+                // the projectile is (the server removes it right after).
+                if p.event == 3 {
+                    let crumbs = self
+                        .creatures
+                        .projectiles
+                        .iter()
+                        .find(|pr| pr.id == p.id as u32)
+                        .and_then(|pr| {
+                            let item = match pr.kind {
+                                horizon_client::projectiles::ProjectileKind::Snowball => {
+                                    "minecraft:snowball"
+                                }
+                                horizon_client::projectiles::ProjectileKind::Egg => "minecraft:egg",
+                                _ => return None,
+                            };
+                            Some(([pr.position.x, pr.position.y, pr.position.z], item))
+                        });
+                    if let Some((at, item)) = crumbs {
+                        self.item_burst(at, item);
+                    }
+                }
             }
             C::Animate(p) => self.remote_animate(p.id, p.action),
             // ClientPacketListener.handleSwingAnimation: the entity swings
diff --git a/crates/horizon-client/src/game/spawner.rs b/crates/horizon-client/src/game/spawner.rs
index 538cb39e7..f2835446f 100644
--- a/crates/horizon-client/src/game/spawner.rs
+++ b/crates/horizon-client/src/game/spawner.rs
@@ -257,8 +257,17 @@ impl Game<'_> {
         let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
             return;
         };
-        let (at, w, h) = (m.position, f64::from(m.width()), f64::from(m.height()));
+        let at = m.position;
         self.lan_entity_event(id as i32, 20, [at.x, at.y, at.z]);
+        self.poof_particles(id);
+    }
+    /// `Mob.handleEntityEvent` 20 (`spawnAnim` on a client): the poof about
+    /// mob `id`.
+    pub(super) fn poof_particles(&mut self, id: u32) {
+        let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
+            return;
+        };
+        let (at, w, h) = (m.position, f64::from(m.width()), f64::from(m.height()));
         let options = ParticleOptions::simple(ParticleType::Poof);
         for _ in 0..20 {
             let r = self.particles.level_random();
diff --git a/crates/horizon-client/src/game/villagers.rs b/crates/horizon-client/src/game/villagers.rs
index 3cfe8aa1d..092faaadf 100644
--- a/crates/horizon-client/src/game/villagers.rs
+++ b/crates/horizon-client/src/game/villagers.rs
@@ -116,7 +116,7 @@ impl Game<'_> {
             // VillagerMakeLove: entity event 13 for the partner, then the parent.
             for i in [ib, ia] {
                 let id = self.mobs[i].id;
-                self.villager_particles(id, "angry_villager");
+                self.mob_event_particles(id, 13);
             }
             return;
         };
@@ -141,12 +141,31 @@ impl Game<'_> {
             child.extra.bed = Some(bed);
         }
         // VillagerMakeLove.giveBirth: entity event 12 for the child.
-        self.villager_particles(id, "heart");
+        self.mob_event_particles(id, 12);
     }
-    /// `Villager.handleEntityEvent` 12, 13, 14 and 42:
-    /// `AbstractVillager.addParticlesAroundSelf`.
-    pub(super) fn villager_particles(&mut self, id: u32, kind: &'static str) {
-        self.particles_around_mob(id, kind, horizon_client::particles::Burst::VILLAGER);
+    /// `Level.broadcastEntityEvent` of an event whose `handleEntityEvent`
+    /// draws particles about the mob (villager 12, 13 and 14, taming 6 and 7,
+    /// love 18): the guests get the byte, and this game draws it as its own
+    /// client would.
+    pub(super) fn mob_event_particles(&mut self, id: u32, event: i8) {
+        let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
+            return;
+        };
+        let at = [m.position.x, m.position.y, m.position.z];
+        self.lan_entity_event(id as i32, event, at);
+        self.entity_event_particles(id, event);
+    }
+    /// `handleEntityEvent(event)`'s particles about mob `id`
+    /// (`Villager`, `TamableAnimal`, `AbstractHorse`, `Animal`, `Allay`).
+    pub(super) fn entity_event_particles(&mut self, id: u32, event: i8) {
+        let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
+            return;
+        };
+        if let Some((kind, burst)) =
+            horizon_client::particles::entity_event_burst(&m.kind.id, event as u8)
+        {
+            self.particles_around_mob(id, kind, burst);
+        }
     }
     /// `particles::around_self` about mob `id`.
     pub(super) fn particles_around_mob(
@@ -283,7 +302,7 @@ impl Game<'_> {
         }
         // Villager.setLastHurtByMob: entity event 13.
         for id in angry {
-            self.villager_particles(id, "angry_villager");
+            self.mob_event_particles(id, 13);
         }
     }
     /// `Villager.tellWitnessesThatIWasMurdered`: the villagers that saw a
@@ -338,7 +357,7 @@ impl Game<'_> {
             gossip::REPUTATION_CHANGE_PER_TRADE,
         );
         // Villager.customServerAiStep after a trade: entity event 14.
-        self.villager_particles(id, "happy_villager");
+        self.mob_event_particles(id, 14);
     }
     /// `Villager.getPlayerReputation` of the local player.
     pub(super) fn villager_reputation(&self, id: u32) -> i32 {
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..e8fa6eb91 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1011,8 +1011,11 @@ pub enum MobEvent {
         at: [f64; 3],
         count: u32,
     },
-    /// Client particles about a mob's box (`particles::around_self`).
+    /// Client particles about a mob's box (`particles::around_self`) and the
+    /// entity event `event` that shows them, sent for mob `mob`.
     AroundSelf {
+        mob: u32,
+        event: i8,
         kind: &'static str,
         feet: [f64; 3],
         width: f64,
diff --git a/crates/horizon-client/src/mobs/villager_brain.rs b/crates/horizon-client/src/mobs/villager_brain.rs
index 7b311a9e0..339318a06 100644
--- a/crates/horizon-client/src/mobs/villager_brain.rs
+++ b/crates/horizon-client/src/mobs/villager_brain.rs
@@ -2905,11 +2905,18 @@ impl B {
                         let mut bodies = Vec::new();
                         if let Some(t) = cx.w.target_info(target) {
                             let (min, max) = (t.bounds.min_position(), t.bounds.max_position());
-                            bodies.push((t.position, max.x - min.x, max.y - min.y));
+                            bodies.push((partner, t.position, max.x - min.x, max.y - min.y));
                         }
-                        bodies.push((m.position, f64::from(m.width()), f64::from(m.height())));
-                        for (feet, width, height) in bodies {
+                        bodies.push((
+                            m.id,
+                            m.position,
+                            f64::from(m.width()),
+                            f64::from(m.height()),
+                        ));
+                        for (mob, feet, width, height) in bodies {
                             cx.events.push(MobEvent::AroundSelf {
+                                mob,
+                                event: 12,
                                 kind: "heart",
                                 feet: [feet.x, feet.y, feet.z],
                                 width,
@@ -3580,6 +3587,8 @@ fn pois_scan_order(_m: &Mob, found: &[(Poi, [i32; 3])]) -> Vec<usize> {
 /// `AbstractVillager.addParticlesAroundSelf(HAPPY_VILLAGER)` on the client.
 fn happy_particles(m: &Mob, cx: &mut Bx) {
     cx.events.push(MobEvent::AroundSelf {
+        mob: m.id,
+        event: 14,
         kind: "happy_villager",
         feet: [m.position.x, m.position.y, m.position.z],
         width: f64::from(m.width()),

From 4825e537ccc51d123bcc0f97d777e3330a570f52 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:05:51 +0100
Subject: [PATCH 014/475] Tilt a server player's camera towards the hit

The server never sent ClientboundHurtAnimationPacket, and the client
ignored the yaw it carried, so a player on a server got the flash but the
camera never tilted towards where the hit came from.

ServerPlayer.indicateDamage now runs where the hit's knockback is dealt
(and with no direction for hits that have none), the packet goes out when
the guest's turn ends, and the client keeps the yaw as Player.hurtDir for
GameRenderer.bobHurt.
---
 crates/horizon-client/src/game/creatures.rs   |  4 +++
 crates/horizon-client/src/game/fov.rs         |  2 +-
 crates/horizon-client/src/game/lan_actions.rs |  7 +++++
 crates/horizon-client/src/game/remote.rs      |  3 ++-
 crates/horizon-client/src/health.rs           | 27 +++++++++++++++++++
 5 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 3a8562ee1..2f80be926 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1528,6 +1528,10 @@ impl Game<'_> {
             // hurt cooldown (a stronger hit there only adds its difference).
             if o.knockback {
                 let (xd, zd) = (from[0] - player.position.x, from[2] - player.position.z);
+                // dealDefaultKnockback's `indicateDamage`, unless blocked.
+                if o.blocked <= 0.0 {
+                    player.health.indicate_damage(xd, zd, player.yaw);
+                }
                 self.knock_back_player(f64::from(0.4_f32), xd, zd);
                 if let Some(p) = self.player.as_mut()
                     && let Some(r) = p.hurt_log.last_mut()
diff --git a/crates/horizon-client/src/game/fov.rs b/crates/horizon-client/src/game/fov.rs
index 95e2e1e6e..364f89189 100644
--- a/crates/horizon-client/src/game/fov.rs
+++ b/crates/horizon-client/src/game/fov.rs
@@ -114,7 +114,7 @@ impl Game<'_> {
             living: Some(HurtBob {
                 hurt_time: p.health.hurt_animation_time as f32 - partial,
                 hurt_duration: hurt.hurt_duration,
-                hurt_dir: 0.0,
+                hurt_dir: p.health.hurt_dir,
                 death_time: self.death_time().map(|t| t as f32 + partial),
             }),
             player: Some((
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index bbb0c37c0..e6869650b 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -650,6 +650,13 @@ impl Game<'_> {
                 g.sprinting = false;
             }
             m.sprinting = false;
+            // ServerPlayer.indicateDamage: the hit's direction to the player.
+            if let Some(yaw) = m.health.indicated_dir.take() {
+                g.send(&C::HurtAnimation(play::HurtAnimation {
+                    id: g.entity_id,
+                    yaw,
+                }));
+            }
             let teleported = std::mem::take(&mut m.teleported);
             let moved: f64 = (0..3).map(|k| (at[k] - g.position[k]).powi(2)).sum();
             g.motion = Some(Box::new(m));
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 5651647b7..c4571c3a9 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -2042,8 +2042,9 @@ impl Game<'_> {
             }
             C::HurtAnimation(p) => {
                 if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) {
+                    // Player.animateHurt: the tilt turns around the yaw.
                     if let Some(pl) = self.player.as_mut() {
-                        pl.health.animate_hurt();
+                        pl.health.animate_hurt_dir(p.yaw);
                     }
                 } else if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
                     m.hurt_time = 10;
diff --git a/crates/horizon-client/src/health.rs b/crates/horizon-client/src/health.rs
index 25c719bfb..b9670d065 100644
--- a/crates/horizon-client/src/health.rs
+++ b/crates/horizon-client/src/health.rs
@@ -163,6 +163,12 @@ pub struct PlayerHealth {
     pub hurt: State,
     /// Client hurt animation; fully blocked hits only refresh the server's hurt state.
     pub hurt_animation_time: i32,
+    /// `Player.hurtDir` on a client: the yaw `ClientboundHurtAnimationPacket`
+    /// gave, which `GameRenderer.bobHurt` tilts the camera around.
+    pub hurt_dir: f32,
+    /// `ServerPlayer.hurtDir` of a hit the player's client hasn't been told
+    /// of yet (`indicateDamage`).
+    pub indicated_dir: Option<f32>,
     pub dead: bool,
     pub sync_velocity: bool,
     pub game_time: i64,
@@ -213,6 +219,8 @@ impl PlayerHealth {
                 last_stamp: 0,
             },
             hurt_animation_time: 0,
+            hurt_dir: 0.0,
+            indicated_dir: None,
             dead: false,
             sync_velocity: false,
             game_time: 0,
@@ -260,6 +268,18 @@ impl PlayerHealth {
         self.hurt.hurt_time = 10;
         self.hurt_animation_time = 10;
     }
+    /// `LivingEntity.animateHurt(yaw)` on a player: the tilt restarts around
+    /// `yaw` (`Player.animateHurt` keeps it as `hurtDir`).
+    pub fn animate_hurt_dir(&mut self, yaw: f32) {
+        self.animate_hurt();
+        self.hurt_dir = yaw;
+    }
+    /// `ServerPlayer.indicateDamage`: the hit's direction relative to where
+    /// the player looks, kept for the packet to its client.
+    pub fn indicate_damage(&mut self, xd: f64, zd: f64, yaw: f32) {
+        use horizon_core::geometry::trig::{RAD_TO_DEG, atan2};
+        self.indicated_dir = Some((atan2(zd, xd) * f64::from(RAD_TO_DEG) - f64::from(yaw)) as f32);
+    }
     /// `LocalPlayer.hurtTo` with `flashOnSetHealth`: a drop below the current
     /// health starts the hurt animation; `damageCooldownTime` (20 on a drop,
     /// 10 on a gain) is what lets `Hud.extractPlayerHealth` blink the hearts.
@@ -348,6 +368,13 @@ impl PlayerMotion {
         if outcome.hurt {
             h.hurt_animation_time = h.hurt.hurt_time;
         }
+        // `dealDefaultKnockback` ends in `indicateDamage` unless blocked: a
+        // hit with no direction of its own (`xd` and `zd` zero) is sent as
+        // the opposite of the player's yaw. A hit that has a direction
+        // replaces this (`mob_hits_player`).
+        if outcome.knockback && outcome.blocked <= 0.0 {
+            h.indicate_damage(0.0, 0.0, self.yaw);
+        }
         let after = h.health() + h.absorption();
         if self.hurt_log.len() >= HURT_LOG {
             self.hurt_log.remove(0);

From 6bc8a8b8899fc5be2e6c03485db8b6b9b47ff05d Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:09:45 +0100
Subject: [PATCH 015/475] Send sweep, damage indicator and fishing particles to
 a server's players

Vanilla sends these with ServerLevel.sendParticles, so every player
nearby sees them. Horizon drew them only in the host window's own
particle engine, which a window on a server (and a guest next to the
host) never sees.

One helper now sends a ClientboundLevelParticlesPacket with the same
count, offset and speed to each player within 32 blocks. While the host
holds the players (a guest's turn, a host hit on a guest) the packet
waits and goes out when the tick ends.
---
 crates/horizon-client/src/game.rs             | 22 +++++--
 crates/horizon-client/src/game/creatures.rs   |  9 +++
 crates/horizon-client/src/game/fishing.rs     |  2 +
 crates/horizon-client/src/game/lan.rs         |  2 +
 .../horizon-client/src/game/lan_particles.rs  | 61 +++++++++++++++++++
 5 files changed, 90 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index cdbd72d7b..765354a0f 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -7455,13 +7455,15 @@ impl Game<'_> {
     }
     /// The visual and sound part of `Player.doSweepAttack` after a successful hit.
     pub(super) fn sweep_attack(&mut self, at: [f64; 3], from: Option<[f64; 3]>) {
-        self.particles.add(
-            &horizon_client::particles::ParticleOptions::simple(
-                horizon_client::particles::ParticleType::SweepAttack,
-            ),
-            at,
-            [0.0; 3],
+        let sweep = horizon_client::particles::ParticleOptions::simple(
+            horizon_client::particles::ParticleType::SweepAttack,
         );
+        self.particles.add(&sweep, at, [0.0; 3]);
+        // Player.sweepAttack's `sendParticles(SWEEP_ATTACK, ..., 0, dx, 0, dz, 0)`:
+        // the offset is the one from the player to the particle.
+        let origin = from.unwrap_or(at);
+        let spread = [at[0] - origin[0], 0.0, at[2] - origin[2]];
+        self.lan_send_particles(&sweep, at, spread, 0.0, 0);
         self.audio
             .play("minecraft:entity.player.attack.sweep", from, 1.0, 1.0);
     }
@@ -7625,6 +7627,14 @@ impl Game<'_> {
                     0.2,
                     (actual * 0.5) as u32,
                 );
+                // The players a server serves are sent them too.
+                self.lan_send_particles(
+                    &indicator,
+                    [feet[0], feet[1] + height * 0.5, feet[2]],
+                    [0.1, 0.0, 0.1],
+                    0.2,
+                    (actual * 0.5) as u32,
+                );
             }
             self.last_hurt_by_player
                 .insert(self.mobs[index].id, self.lan_acting);
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 3a8562ee1..2fd9f588c 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -49,6 +49,15 @@ pub(super) struct Creatures {
     pub elder_apparition: i32,
     /// The wandering trader spawner's clock.
     pub trader: super::wandering_trader::Spawner,
+    /// Particles from a guest's turn, waiting for it to end
+    /// (`lan_send_particles`: options, centre, spread, speed, count).
+    pub lan_particles: Vec<(
+        horizon_client::particles::ParticleOptions,
+        [f64; 3],
+        [f64; 3],
+        f64,
+        u32,
+    )>,
 }
 struct ProjWorld<'a, 'w> {
     w: &'a MobWorld<'w>,
diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs
index d454df406..b62822beb 100644
--- a/crates/horizon-client/src/game/fishing.rs
+++ b/crates/horizon-client/src/game/fishing.rs
@@ -416,6 +416,8 @@ impl Game<'_> {
         let options = ParticleOptions::simple(kind);
         self.particles
             .send_particles(&options, at, spread, speed, count);
+        // The players a server serves are sent them too.
+        self.lan_send_particles(&options, at, spread, speed, count);
     }
     /// `FishingHook.tick`.
     pub(super) fn tick_fishing(&mut self) {
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 50fa222e6..af89844c6 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -1046,6 +1046,8 @@ impl Game<'_> {
         self.lan = Some(host);
         // A mace's wind burst from a guest's attack.
         let _ = self.flush_wind_bursts();
+        // Particles a guest's turn sent (sweep attack, damage indicator, a hook's splashes).
+        self.flush_lan_particles();
     }
 
     fn lan_guest_joined(
diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs
index 0e35392bf..b1790686e 100644
--- a/crates/horizon-client/src/game/lan_particles.rs
+++ b/crates/horizon-client/src/game/lan_particles.rs
@@ -191,6 +191,67 @@ impl Game<'_> {
         }
     }
 
+    /// `ServerLevel.sendParticles` for the players a server serves: one
+    /// `ClientboundLevelParticlesPacket` to each player in the level whose
+    /// block is within 32 blocks of `at`. The window's own player is not
+    /// sent it (the caller draws it in this window). While the host holds
+    /// the players (a guest's turn through `as_guest`, a host's hit on a
+    /// guest) the packet waits for the turn to end so that it reaches every
+    /// player, the guest too.
+    pub(super) fn lan_send_particles(
+        &mut self,
+        options: &ParticleOptions,
+        at: [f64; 3],
+        spread: [f64; 3],
+        speed: f64,
+        count: u32,
+    ) {
+        if self.lan.is_none() {
+            // The server is running (its sounds are captured for the guests).
+            if self.audio.capture.is_some() {
+                self.creatures
+                    .lan_particles
+                    .push((options.clone(), at, spread, speed, count));
+            }
+            return;
+        }
+        let Some(particle) = self.network_particle(options, None) else {
+            return;
+        };
+        let Some(host) = self.lan.as_ref() else {
+            return;
+        };
+        let body = C::LevelParticles(play::LevelParticles {
+            particle,
+            override_limiter: false,
+            always_show: false,
+            pos: at,
+            dist: spread.map(|d| d as f32),
+            max_speed: [speed as f32; 3],
+            count: count as i32,
+            randomization: 0,
+        })
+        .encode();
+        for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) {
+            // BlockPos.closerToCenterThan(at, 32): from the centre of the
+            // player's block.
+            let d: f64 = (0..3)
+                .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2))
+                .sum();
+            if d < 32.0 * 32.0 {
+                g.sender.send(body.clone());
+            }
+        }
+    }
+
+    /// The particles guests' turns put off.
+    pub(super) fn flush_lan_particles(&mut self) {
+        for (options, at, spread, speed, count) in std::mem::take(&mut self.creatures.lan_particles)
+        {
+            self.lan_send_particles(&options, at, spread, speed, count);
+        }
+    }
+
     /// `ServerLevel.explode`'s packet to each player within 64 blocks. The
     /// sound and the push reach them on their own (the level's sounds, the
     /// motion a hurt player is sent), so the packet carries neither.

From 8697f3fd3f91a8e6f48d5ca19882413b7a55ba2b Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:13:32 +0100
Subject: [PATCH 016/475] Furnaces: drying a wet sponge fills the bucket in the
 fuel slot

---
 crates/horizon-client/src/containers.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs
index d13c5e45b..b0e034e5b 100644
--- a/crates/horizon-client/src/containers.rs
+++ b/crates/horizon-client/src/containers.rs
@@ -639,6 +639,18 @@ impl Furnace {
                                     None => self.items[2] = Some(recipe.result.clone()),
                                 }
                                 *self.recipes_used.entry(recipe.id.clone()).or_insert(0) += 1;
+                                // AbstractFurnaceBlockEntity.burn: drying a wet sponge fills
+                                // the bucket in the fuel slot.
+                                if self.items[0]
+                                    .as_ref()
+                                    .is_some_and(|i| &*i.item == "minecraft:wet_sponge")
+                                    && self.items[1]
+                                        .as_ref()
+                                        .is_some_and(|f| &*f.item == "minecraft:bucket")
+                                {
+                                    self.items[1] =
+                                        Some(ItemStack::new("minecraft:water_bucket", 1));
+                                }
                                 if let Some(i) = self.items[0].as_mut() {
                                     i.count -= 1;
                                     if i.count == 0 {

From 2f6f0e3e0f22c91d1cf7205563e2574d75d6f570 Mon Sep 17 00:00:00 2001
From: Joansitoh <joan.programas@gmail.com>
Date: Mon, 26 Oct 2026 13:16:35 +0100
Subject: [PATCH 017/475] Launcher: Game arguments edits at the caret

The field only appended and popped the last character, and Space typed
nothing on Windows (it arrives without a character). A shared one-line
field, launcher/src/line_edit.rs, now holds the text, caret, selection
and undo history: arrows, Home/End, Ctrl+arrows by word, Shift to select,
mouse click, drag, double and triple click, Ctrl+A/C/X/V and Ctrl+Z / Ctrl+Y.
---
 launcher/src/line_edit.rs | 672 ++++++++++++++++++++++++++++++++++++++
 launcher/src/main.rs      |  53 ++-
 2 files changed, 692 insertions(+), 33 deletions(-)
 create mode 100644 launcher/src/line_edit.rs

diff --git a/launcher/src/line_edit.rs b/launcher/src/line_edit.rs
new file mode 100644
index 000000000..0647f5861
--- /dev/null
+++ b/launcher/src/line_edit.rs
@@ -0,0 +1,672 @@
+//! The one-line text field every launcher input shares: the state (text, caret, selection,
+//! undo), the keyboard (`handle`) and what it draws (`content`). A page keeps its own box and
+//! its Enter/Escape; this is what is inside it. Positions count characters, not bytes.
+
+use super::*;
+use gpui::{
+    black, canvas, Bounds, Font, MouseButton, MouseDownEvent, MouseMoveEvent, Pixels, Point,
+    TextRun,
+};
+use std::{cell::RefCell, rc::Rc};
+
+/// What a key did to the field.
+#[derive(Debug, PartialEq)]
+pub(super) enum Key {
+    Enter,
+    Escape,
+    /// Not the field's: Tab (focus), shortcuts.
+    Pass,
+    /// The caret or the selection moved; the text is the same.
+    Moved,
+    /// The text changed.
+    Edited,
+    /// Ctrl/Cmd-V: `handle` inserts the clipboard's first line.
+    Paste,
+    /// Ctrl/Cmd-C: `handle` puts this on the clipboard.
+    Copy(String),
+    /// Ctrl/Cmd-X: the text changed; `handle` puts this on the clipboard.
+    Cut(String),
+}
+
+/// What the last edit was, so a run of typing undoes as one step.
+#[derive(Clone, Copy, PartialEq)]
+enum Run {
+    None,
+    Typing,
+    Deleting,
+    Other,
+}
+
+/// Where the text was drawn last frame, and how: what turns a mouse position into a character.
+struct Area {
+    bounds: Bounds<Pixels>,
+    font: Font,
+    size: Pixels,
+    mask: bool,
+}
+
+struct Snap {
+    text: String,
+    caret: usize,
+}
+
+pub(super) struct LineEdit {
+    text: String,
+    caret: usize,
+    /// The other end of the selection; equal to `caret` when nothing is selected.
+    anchor: usize,
+    scroll: usize,
+    max: usize,
+    /// How many characters the box shows.
+    visible: usize,
+    undo: Vec<Snap>,
+    redo: Vec<Snap>,
+    run: Run,
+    area: Rc<RefCell<Option<Area>>>,
+    /// A drag that started in this field is on.
+    dragging: bool,
+}
+
+const HISTORY: usize = 100;
+
+impl LineEdit {
+    pub(super) fn new(text: String, max: usize, visible: usize) -> Self {
+        let caret = text.chars().count();
+        let mut e = LineEdit {
+            text,
+            caret,
+            anchor: caret,
+            scroll: 0,
+            max,
+            visible,
+            undo: Vec::new(),
+            redo: Vec::new(),
+            run: Run::None,
+            area: Rc::default(),
+            dragging: false,
+        };
+        e.reveal();
+        e
+    }
+
+    pub(super) fn text(&self) -> &str {
+        &self.text
+    }
+
+    pub(super) fn select_all(&mut self) {
+        self.anchor = 0;
+        self.caret = self.len();
+    }
+
+    /// The character under `pos`, from where the text was drawn last frame.
+    fn index_at(&self, window: &Window, pos: Point<Pixels>) -> Option<usize> {
+        let area = self.area.borrow();
+        let a = area.as_ref()?;
+        let shown: String = self
+            .text
+            .chars()
+            .skip(self.scroll)
+            .take(self.visible)
+            .collect();
+        let shown = if a.mask {
+            "•".repeat(shown.chars().count())
+        } else {
+            shown
+        };
+        let run = TextRun {
+            len: shown.len(),
+            font: a.font.clone(),
+            color: black(),
+            background_color: None,
+            underline: None,
+            strikethrough: None,
+        };
+        let line = window
+            .text_system()
+            .shape_line(shown.clone().into(), a.size, &[run], None);
+        let at = line
+            .closest_index_for_x(pos.x - a.bounds.origin.x)
+            .min(shown.len());
+        Some(self.scroll + shown[..at].chars().count())
+    }
+
+    fn select_word(&mut self, at: usize) {
+        self.anchor = self.word(at, false);
+        self.caret = self.word(at, true).max(self.anchor);
+        self.run = Run::None;
+    }
+
+    fn len(&self) -> usize {
+        self.text.chars().count()
+    }
+
+    fn byte(&self, at: usize) -> usize {
+        self.text
+            .char_indices()
+            .nth(at)
+            .map_or(self.text.len(), |(i, _)| i)
+    }
+
+    fn range(&self) -> (usize, usize) {
+        (self.caret.min(self.anchor), self.caret.max(self.anchor))
+    }
+
+    fn selected(&self) -> String {
+        let (lo, hi) = self.range();
+        self.text.chars().skip(lo).take(hi - lo).collect()
+    }
+
+    fn snap(&self) -> Snap {
+        Snap {
+            text: self.text.clone(),
+            caret: self.caret,
+        }
+    }
+
+    /// Runs an edit and remembers the text it replaced for undo, unless it changed nothing
+    /// (typing a "t" over a selected "t") or continues a run. A run of typing is one step per
+    /// word: `split` starts a new one.
+    fn edit(&mut self, run: Run, split: bool, f: impl FnOnce(&mut Self)) {
+        let prev = self.snap();
+        let prev_run = self.run;
+        f(self);
+        if self.text == prev.text {
+            self.run = prev_run;
+            return;
+        }
+        if run == Run::Other || run != prev_run || split {
+            if self.undo.len() == HISTORY {
+                self.undo.remove(0);
+            }
+            self.undo.push(prev);
+        }
+        self.redo.clear();
+        self.run = run;
+    }
+
+    fn restore(&mut self, s: Snap) {
+        self.text = s.text;
+        self.caret = s.caret;
+        self.anchor = s.caret;
+        self.run = Run::None;
+    }
+
+    fn undo(&mut self) {
+        if let Some(s) = self.undo.pop() {
+            self.redo.push(self.snap());
+            self.restore(s);
+        }
+    }
+
+    fn redo(&mut self) {
+        if let Some(s) = self.redo.pop() {
+            self.undo.push(self.snap());
+            self.restore(s);
+        }
+    }
+
+    fn delete_selection(&mut self) -> bool {
+        let (lo, hi) = self.range();
+        if lo == hi {
+            return false;
+        }
+        self.text.replace_range(self.byte(lo)..self.byte(hi), "");
+        self.caret = lo;
+        self.anchor = lo;
+        true
+    }
+
+    fn put(&mut self, s: &str) {
+        self.delete_selection();
+        let room = self.max.saturating_sub(self.len());
+        let s: String = s.chars().filter(|c| !c.is_control()).take(room).collect();
+        self.text.insert_str(self.byte(self.caret), &s);
+        self.caret += s.chars().count();
+        self.anchor = self.caret;
+    }
+
+    /// Replaces the selection with `s` (control characters dropped), up to the length limit.
+    pub(super) fn insert(&mut self, s: &str) {
+        self.edit(Run::Other, false, |e| e.put(s));
+        self.reveal();
+    }
+
+    fn move_to(&mut self, at: usize, extend: bool) {
+        self.caret = at.min(self.len());
+        if !extend {
+            self.anchor = self.caret;
+        }
+        self.run = Run::None;
+    }
+
+    /// The start of the word before `from`, or the end of the one after it.
+    fn word(&self, from: usize, forward: bool) -> usize {
+        let chars: Vec<char> = self.text.chars().collect();
+        let mut i = from;
+        if forward {
+            while i < chars.len() && chars[i].is_whitespace() {
+                i += 1;
+            }
+            while i < chars.len() && !chars[i].is_whitespace() {
+                i += 1;
+            }
+        } else {
+            while i > 0 && chars[i - 1].is_whitespace() {
+                i -= 1;
+            }
+            while i > 0 && !chars[i - 1].is_whitespace() {
+                i -= 1;
+            }
+        }
+        i
+    }
+
+    /// Applies a key press. `command` is Ctrl, or Cmd on macOS.
+    pub(super) fn key(
+        &mut self,
+        key: &str,
+        key_char: Option<&str>,
+        command: bool,
+        shift: bool,
+    ) -> Key {
+        let (lo, hi) = self.range();
+        let out = match key {
+            "enter" => Key::Enter,
+            "escape" => Key::Escape,
+            "left" if !shift && lo != hi && !command => {
+                self.move_to(lo, false);
+                Key::Moved
+            }
+            "right" if !shift && lo != hi && !command => {
+                self.move_to(hi, false);
+                Key::Moved
+            }
+            "left" => {
+                let to = if command {
+                    self.word(self.caret, false)
+                } else {
+                    self.caret.saturating_sub(1)
+                };
+                self.move_to(to, shift);
+                Key::Moved
+            }
+            "right" => {
+                let to = if command {
+                    self.word(self.caret, true)
+                } else {
+                    self.caret + 1
+                };
+                self.move_to(to, shift);
+                Key::Moved
+            }
+            "home" => {
+                self.move_to(0, shift);
+                Key::Moved
+            }
+            "end" => {
+                self.move_to(self.len(), shift);
+                Key::Moved
+            }
+            "backspace" | "delete" => {
+                let run = if lo == hi { Run::Deleting } else { Run::Other };
+                self.edit(run, false, |e| {
+                    if !e.delete_selection() {
+                        let (from, to) = match (key, command) {
+                            ("backspace", false) => (e.caret.saturating_sub(1), e.caret),
+                            ("backspace", true) => (e.word(e.caret, false), e.caret),
+                            (_, false) => (e.caret, (e.caret + 1).min(e.len())),
+                            (_, true) => (e.caret, e.word(e.caret, true)),
+                        };
+                        e.anchor = from;
+                        e.caret = to;
+                        e.delete_selection();
+                    }
+                });
+                Key::Edited
+            }
+            "a" if command => {
+                self.select_all();
+                self.run = Run::None;
+                Key::Moved
+            }
+            "z" if command && shift => {
+                self.redo();
+                Key::Edited
+            }
+            "z" if command => {
+                self.undo();
+                Key::Edited
+            }
+            "y" if command => {
+                self.redo();
+                Key::Edited
+            }
+            "c" if command => Key::Copy(self.selected()),
+            "x" if command => {
+                let cut = self.selected();
+                self.edit(Run::Other, false, |e| {
+                    e.delete_selection();
+                });
+                Key::Cut(cut)
+            }
+            "v" if command => Key::Paste,
+            _ if command => Key::Pass,
+            // Not every platform gives Space a character.
+            "space" => {
+                let run = if lo == hi { Run::Typing } else { Run::Other };
+                self.edit(run, false, |e| e.put(" "));
+                Key::Edited
+            }
+            _ => match key_char {
+                Some(ch) if !ch.is_empty() && !ch.chars().any(char::is_control) => {
+                    let starts_word = !ch.starts_with(char::is_whitespace)
+                        && self
+                            .text
+                            .chars()
+                            .nth(self.caret.wrapping_sub(1))
+                            .is_some_and(char::is_whitespace);
+                    let run = if lo == hi { Run::Typing } else { Run::Other };
+                    self.edit(run, starts_word, |e| e.put(ch));
+                    Key::Edited
+                }
+                _ => Key::Pass,
+            },
+        };
+        self.reveal();
+        out
+    }
+
+    /// Scrolls the field so the caret shows.
+    fn reveal(&mut self) {
+        if self.caret < self.scroll {
+            self.scroll = self.caret;
+        } else if self.caret > self.scroll + self.visible {
+            self.scroll = self.caret - self.visible;
+        }
+    }
+
+    /// What shows: the text before the selection, the selection, the text after, and whether the
+    /// caret sits before the selection (otherwise after it). `whole` shows all of it selected.
+    fn view(&self, whole: bool) -> (String, String, String, bool) {
+        let (lo, hi) = if whole { (0, self.len()) } else { self.range() };
+        let end = self.scroll + self.visible;
+        let part = |a: usize, b: usize| -> String {
+            let (a, b) = (a.max(self.scroll), b.min(end));
+            self.text
+                .chars()
+                .skip(a)
+                .take(b.saturating_sub(a))
+                .collect()
+        };
+        (
+            part(0, lo),
+            part(lo, hi),
+            part(hi, usize::MAX),
+            self.caret == lo,
+        )
+    }
+}
+
+/// The keyboard in a field: moves the caret, edits, copies and pastes. Never returns Paste, Copy
+/// or Cut (they are done); Enter, Escape and Pass are the page's.
+pub(super) fn handle(edit: &mut LineEdit, ev: &KeyDownEvent, cx: &mut App) -> Key {
+    let k = &ev.keystroke;
+    let command = k.modifiers.control || k.modifiers.platform;
+    match edit.key(&k.key, k.key_char.as_deref(), command, k.modifiers.shift) {
+        Key::Paste => {
+            if let Some(text) = cx.read_from_clipboard().and_then(|c| c.text()) {
+                edit.insert(text.lines().next().unwrap_or_default().trim());
+            }
+            Key::Edited
+        }
+        Key::Copy(s) => {
+            cx.write_to_clipboard(gpui::ClipboardItem::new_string(s));
+            Key::Moved
+        }
+        Key::Cut(s) => {
+            cx.write_to_clipboard(gpui::ClipboardItem::new_string(s));
+            Key::Edited
+        }
+        other => other,
+    }
+}
+
+/// Puts mouse handling on a field's box: a click puts the caret in (Shift extends the selection),
+/// a drag selects, a double click selects a word and a triple click the line.
+pub(super) fn mouse<T: 'static, E: InteractiveElement>(
+    el: E,
+    cx: &mut Context<T>,
+    edit: impl Fn(&mut T) -> &mut LineEdit + Clone + 'static,
+) -> E {
+    let get = edit.clone();
+    el.on_mouse_down(
+        MouseButton::Left,
+        cx.listener(move |this, ev: &MouseDownEvent, window, cx| {
+            let e = get(this);
+            if let Some(at) = e.index_at(window, ev.position) {
+                match ev.click_count {
+                    1 => e.move_to(at, ev.modifiers.shift),
+                    2 => e.select_word(at),
+                    _ => e.select_all(),
+                }
+                e.dragging = true;
+                cx.notify();
+            }
+        }),
+    )
+    .on_mouse_move(cx.listener(move |this, ev: &MouseMoveEvent, window, cx| {
+        let e = edit(this);
+        if !ev.dragging() {
+            e.dragging = false;
+        } else if e.dragging {
+            if let Some(at) = e.index_at(window, ev.position) {
+                e.move_to(at, true);
+                cx.notify();
+            }
+        }
+    }))
+}
+
+/// What a field draws inside its box: the placeholder while empty and unfocused, else the text
+/// with its selection and caret. `mask` shows dots (a token); `whole` shows all selected.
+pub(super) fn content(
+    edit: &LineEdit,
+    t: &theme::Theme,
+    focused: bool,
+    whole: bool,
+    mask: bool,
+    placeholder: &'static str,
+) -> Div {
+    if edit.text.is_empty() && !focused {
+        return div().text_color(t.muted).child(placeholder);
+    }
+    let (before, selected, after, caret_first) = edit.view(whole);
+    let text = |s: String| {
+        let s = if mask {
+            "•".repeat(s.chars().count())
+        } else {
+            s
+        };
+        div().flex_none().whitespace_nowrap().child(s)
+    };
+    let caret = || div().flex_none().w(px(1.)).h(px(14.)).bg(t.ink);
+    let area = edit.area.clone();
+    div()
+        .relative()
+        .flex()
+        .items_center()
+        .text_color(t.ink)
+        .child(text(before))
+        .when(focused && caret_first, |d| d.child(caret()))
+        .when(!selected.is_empty(), |d| {
+            d.child(
+                text(selected)
+                    .rounded(px(2.))
+                    .bg(t.accent.opacity(theme::SELECTION)),
+            )
+        })
+        .when(focused && !caret_first, |d| d.child(caret()))
+        .child(text(after))
+        .child(
+            // Records where the text sits and in what font, for the mouse.
+            canvas(
+                move |bounds, window, _| {
+                    let style = window.text_style();
+                    *area.borrow_mut() = Some(Area {
+                        bounds,
+                        font: style.font(),
+                        size: style.font_size.to_pixels(window.rem_size()),
+                        mask,
+                    });
+                },
+                |_, _, _, _| {},
+            )
+            .absolute()
+            .size_full(),
+        )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn edit(text: &str) -> LineEdit {
+        LineEdit::new(text.into(), 1024, 38)
+    }
+
+    fn typed(e: &mut LineEdit, s: &str) {
+        for c in s.chars() {
+            let key = if c == ' ' { "space" } else { "x" };
+            let ch = c.to_string();
+            e.key(key, (c != ' ').then_some(ch.as_str()), false, false);
+        }
+    }
+
+    #[test]
+    fn spaces_type_and_the_caret_moves_and_edits_in_the_middle() {
+        let mut e = edit("");
+        typed(&mut e, "--name Steve");
+        assert_eq!(e.text(), "--name Steve");
+        for _ in 0..5 {
+            e.key("left", None, false, false);
+        }
+        typed(&mut e, "X");
+        assert_eq!(e.text(), "--name XSteve");
+        e.key("backspace", None, false, false);
+        e.key("delete", None, false, false);
+        assert_eq!(e.text(), "--name teve");
+        e.key("home", None, false, false);
+        e.key("delete", None, false, false);
+        assert_eq!(e.text(), "-name teve");
+    }
+
+    #[test]
+    fn undo_steps_back_a_run_at_a_time_and_redo_returns() {
+        let mut e = edit("");
+        typed(&mut e, "--name Steve");
+        e.key("home", None, false, false);
+        e.key("delete", None, false, false);
+        e.key("delete", None, false, false);
+        assert_eq!(e.text(), "name Steve");
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "--name Steve");
+        // Typing undoes a word at a time.
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "--name ");
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "");
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "");
+        e.key("y", None, true, false);
+        assert_eq!(e.text(), "--name ");
+        e.key("y", None, true, false);
+        assert_eq!(e.text(), "--name Steve");
+        e.key("z", None, true, false);
+        e.key("z", None, true, true);
+        assert_eq!(e.text(), "--name Steve");
+        // A paste is a step of its own, and typing after an undo drops the redo.
+        e.key("end", None, false, false);
+        e.insert("!");
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "--name Steve");
+        typed(&mut e, "?");
+        e.key("y", None, true, false);
+        assert_eq!(e.text(), "--name Steve?");
+    }
+
+    #[test]
+    fn selection_is_replaced_copied_and_cut() {
+        let mut e = edit("--name Steve");
+        e.key("a", None, true, false);
+        assert_eq!(
+            e.key("c", None, true, false),
+            Key::Copy("--name Steve".into())
+        );
+        e.key("home", None, false, false);
+        for _ in 0..2 {
+            e.key("right", None, false, true);
+        }
+        assert_eq!(e.key("x", None, true, false), Key::Cut("--".into()));
+        assert_eq!(e.text(), "name Steve");
+        e.key("a", None, true, false);
+        e.key("y", Some("y"), false, false);
+        assert_eq!(e.text(), "y");
+        e.insert("a\nb c");
+        assert_eq!(e.text(), "yab c");
+    }
+
+    #[test]
+    fn words_and_the_length_limit() {
+        let mut e = edit("one two three");
+        e.key("backspace", None, true, false);
+        assert_eq!(e.text(), "one two ");
+        e.key("left", None, true, false);
+        e.key("delete", None, true, false);
+        assert_eq!(e.text(), "one  ");
+        let mut e = LineEdit::new("abc".into(), 4, 38);
+        e.insert("defg");
+        assert_eq!(e.text(), "abcd");
+        assert_eq!(e.key("tab", None, false, false), Key::Pass);
+        assert_eq!(e.key("q", None, true, false), Key::Pass);
+        assert_eq!(e.key("enter", Some("\n"), false, false), Key::Enter);
+        assert_eq!(e.key("escape", None, false, false), Key::Escape);
+    }
+
+    #[test]
+    fn an_edit_that_changes_nothing_is_not_an_undo_step() {
+        let mut e = edit("test");
+        e.key("left", None, false, false);
+        e.key("end", None, false, false);
+        e.key("left", None, false, true);
+        e.key("t", Some("t"), false, false);
+        assert_eq!(e.text(), "test");
+        e.key("delete", None, false, false);
+        e.key("home", None, false, false);
+        e.key("backspace", None, false, false);
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "test");
+        e.insert("");
+        e.key("x", Some("x"), false, false);
+        assert_eq!(e.text(), "xtest");
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "test");
+    }
+
+    #[test]
+    fn a_selected_text_is_replaced_by_what_is_typed() {
+        let mut e = edit("My server");
+        e.select_all();
+        e.key("f", Some("F"), false, false);
+        assert_eq!(e.text(), "F");
+    }
+
+    #[test]
+    fn the_view_follows_the_caret() {
+        let mut e = edit(&"é".repeat(100));
+        let (before, sel, after, _) = e.view(false);
+        assert_eq!((before.chars().count(), sel.len(), after.len()), (38, 0, 0));
+        e.key("home", None, false, false);
+        assert_eq!(e.view(false).2.chars().count(), 38);
+        assert_eq!(e.view(true).1.chars().count(), 38);
+    }
+}
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 7d778b6b9..0632a51ca 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -13,6 +13,7 @@ mod console;
 mod cull;
 mod game_tools;
 mod internet;
+mod line_edit;
 mod markdown;
 mod mcp;
 mod modpacks_page;
@@ -183,7 +184,7 @@ struct Launcher {
     friend_focus: FocusHandle,
     joining: Option<String>,
     /// Settings' Game arguments field: the line, whether it has focus, and its focus handle.
-    args_input: String,
+    args_input: line_edit::LineEdit,
     args_focused: bool,
     args_focus: FocusHandle,
     /// Opt-in data collection: the player's answer and Settings' section (`collection`).
@@ -298,7 +299,7 @@ impl Launcher {
             install_error: None,
             confirm_remove: None,
             picker_open: false,
-            args_input: settings.game_args.clone(),
+            args_input: line_edit::LineEdit::new(settings.game_args.clone(), 1024, 38),
             args_focused: false,
             args_focus: cx.focus_handle(),
             settings,
@@ -2615,46 +2616,32 @@ impl Launcher {
             .font_family(theme::MONO)
             .text_size(px(12.))
             .cursor_text()
-            .child(if self.args_input.is_empty() && !focused {
-                div()
-                    .text_color(t.muted)
-                    .child("For example --server-thread")
-            } else {
-                // The end of a long line stays in view while typing.
-                let chars: Vec<char> = self.args_input.chars().collect();
-                let shown: String = chars[chars.len().saturating_sub(44)..].iter().collect();
-                div().text_color(t.ink).child(shown)
-            })
-            .when(focused, |d| d.child(div().w(px(1.)).h(px(14.)).bg(t.ink)))
+            .child(line_edit::content(
+                &self.args_input,
+                &t,
+                focused,
+                false,
+                false,
+                "For example --server-thread",
+            ))
             .on_click(cx.listener(|this, _: &ClickEvent, window, cx| {
                 window.focus(&this.args_focus);
                 cx.notify();
             }))
-            .on_key_down(cx.listener(|this, ev: &KeyDownEvent, _, cx| {
-                let k = &ev.keystroke;
-                let paste = k.key == "v" && (k.modifiers.control || k.modifiers.platform);
-                match k.key.as_str() {
-                    "backspace" => {
-                        this.args_input.pop();
+            .on_key_down(cx.listener(|this, ev: &KeyDownEvent, window, cx| {
+                match line_edit::handle(&mut this.args_input, ev, cx) {
+                    line_edit::Key::Pass => return,
+                    line_edit::Key::Escape => window.blur(),
+                    line_edit::Key::Edited => {
+                        this.settings.game_args = this.args_input.text().to_string();
+                        this.settings.save();
                     }
-                    _ if paste => {
-                        if let Some(text) = cx.read_from_clipboard().and_then(|c| c.text()) {
-                            this.args_input.push_str(text.trim());
-                        }
-                    }
-                    _ if !k.modifiers.control && !k.modifiers.platform => {
-                        if let Some(ch) = &k.key_char {
-                            this.args_input.push_str(ch);
-                        }
-                    }
-                    _ => return,
+                    _ => {}
                 }
-                this.args_input.truncate(1024);
-                this.settings.game_args = this.args_input.clone();
-                this.settings.save();
                 cx.stop_propagation();
                 cx.notify();
             }));
+        let field = line_edit::mouse(field, cx, |this| &mut this.args_input);
         index_row(
             n,
             "Game arguments",

From e2781f7939dfb4451f356a60d6513e25a4a271fa Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:20:35 +0100
Subject: [PATCH 018/475] Apply suspicious stew effects when the stew is eaten

---
 crates/horizon-client/src/game/consume.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/crates/horizon-client/src/game/consume.rs b/crates/horizon-client/src/game/consume.rs
index 93d919911..37d27eeb8 100644
--- a/crates/horizon-client/src/game/consume.rs
+++ b/crates/horizon-client/src/game/consume.rs
@@ -57,6 +57,17 @@ impl Game<'_> {
             self.audio
                 .play("minecraft:entity.player.burp", self.feet(), 0.5, pitch);
         }
+        // SuspiciousStewEffects.onConsume, a ConsumableListener: each entry is
+        // added as a `MobEffectInstance(effect, duration)` (amplifier 0).
+        if let Some(data) = stack.extra.as_deref() {
+            for (id, duration) in &data.stew_effects {
+                if let Some(def) = horizon_client::brewing::effect(id) {
+                    self.add_player_effect(horizon_client::effects::EffectInstance::new(
+                        def.id, *duration, 0,
+                    ));
+                }
+            }
+        }
         for effect in &consumable.effects {
             self.apply_consume_effect(effect);
         }

From 30fa41ddbd4e85258e36a00f75e692976b7f3775 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:20:37 +0100
Subject: [PATCH 019/475] Make the fall, drowning, fire and freeze damage game
 rules work

---
 .../examples/probe/scene_motion_probe.rs      |  1 +
 crates/horizon-client/src/game/chat.rs        |  5 +++++
 crates/horizon-client/src/health.rs           | 19 +++++++++++++++++--
 3 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/examples/probe/scene_motion_probe.rs b/crates/horizon-client/examples/probe/scene_motion_probe.rs
index 21977eeab..523bd28a4 100644
--- a/crates/horizon-client/examples/probe/scene_motion_probe.rs
+++ b/crates/horizon-client/examples/probe/scene_motion_probe.rs
@@ -351,6 +351,7 @@ pub fn main() -> Result<()> {
                             horizon_world::food::Difficulty::Hard,
                         ][op["difficulty"].as_u64().unwrap() as usize],
                         natural_regeneration: op["regenerate"].as_bool().unwrap(),
+                        ..Default::default()
                     };
                 }
                 "food" => {
diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs
index 5d3919c8b..e19e3669f 100644
--- a/crates/horizon-client/src/game/chat.rs
+++ b/crates/horizon-client/src/game/chat.rs
@@ -763,6 +763,11 @@ impl Game<'_> {
     pub(super) fn sync_rules(&mut self) {
         self.world.health_rules.natural_regeneration =
             self.ui.rules.bool("natural_health_regeneration");
+        // Player.isInvulnerableTo: the damage-type rules.
+        self.world.health_rules.drowning_damage = self.ui.rules.bool("drowning_damage");
+        self.world.health_rules.fall_damage = self.ui.rules.bool("fall_damage");
+        self.world.health_rules.fire_damage = self.ui.rules.bool("fire_damage");
+        self.world.health_rules.freeze_damage = self.ui.rules.bool("freeze_damage");
         use horizon_world::food::Difficulty;
         self.world.health_rules.difficulty = match self.ui.difficulty {
             0 => Difficulty::Peaceful,
diff --git a/crates/horizon-client/src/health.rs b/crates/horizon-client/src/health.rs
index 25c719bfb..cf7397bf8 100644
--- a/crates/horizon-client/src/health.rs
+++ b/crates/horizon-client/src/health.rs
@@ -29,12 +29,22 @@ pub(crate) type State = HurtState<DamageTypeId>;
 pub struct HealthRules {
     pub difficulty: Difficulty,
     pub natural_regeneration: bool,
+    /// The `drowning_damage`, `fall_damage`, `fire_damage` and
+    /// `freeze_damage` rules `Player.isInvulnerableTo` reads.
+    pub drowning_damage: bool,
+    pub fall_damage: bool,
+    pub fire_damage: bool,
+    pub freeze_damage: bool,
 }
 impl Default for HealthRules {
     fn default() -> Self {
         Self {
             difficulty: Difficulty::Normal,
             natural_regeneration: true,
+            drowning_damage: true,
+            fall_damage: true,
+            fire_damage: true,
+            freeze_damage: true,
         }
     }
 }
@@ -604,8 +614,13 @@ impl ImmunityWorld for Environment<'_> {
     fn enchantment_immunity(&mut self) -> io::Result<bool> {
         Ok(false)
     }
-    fn damage_rule(&mut self, _: DamageRule) -> io::Result<bool> {
-        Ok(true)
+    fn damage_rule(&mut self, rule: DamageRule) -> io::Result<bool> {
+        Ok(match rule {
+            DamageRule::Drowning => self.rules.drowning_damage,
+            DamageRule::Fall => self.rules.fall_damage,
+            DamageRule::Fire => self.rules.fire_damage,
+            DamageRule::Freeze => self.rules.freeze_damage,
+        })
     }
     fn changing_dimension(&mut self) -> io::Result<bool> {
         Ok(false)

From f252941ac15a075b982d892b0c5d6924818a5a62 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:20:39 +0100
Subject: [PATCH 020/475] Charge melee exhaustion only when the hit hurts

---
 crates/horizon-client/src/game.rs             | 12 ++++++----
 crates/horizon-client/src/game/lan_actions.rs |  8 +++++--
 crates/horizon-client/src/game/lan_pvp.rs     | 23 ++++++++++++-------
 3 files changed, 28 insertions(+), 15 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index b397882cd..fbd6fd240 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -7552,11 +7552,6 @@ impl Game<'_> {
         let sweep = self.sweep_attack_position(scale, crit);
         let (knockback, knockback_attack) = self.extra_knockback(&target_kind, scale);
         self.attack_ticks = 0;
-        if let Some(p) = self.player.as_mut()
-            && !self.creative
-        {
-            p.cause_food_exhaustion(0.1);
-        }
         let player = self.player.as_ref();
         let from = player.map(|p| [p.position.x, p.position.y, p.position.z]);
         if knockback_attack {
@@ -7651,6 +7646,13 @@ impl Game<'_> {
                 }
             }
             self.weapon_hit(index);
+            // Player.attack: causeFoodExhaustion(0.1F) only when the hit hurt
+            // (inside `if (wasHurt)`), after damageStatsAndHearts.
+            if let Some(p) = self.player.as_mut()
+                && !self.creative
+            {
+                p.cause_food_exhaustion(0.1);
+            }
         } else {
             self.audio
                 .play("minecraft:entity.player.attack.nodamage", from, 1.0, 1.0);
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index bbb0c37c0..7cba4c162 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -1468,9 +1468,13 @@ impl Game<'_> {
         if let Some(victim) = Self::pvp_victim(host, conn, id) {
             if let Some(Some(strike)) = self.as_guest(host, conn, |g| g.pvp_strike())
                 && self.pvp_land(host, victim, &strike)
-                && strike.stops_sprint()
             {
-                self.as_guest(host, conn, |g| g.stop_sprint_after_extra_knockback());
+                self.as_guest(host, conn, |g| {
+                    g.pvp_exhaustion();
+                    if strike.stops_sprint() {
+                        g.stop_sprint_after_extra_knockback();
+                    }
+                });
             }
             return;
         }
diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs
index 467c4537c..7b59681ed 100644
--- a/crates/horizon-client/src/game/lan_pvp.rs
+++ b/crates/horizon-client/src/game/lan_pvp.rs
@@ -82,9 +82,11 @@ impl Game<'_> {
         };
         if let Some(strike) = self.pvp_strike()
             && self.pvp_land(&mut host, Victim::Guest(conn), &strike)
-            && strike.stops_sprint()
         {
-            self.stop_sprint_after_extra_knockback();
+            self.pvp_exhaustion();
+            if strike.stops_sprint() {
+                self.stop_sprint_after_extra_knockback();
+            }
         }
         self.lan = Some(host);
         true
@@ -102,8 +104,18 @@ impl Game<'_> {
             .map(|g| Victim::Guest(g.conn))
     }
 
+    /// `Player.attack`'s `causeFoodExhaustion(0.1F)`, charged to the attacker
+    /// (the host, or a guest swapped in) only once the hit hurt the victim.
+    pub(super) fn pvp_exhaustion(&mut self) {
+        if let Some(p) = self.player.as_mut()
+            && !self.creative
+        {
+            p.cause_food_exhaustion(0.1);
+        }
+    }
+
     /// The attacker's side of `Player.attack` (the host, or a guest swapped
-    /// in): the damage, the charge reset, the exhaustion and the swing.
+    /// in): the damage, the charge reset and the swing.
     pub(super) fn pvp_strike(&mut self) -> Option<Strike> {
         let p = self.player.as_ref()?;
         let from = [p.position.x, p.position.y, p.position.z];
@@ -112,11 +124,6 @@ impl Game<'_> {
         let (strength, knockback_attack) = self.extra_knockback("minecraft:player", scale);
         let (xd, zd) = self.extra_knockback_direction();
         self.attack_ticks = 0;
-        if let Some(p) = self.player.as_mut()
-            && !self.creative
-        {
-            p.cause_food_exhaustion(0.1);
-        }
         self.swing_arm();
         Some(Strike {
             amount,

From a8205dd80dc43779ec22d213e412ef97805553c6 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:21:45 +0100
Subject: [PATCH 021/475] Infested blocks release their silverfish when broken

---
 crates/horizon-client/src/game.rs         | 15 +++++++++++++++
 crates/horizon-client/src/game/spawner.rs |  2 +-
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index b397882cd..e5fe51b7c 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -3396,6 +3396,21 @@ impl Game<'_> {
                 {
                     self.hive_broken_by_player(pos, hive, honey, facing);
                 }
+                // InfestedBlock.spawnAfterBreak: its silverfish comes out unless the
+                // tool has silk touch (#prevents_infested_spawns) or blocks don't drop.
+                if facts.name.starts_with("minecraft:infested_")
+                    && !silk
+                    && self.ui.rules.bool("block_drops")
+                {
+                    let at = [
+                        f64::from(pos[0]) + 0.5,
+                        f64::from(pos[1]),
+                        f64::from(pos[2]) + 0.5,
+                    ];
+                    if let Some(id) = self.spawn_mob("minecraft:silverfish", at, false) {
+                        self.mob_poof(id);
+                    }
+                }
                 // SpawnerBlock.spawnAfterBreak pops its experience whatever the tool.
                 let xp = if silk && &*facts.name != "minecraft:spawner" {
                     0
diff --git a/crates/horizon-client/src/game/spawner.rs b/crates/horizon-client/src/game/spawner.rs
index 538cb39e7..5dd907afb 100644
--- a/crates/horizon-client/src/game/spawner.rs
+++ b/crates/horizon-client/src/game/spawner.rs
@@ -253,7 +253,7 @@ impl Game<'_> {
         self.world.modified.insert((key.0 >> 4, key.2 >> 4));
     }
     /// `LivingEntity.makePoofParticles` (entity event 20) for a mob.
-    fn mob_poof(&mut self, id: u32) {
+    pub(super) fn mob_poof(&mut self, id: u32) {
         let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
             return;
         };

From 6c7a90cd7e2f2627a06744392db5882de81660a0 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:21:59 +0100
Subject: [PATCH 022/475] Let chickens lay eggs and players get snow and chorus
 flowers from loot tables

Gift loot (chicken eggs, sniffer seeds) is now rolled with the mob as the
loot context's this entity, and chicken variants are known to loot
predicates, so each chicken lays its own egg colour. A block a player
breaks now has the player as this entity, so snow layers drop snowballs
and chorus flowers drop themselves.
---
 crates/horizon-client/src/game.rs           |  9 ++--
 crates/horizon-client/src/game/creatures.rs | 51 +++++++++++++++++----
 crates/horizon-client/src/game/explosion.rs |  1 +
 crates/horizon-client/src/items.rs          | 45 ++++++++++++++++--
 crates/horizon-client/src/mobs.rs           |  4 +-
 crates/horizon-client/src/mobs/drops.rs     |  3 ++
 crates/horizon-client/src/mobs/farm.rs      |  1 +
 crates/horizon-client/src/mobs/sniffer.rs   |  1 +
 crates/horizon-world/src/loot.rs            |  5 ++
 9 files changed, 103 insertions(+), 17 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index b397882cd..7fd2bd1ba 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2159,8 +2159,9 @@ impl Game<'_> {
             ticks: 0,
         });
     }
-    /// `Block.getDrops`: the block's loot table, drawing from its server random
-    /// sequence (`LootContext.Builder.create`), else the level random.
+    /// `Block.getDrops` for a block a player breaks: the block's loot table
+    /// with the player as `this`, drawing from its server random sequence
+    /// (`LootContext.Builder.create`), else the level random.
     fn block_loot_at(
         &mut self,
         pos: [i32; 3],
@@ -2174,9 +2175,9 @@ impl Game<'_> {
                 let random = self.rand_sequences.get(&sequence, self.level.seed);
                 self.res
                     .items()
-                    .block_drops_with(registry, state, held, &dynamic, random)
+                    .block_drops_by_player(registry, state, held, &dynamic, random)
             }
-            None => self.res.items().block_drops_with(
+            None => self.res.items().block_drops_by_player(
                 registry,
                 state,
                 held,
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 3a8562ee1..88abe39a1 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -834,6 +834,47 @@ impl Game<'_> {
             }
         }
     }
+    /// `LivingEntity.dropFromGiftLootTable`: the gift table from its random
+    /// sequence with the mob as `this` (a chicken's egg depends on its
+    /// variant); the loot data of the game's resources decides, and without it
+    /// the items' table engine (no entity) rolls it.
+    fn drop_gift_loot(&mut self, mob: u32, table: &'static str, at: [f64; 3]) {
+        use horizon_client::mobs::drops;
+        use horizon_world::loot::EntityLootParams;
+        let loot = horizon_client::structure_blocks::loot_data(&self.options.resources);
+        let this = self
+            .mobs
+            .iter()
+            .find(|m| m.id == mob)
+            .map(|m| drops::loot_entity(m, None));
+        let stacks = match (loot, this) {
+            (Some(loot), Some(this)) if loot.has_table(table) => {
+                let params = EntityLootParams {
+                    this,
+                    ..EntityLootParams::default()
+                };
+                let seed = self.level.seed;
+                match loot.random_sequence(table) {
+                    Some(id) => {
+                        let random = self.rand_sequences.get(id, seed);
+                        loot.roll_entity(table, random, &params)
+                            .iter()
+                            .filter(|s| !s.is_empty())
+                            .map(from_loot)
+                            .collect()
+                    }
+                    None => Vec::new(),
+                }
+            }
+            _ => self
+                .res
+                .items()
+                .loot_table(table, false, None, &mut self.world.random),
+        };
+        for d in stacks {
+            self.spawn_item(d, at, [0.0, 0.2, 0.0], 10);
+        }
+    }
     pub(super) fn handle_mob_events(&mut self, events: Vec<MobEvent>) -> Result<()> {
         for e in events {
             match e {
@@ -1215,15 +1256,7 @@ impl Game<'_> {
                         m.ai.aggressive |= aggressive;
                     }
                 }
-                MobEvent::GiftLoot { table, at } => {
-                    let drops =
-                        self.res
-                            .items()
-                            .loot_table(table, false, None, &mut self.world.random);
-                    for d in drops {
-                        self.spawn_item(d, at, [0.0, 0.2, 0.0], 10);
-                    }
-                }
+                MobEvent::GiftLoot { mob, table, at } => self.drop_gift_loot(mob, table, at),
             }
         }
         Ok(())
diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs
index 6ecba3a54..4324c5863 100644
--- a/crates/horizon-client/src/game/explosion.rs
+++ b/crates/horizon-client/src/game/explosion.rs
@@ -620,6 +620,7 @@ impl Game<'_> {
                 &mut self.world.random,
                 Some((&mut self.rand_sequences, self.level.seed)),
                 decay,
+                false,
             );
             for mut stack in drops {
                 if &*stack.item == "minecraft:air" || stack.count == 0 {
diff --git a/crates/horizon-client/src/items.rs b/crates/horizon-client/src/items.rs
index 8ac450bcb..32a84e7d7 100644
--- a/crates/horizon-client/src/items.rs
+++ b/crates/horizon-client/src/items.rs
@@ -796,6 +796,7 @@ impl Items {
             held: None,
             killed_by_player: false,
             explosion_radius: None,
+            this_entity: false,
         };
         ctx.evaluate(table, random)
     }
@@ -860,10 +861,26 @@ impl Items {
         random: &mut impl RandomSource,
         sequences: Option<(&mut crate::random_sequences::RandomSequences, i64)>,
     ) -> Vec<ItemStack> {
-        self.block_drops_exploded(registry, state, held, dynamic, random, sequences, None)
+        self.block_drops_exploded(
+            registry, state, held, dynamic, random, sequences, None, false,
+        )
+    }
+    /// `block_drops_with` for a block a player breaks (`Block.playerDestroy`):
+    /// the player is the loot context's `this` entity, so snow and chorus
+    /// flower tables see an entity.
+    pub fn block_drops_by_player(
+        &self,
+        registry: &BlockRegistry,
+        state: BlockStateId,
+        held: Option<&ItemStack>,
+        dynamic: &[ItemStack],
+        random: &mut impl RandomSource,
+    ) -> Vec<ItemStack> {
+        self.block_drops_exploded(registry, state, held, dynamic, random, None, None, true)
     }
     /// `block_drops_full` for a block an explosion destroys: `explosion`
-    /// is its radius when the explosion decays drops (`DESTROY_WITH_DECAY`).
+    /// is its radius when the explosion decays drops (`DESTROY_WITH_DECAY`);
+    /// `breaker` is whether an entity (the player) broke the block.
     #[allow(clippy::too_many_arguments)]
     pub fn block_drops_exploded(
         &self,
@@ -874,8 +891,10 @@ impl Items {
         random: &mut impl RandomSource,
         sequences: Option<(&mut crate::random_sequences::RandomSequences, i64)>,
         explosion: Option<f32>,
+        breaker: bool,
     ) -> Vec<ItemStack> {
-        let drops = self.block_drops_raw(registry, state, held, random, sequences, explosion);
+        let drops =
+            self.block_drops_raw(registry, state, held, random, sequences, explosion, breaker);
         if !drops.iter().any(|d| d.item.starts_with(DYNAMIC)) {
             return drops;
         }
@@ -890,6 +909,7 @@ impl Items {
             })
             .collect()
     }
+    #[allow(clippy::too_many_arguments)]
     fn block_drops_raw(
         &self,
         registry: &BlockRegistry,
@@ -898,6 +918,7 @@ impl Items {
         random: &mut impl RandomSource,
         sequences: Option<(&mut crate::random_sequences::RandomSequences, i64)>,
         explosion_radius: Option<f32>,
+        breaker: bool,
     ) -> Vec<ItemStack> {
         let Some(block) = registry.state(state) else {
             return vec![];
@@ -931,6 +952,7 @@ impl Items {
                 held,
                 killed_by_player: false,
                 explosion_radius,
+                this_entity: breaker,
             };
             return ctx.evaluate(table, random);
         }
@@ -941,6 +963,7 @@ impl Items {
             held,
             killed_by_player: false,
             explosion_radius,
+            this_entity: breaker,
         };
         ctx.evaluate(table, random)
     }
@@ -964,6 +987,7 @@ impl Items {
             held,
             killed_by_player,
             explosion_radius: None,
+            this_entity: false,
         };
         ctx.evaluate(table, random)
     }
@@ -996,6 +1020,7 @@ impl Items {
             held: None,
             killed_by_player: false,
             explosion_radius: None,
+            this_entity: false,
         };
         match table.get("random_sequence").and_then(Value::as_str) {
             Some(sequence) => ctx.evaluate(table, sequences.get(sequence, seed)),
@@ -1021,6 +1046,7 @@ impl Items {
             held,
             killed_by_player,
             explosion_radius: None,
+            this_entity: false,
         };
         ctx.evaluate(table, random)
     }
@@ -1043,6 +1069,7 @@ impl Items {
             held,
             killed_by_player,
             explosion_radius: None,
+            this_entity: false,
         };
         ctx.evaluate(table, random)
     }
@@ -1084,6 +1111,8 @@ struct LootContext<'a> {
     killed_by_player: bool,
     /// `LootContextParams.EXPLOSION_RADIUS`: an explosion that decays drops.
     explosion_radius: Option<f32>,
+    /// `LootContextParams.THIS_ENTITY` is set (a player broke the block).
+    this_entity: bool,
 }
 impl LootContext<'_> {
     /// Level of an enchantment on the tool / killer's weapon.
@@ -1244,6 +1273,15 @@ impl LootContext<'_> {
                 };
                 random.next_float() < chance
             }
+            // `this` with no checks (snow, chorus flower) holds when an entity
+            // broke the block (LootItemEntityPropertyCondition needs the entity).
+            "minecraft:entity_properties"
+                if self.this_entity
+                    && c["entity"].as_str() == Some("this")
+                    && c["predicate"].as_object().is_none_or(|p| p.is_empty()) =>
+            {
+                true
+            }
             // Entity flags, equipment and damage-source predicates: none hold
             // for an unenchanted player kill without fire or lightning.
             "minecraft:entity_properties" | "minecraft:damage_source_properties" => false,
@@ -1571,6 +1609,7 @@ mod tests {
             held,
             killed_by_player: block.is_empty(),
             explosion_radius: None,
+            this_entity: false,
         }
     }
 
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..b37841adc 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1126,8 +1126,10 @@ pub enum MobEvent {
         target: Who,
         aggressive: bool,
     },
-    /// Drop the loot of a gift table (chicken eggs, armadillo scutes).
+    /// Drop the loot of a gift table (chicken eggs, sniffer seeds) with the
+    /// mob as `this` (`LivingEntity.dropFromGiftLootTable`).
     GiftLoot {
+        mob: u32,
         table: &'static str,
         at: [f64; 3],
     },
diff --git a/crates/horizon-client/src/mobs/drops.rs b/crates/horizon-client/src/mobs/drops.rs
index e5ccfd283..f8431fd65 100644
--- a/crates/horizon-client/src/mobs/drops.rs
+++ b/crates/horizon-client/src/mobs/drops.rs
@@ -350,6 +350,9 @@ pub fn loot_entity(m: &Mob, vehicle: Option<LootEntity>) -> LootEntity {
             .to_owned(),
         );
     }
+    if s == S::Chicken {
+        e.chicken_variant = super::finalize::variant_component(m).map(|(_, id)| id);
+    }
     e.powered = s == S::Creeper && m.extra.charged;
     e.equipment = SLOTS
         .iter()
diff --git a/crates/horizon-client/src/mobs/farm.rs b/crates/horizon-client/src/mobs/farm.rs
index 83d5ac1f5..87951b0e2 100644
--- a/crates/horizon-client/src/mobs/farm.rs
+++ b/crates/horizon-client/src/mobs/farm.rs
@@ -80,6 +80,7 @@ pub fn chicken_ai_step(m: &mut Mob, _w: &MobWorld, events: &mut Vec<MobEvent>) {
             let at = [m.position.x, m.position.y, m.position.z];
             events.push(MobEvent::Sound("entity.chicken.egg", at, 1.0, pitch));
             events.push(MobEvent::GiftLoot {
+                mob: m.id,
                 table: "minecraft:gameplay/chicken_lay",
                 at,
             });
diff --git a/crates/horizon-client/src/mobs/sniffer.rs b/crates/horizon-client/src/mobs/sniffer.rs
index 6979171b8..c0c8d8155 100644
--- a/crates/horizon-client/src/mobs/sniffer.rs
+++ b/crates/horizon-client/src/mobs/sniffer.rs
@@ -94,6 +94,7 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
     if current == DIGGING && now(m) == m.extra.ints[3] {
         let h = head_block(m);
         events.push(MobEvent::GiftLoot {
+            mob: m.id,
             table: "minecraft:gameplay/sniffer_digging",
             at: [f64::from(h[0]), f64::from(h[1]), f64::from(h[2])],
         });
diff --git a/crates/horizon-world/src/loot.rs b/crates/horizon-world/src/loot.rs
index 96ca5bdee..ca7ff9e56 100644
--- a/crates/horizon-world/src/loot.rs
+++ b/crates/horizon-world/src/loot.rs
@@ -150,6 +150,8 @@ pub struct LootEntity {
     pub captain: Option<bool>,
     /// A frog's variant id (`minecraft:warm`).
     pub frog_variant: Option<String>,
+    /// A chicken's variant id (`minecraft:warm`).
+    pub chicken_variant: Option<String>,
     /// A charged creeper (`Creeper.isPowered`).
     pub powered: bool,
     /// Worn and held items by `EquipmentSlot` name (mainhand, offhand,
@@ -851,6 +853,9 @@ impl<R: RandomSource> Context<'_, R> {
                 "minecraft:frog/variant" => {
                     e.frog_variant.is_some() && want.as_str() == e.frog_variant.as_deref()
                 }
+                "minecraft:chicken/variant" => {
+                    e.chicken_variant.is_some() && want.as_str() == e.chicken_variant.as_deref()
+                }
                 _ => false,
             }),
             "minecraft:type_specific/sheep" => e

From 23d089aa7c5bf68f0a5ab830bf2ae3264a636954 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:25:30 +0100
Subject: [PATCH 023/475] Match vanilla animal breeding rules: rabbits breed,
 damage ends love, horse and wolf checks, breeding XP rule

Rabbits get BreedGoal and TemptGoal with rabbit food. Damage to an animal
resets love. Horses, donkeys and llamas need canParent (not ridden, tame,
adult, full health) for both parents, a sitting wolf is no partner, and the
breeding experience orb needs the mob_drops game rule.
---
 crates/horizon-client/src/game/creatures.rs | 17 ++++++++++++-----
 crates/horizon-client/src/mobs.rs           | 10 ++++++++++
 crates/horizon-client/src/mobs/goals.rs     | 20 ++++++++++++++------
 crates/horizon-client/src/mobs/rabbit.rs    | 11 ++++++++++-
 4 files changed, 46 insertions(+), 12 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 3a8562ee1..d8fdb9104 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1117,7 +1117,7 @@ impl Game<'_> {
                         self.particles.add(&options, at, velocity);
                     }
                 }
-                MobEvent::Experience { at, amount } => self.spawn_orbs(at, amount),
+                MobEvent::Experience { at, amount } => self.spawn_breeding_orb(at, amount),
                 MobEvent::AxolotlSupportPlayer => {
                     let previous = self
                         .potions
@@ -1261,6 +1261,13 @@ impl Game<'_> {
             m.extra.egg_time = life;
         }
     }
+    /// `Animal.finalizeSpawnChildFromBreeding`'s experience orb: only when the
+    /// `mob_drops` game rule is on.
+    fn spawn_breeding_orb(&mut self, at: [f64; 3], amount: u32) {
+        if self.ui.rules.bool("mob_drops") {
+            self.spawn_orbs(at, amount);
+        }
+    }
     /// Animal.spawnChildFromBreeding
     fn breed(
         &mut self,
@@ -1354,7 +1361,7 @@ impl Game<'_> {
                 }
                 self.world.random = r;
                 let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
-                self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+                self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp);
                 return;
             }
             if p.species() == Species::Cat {
@@ -1375,7 +1382,7 @@ impl Game<'_> {
                     };
                 }
                 let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
-                self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+                self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp);
                 return;
             }
             if p.species() == Species::Wolf {
@@ -1397,7 +1404,7 @@ impl Game<'_> {
                     };
                 }
                 let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
-                self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+                self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp);
                 return;
             }
             // Nautilus.getBreedOffspring: a tame parent's baby is tame too.
@@ -1413,7 +1420,7 @@ impl Game<'_> {
             }
         }
         let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
-        self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+        self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp);
     }
     /// `MobEffectUtil.addEffectToPlayersAround` for an elder guardian:
     /// mining fatigue III for five minutes unless a stronger or longer one
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..479683664 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1243,6 +1243,10 @@ pub struct Seen {
     /// `MAX_HEALTH`, `JUMP_STRENGTH` and `MOVEMENT_SPEED` base values (a
     /// horse's breeding stock).
     pub stats: [f64; 3],
+    /// `Wolf.isInSittingPose`.
+    pub sitting: bool,
+    /// `Entity.isVehicle` or `isPassenger`.
+    pub ridden: bool,
 }
 impl Mob {
     pub fn burning_time(&self) -> f64 {
@@ -1315,6 +1319,8 @@ impl Mob {
                 m.extra.vector[0],
                 m.attrs.speed,
             ],
+            sitting: m.extra.sitting,
+            ridden: m.rider.is_some() || m.extra.rider.is_some() || m.extra.mount.is_some(),
         }
     }
     /// `EntityType.getCategory`'s name.
@@ -1752,6 +1758,10 @@ impl Mob {
             self.health -= amount;
             self.hurt_time = 10;
         }
+        // Animal.actuallyHurt: damage taken ends love mode (`resetLove`).
+        if drops::is_animal(self.species()) {
+            self.extra.in_love = 0;
+        }
         self.last_damage = Some((source, i64::from(self.age)));
         if let Some(who) = source.attacker {
             self.ai.last_hurt_by = Some(who);
diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs
index 7f73e32c4..a784464d8 100644
--- a/crates/horizon-client/src/mobs/goals.rs
+++ b/crates/horizon-client/src/mobs/goals.rs
@@ -1771,11 +1771,16 @@ impl Goal for Breed {
         }
         let llama = super::llama::is_llama(species);
         let equine = matches!(species, Species::Horse | Species::Donkey) || llama;
-        if equine && !m.extra.tame {
-            return false;
-        }
-        // Llama.canParent: not ridden, and at full health.
-        if llama && (m.rider.is_some() || m.health < m.attrs.max_health) {
+        // AbstractHorse.canParent: tame, an adult, not a vehicle or passenger
+        // and at full health.
+        if equine
+            && (!m.extra.tame
+                || m.is_baby()
+                || m.rider.is_some()
+                || m.extra.rider.is_some()
+                || m.extra.mount.is_some()
+                || m.health < m.attrs.max_health)
+        {
             return false;
         }
         self.partner =
@@ -1788,7 +1793,10 @@ impl Goal for Breed {
                     && s.in_love
                     && !s.baby
                     && (!tamable || s.tame)
-                    && (!equine || s.tame)
+                    // Wolf.canMate: a sitting wolf is no partner.
+                    && !(species == Species::Wolf && s.sitting)
+                    // AbstractHorse.canParent of the partner.
+                    && (!equine || s.tame && !s.ridden && s.health >= s.stats[0] as f32)
                     && (!sniffer || super::sniffer::can_mate_state(s.variant))
             })
             .map(|s| s.id)
diff --git a/crates/horizon-client/src/mobs/rabbit.rs b/crates/horizon-client/src/mobs/rabbit.rs
index a2ab6e95c..ac4c3850f 100644
--- a/crates/horizon-client/src/mobs/rabbit.rs
+++ b/crates/horizon-client/src/mobs/rabbit.rs
@@ -1,5 +1,9 @@
 //! Rabbit hopping controls and the clocks consumed by `RabbitModel`.
-use super::{Mob, MobEvent, MobWorld, control::Operation};
+use super::{
+    Mob, MobEvent, MobWorld,
+    control::Operation,
+    goals::{Breed, Tempt},
+};
 use horizon_core::{
     geometry::{Vec3, trig},
     random::RandomSource,
@@ -14,7 +18,12 @@ const IDLE_TIMEOUT: usize = 3;
 const CLIENT_JUMP_TICKS: usize = 4;
 const CLIENT_JUMP_DURATION: usize = 5;
 
+/// Rabbit.registerGoals after the generic panic and stroll: BreedGoal and
+/// TemptGoal with rabbit food.
 pub fn register(m: &mut Mob) {
+    let food = m.kind.food.clone();
+    m.ai.goals.add(2, Breed::new(0.8));
+    m.ai.goals.add(3, Tempt::new(1.0, food, false));
     m.ai.mov.kind = super::control::MoveKind::Custom;
     m.ai.nav.can_float = true;
     m.extra.ints[IDLE_TIMEOUT] = m.random.next_int_bound(40).unwrap_or(0) + 180;

From ebf3c1567cf408783e6adc08d76106b30fb82f20 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 13:34:31 +0100
Subject: [PATCH 024/475] parity: follow code into new crates when choosing
 harnesses

Two changes so `parity.py --changed` keeps picking the right harnesses once code moves into a crate of its own:

- A harness recorded before the move names the old paths. A changed Rust file of a crate the recorded crates
  link (their path dependencies, transitively) but don't name now counts, and the reach search decides.
  Before, such a file matched no record and selected nothing.
- A library's root opens once reached code names the crate (`horizon_world::`, `pub use horizon_command as
  command`), instead of always. Every crate root was open, so any item of a new crate whose name matched a
  name used anywhere counted. On main the selection is the same for 15 of 16 sampled files; for
  horizon-world/src/nbt.rs one harness that reached it only through a name match drops out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_parity_reach.py | 20 +++++++++++++++++
 tools/parity.py            |  2 +-
 tools/parity_reach.py      | 45 +++++++++++++++++++++++++++++++++-----
 3 files changed, 61 insertions(+), 6 deletions(-)

diff --git a/tests/test_parity_reach.py b/tests/test_parity_reach.py
index 07e3df9e3..0e20f9174 100644
--- a/tests/test_parity_reach.py
+++ b/tests/test_parity_reach.py
@@ -111,6 +111,26 @@ class ReachTests(unittest.TestCase):
         self.assertIn("crates/a/src/display.rs", full)
         self.assertTrue(graph.results)
 
+    def test_a_module_moved_to_a_new_crate_counts_through_its_reexport(self):
+        # used.rs moves to crate b after the harness was recorded; a re-exports it under its old path. Crate c is
+        # a dependency nothing reached names: its items stay out even where their names match.
+        (self.root / "crates/a/src/used.rs").unlink()
+        workspace(self.root, {
+            "crates/a/Cargo.toml": (self.root / "crates/a/Cargo.toml").read_text()
+            + '\n[dependencies]\nb = { path = "../b" }\nc = { path = "../c" }\n',
+            "crates/a/src/lib.rs": "pub use b::used;\npub mod unused;\nmod methods;\nmod display;\n",
+            "crates/b/Cargo.toml": '[package]\nname = "b"\n',
+            "crates/b/src/lib.rs": "pub mod used;\n",
+            "crates/b/src/used.rs": "pub struct Thing;\npub fn helper() -> u32 { 1 }\n",
+            "crates/c/Cargo.toml": '[package]\nname = "c"\n',
+            "crates/c/src/lib.rs": "pub fn helper() -> u32 { 3 }\n",
+        })
+        changed = {"crates/b/src/used.rs", "crates/c/src/lib.rs"}
+        self.assertEqual(parity_reach.unrecorded(self.root, self.dependencies, changed), changed)
+        kept = self.narrowed(changed=changed)
+        self.assertIn("crates/b/src/used.rs", kept)
+        self.assertNotIn("crates/c/src/lib.rs", kept)
+
     def test_unknown_probes_keep_everything(self):
         self.assertEqual(set(self.narrowed(artifacts=[])), set(self.dependencies))
         self.assertEqual(set(self.narrowed(artifacts=[["example", "missing", "release", ["-p", "a"], True]])),
diff --git a/tools/parity.py b/tools/parity.py
index dbff8c146..6cc61cfb4 100644
--- a/tools/parity.py
+++ b/tools/parity.py
@@ -1274,7 +1274,7 @@ def affected_harnesses(found, records, changed, reach=True, base=None):
             affected.add(name)
             continue
         plain = {path.split(KEEP)[0] for path in dependencies}
-        hit = plain & changed
+        hit = (plain & changed) | parity_reach.unrecorded(ROOT, plain, changed)
         if not hit:
             continue
         if graph is None or any(not path.startswith("crates/") for path in hit):
diff --git a/tools/parity_reach.py b/tools/parity_reach.py
index dc61f6215..b5be2a192 100644
--- a/tools/parity_reach.py
+++ b/tools/parity_reach.py
@@ -7,8 +7,8 @@ of the workspace's current sources whose nodes are items:
 
 - everything in an entry is reached, and so is everything in a Rust file the module tree doesn't place (an
   `include!`d source);
-- a module is open when it is a crate root, holds reached code, or is named in a path (`name::`, `use ...name`) by
-  reached code while its parent is open;
+- a module is open when it holds reached code, or is named in a path (`name::`, `use ...name`) by reached code while
+  its parent is open; a library's root once reached code names its crate (`horizon_world`);
 - a free item (fn, struct, enum, union, trait, type, const, static, an item-level macro call's items) is reached when
   reached code in its own module or below it mentions its name, or when its module is open and reached code names
   it in a path or an import, or when its module is glob-imported (`use m::*`) and its name is mentioned;
@@ -608,8 +608,8 @@ class SourceGraph:
 
         try:
             for path in universe:
-                if path.endswith("/src/lib.rs") or path in entries or path not in self.parent:
-                    open_module(path, "crate root or entry")
+                if path in entries or path not in self.parent and not path.endswith("/src/lib.rs"):
+                    open_module(path, "entry, or a file no module places")
             for node in seeds:
                 reach(node, "entry" if node[0] in entries else "always counted")
             for path in entries & universe:
@@ -624,6 +624,12 @@ class SourceGraph:
                 label = (item.get("names") or [item["kind"]])[0] if member is None else item["members"][member]["name"]
                 source = sets_of(node, item)
                 why = f"{path} ({label})"
+                # A library's root opens once reached code names the crate (`horizon_world::`, `use horizon_command
+                # as command`): its items are out of reach until then.
+                for word in (source["mentions"] | source["paths"]) & idents.keys():
+                    root = f"crates/{idents[word]}/src/lib.rs"
+                    if root in universe and root not in opened:
+                        open_module(root, f"{why} names {word}")
                 # Plain mentions reach items of this file and of the modules above it.
                 ancestor, new = path, source["mentions"]
                 while ancestor is not None and new:
@@ -709,6 +715,35 @@ def is_workspace_rust(path):
     return path.startswith("crates/") and path.endswith(".rs") and path.count("/") >= 2
 
 
+PATH_DEPENDENCY = re.compile(r'path\s*=\s*"\.\./([\w-]+)"')
+
+
+@functools.cache
+def _path_dependencies(root, crate):
+    manifest = Path(root) / "crates" / crate / "Cargo.toml"
+    text = manifest.read_text(encoding="utf-8") if manifest.is_file() else ""
+    return frozenset(PATH_DEPENDENCY.findall(text))
+
+
+def linked_crates(root, crates):
+    """The workspace crates (folders under crates/) that crates link, themselves included: their path dependencies,
+    transitively. A harness recorded before code moved to a new crate links that crate without naming its files."""
+    found, queue = set(crates), list(crates)
+    while queue:
+        for dependency in _path_dependencies(str(root), queue.pop()):
+            if dependency not in found:
+                found.add(dependency)
+                queue.append(dependency)
+    return found
+
+
+def unrecorded(root, plain, changed):
+    """Changed workspace Rust files of crates a harness's recorded crates link but its record doesn't name."""
+    crates = {crate_of(path) for path in plain if path.startswith("crates/") and path.count("/") >= 2}
+    linked = linked_crates(root, crates) - crates
+    return {path for path in changed if is_workspace_rust(path) and crate_of(path) in linked}
+
+
 DECLARATION_LINE = re.compile(rf"\s*(?:pub(?:\([^)]*\))?\s+)?mod\s+({IDENT})\s*;")
 
 
@@ -758,7 +793,7 @@ def narrow(dependencies, artifacts, graph, changed=(), stop=frozenset()):
     plain = [dependency.split("#keep:")[0] for dependency in dependencies]
     crates = {crate_of(path) for path in plain if path.startswith("crates/") and path.count("/") >= 2}
     rust = {path for path in plain if is_workspace_rust(path)}
-    added = {path for path in changed if is_workspace_rust(path) and crate_of(path) in crates
+    added = {path for path in changed if is_workspace_rust(path) and crate_of(path) in linked_crates(graph.root, crates)
              and path not in rust and (graph.root / path).is_file()}
     entries = graph.entries(artifacts, rust)
     if entries is None:

From 0a116d95234f09d1cd5867a0ee371e097e37ed5a Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 13:34:31 +0100
Subject: [PATCH 025/475] Split horizon-command and horizon-client-core out of
 horizon-client

A pure move, the first slice of splitting the client lib into crates:

- horizon-command: the command/ module (Brigadier port, vanilla tree, argument types, selectors), as is.
- horizon-client-core: what command needs from the lib, with no other dependency inside it: text, lang, snbt,
  nbt_path, component, scoreboard, bossbar, gamerules, block_entity_nbt, fastutil_order; plus items moved out of
  lib modules that sit in the cycle, unchanged: ParticleType (particles.rs), the key display name (keybinds.rs),
  SOUND_SOURCES (settings.rs), uuid_text/uuid_from_text (save.rs), Registries/RegistryIds and parse_identifier
  (command/args.rs).

horizon-client re-exports every module and item under its old path (`horizon_client::text`,
`crate::command::Registries`, `particles::ParticleType`...), so no caller changes. Inside the moved files only
paths changed (`crate::snbt` -> `horizon_client_core::snbt` in command, `crate::command::args::parse_identifier`
-> `crate::identifier::parse_identifier`...), `sign_side` became pub, lang.rs includes the lang files from
horizon-client's assets, and gamerules' test that saves a Level moved to save.rs (it needs the client's save).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |  10 +-
 Cargo.lock                                    |  19 ++
 Cargo.toml                                    |   2 +-
 crates/horizon-client-core/Cargo.toml         |  14 +
 .../src/block_entity_nbt.rs                   |   2 +-
 .../src/bossbar.rs                            |   0
 .../src/component.rs                          |   2 +-
 .../src/fastutil_order.rs                     |   0
 .../src/gamerules.rs                          |  23 --
 crates/horizon-client-core/src/identifier.rs  |  18 ++
 crates/horizon-client-core/src/key_display.rs |  38 +++
 .../src/lang.rs                               |   8 +-
 crates/horizon-client-core/src/lib.rs         |  23 ++
 .../src/nbt_path.rs                           |   0
 .../horizon-client-core/src/particle_type.rs  | 209 +++++++++++++++
 crates/horizon-client-core/src/registries.rs  | 188 +++++++++++++
 .../src/scoreboard.rs                         |   4 +-
 .../src/snbt.rs                               |   0
 .../horizon-client-core/src/sound_source.rs   |   7 +
 .../src/text.rs                               |   2 +-
 crates/horizon-client-core/src/uuid.rs        |  24 ++
 crates/horizon-client/Cargo.toml              |   2 +
 crates/horizon-client/src/keybinds.rs         |  36 +--
 crates/horizon-client/src/lib.rs              |  24 +-
 crates/horizon-client/src/particles.rs        | 207 +--------------
 crates/horizon-client/src/save.rs             |  47 ++--
 crates/horizon-client/src/settings.rs         |   6 +-
 crates/horizon-command/Cargo.toml             |  15 ++
 .../command => horizon-command/src}/args.rs   | 248 ++----------------
 .../command => horizon-command/src}/block.rs  |   0
 .../command => horizon-command/src}/codec.rs  |   2 +-
 .../src}/component.rs                         |   4 +-
 .../command => horizon-command/src}/item.rs   |   4 +-
 .../mod.rs => horizon-command/src/lib.rs}     |   9 +-
 .../src}/network.rs                           |   0
 .../src}/packrat.rs                           |   2 +-
 .../src}/selector.rs                          |   6 +-
 .../command => horizon-command/src}/snbt.rs   |   0
 .../command => horizon-command/src}/tests.rs  |   0
 .../src}/tree_data.rs                         |   0
 .../src}/tree_execute.rs                      |   0
 .../src}/tree_extra.rs                        |   0
 .../src}/tree_misc.rs                         |   4 +-
 .../src}/tree_scoreboard.rs                   |   0
 .../src}/tree_world.rs                        |   2 +-
 .../src}/vanilla.rs                           |   2 +-
 .../src}/vanilla_order.rs                     |   0
 docs/architecture.md                          |  11 +-
 docs/version-ports.md                         |   2 +-
 tools/generate_command_order.py               |   4 +-
 tools/port_regen.py                           |   2 +-
 tools/port_report.py                          |   2 +-
 tools/test_lore_tooltip_parity.py             |   4 +-
 tools/test_resource_pack_parity.py            |   2 +-
 54 files changed, 678 insertions(+), 562 deletions(-)
 create mode 100644 crates/horizon-client-core/Cargo.toml
 rename crates/{horizon-client => horizon-client-core}/src/block_entity_nbt.rs (99%)
 rename crates/{horizon-client => horizon-client-core}/src/bossbar.rs (100%)
 rename crates/{horizon-client => horizon-client-core}/src/component.rs (99%)
 rename crates/{horizon-client => horizon-client-core}/src/fastutil_order.rs (100%)
 rename crates/{horizon-client => horizon-client-core}/src/gamerules.rs (90%)
 create mode 100644 crates/horizon-client-core/src/identifier.rs
 create mode 100644 crates/horizon-client-core/src/key_display.rs
 rename crates/{horizon-client => horizon-client-core}/src/lang.rs (96%)
 create mode 100644 crates/horizon-client-core/src/lib.rs
 rename crates/{horizon-client => horizon-client-core}/src/nbt_path.rs (100%)
 create mode 100644 crates/horizon-client-core/src/particle_type.rs
 create mode 100644 crates/horizon-client-core/src/registries.rs
 rename crates/{horizon-client => horizon-client-core}/src/scoreboard.rs (99%)
 rename crates/{horizon-client => horizon-client-core}/src/snbt.rs (100%)
 create mode 100644 crates/horizon-client-core/src/sound_source.rs
 rename crates/{horizon-client => horizon-client-core}/src/text.rs (99%)
 create mode 100644 crates/horizon-client-core/src/uuid.rs
 create mode 100644 crates/horizon-command/Cargo.toml
 rename crates/{horizon-client/src/command => horizon-command/src}/args.rs (87%)
 rename crates/{horizon-client/src/command => horizon-command/src}/block.rs (100%)
 rename crates/{horizon-client/src/command => horizon-command/src}/codec.rs (99%)
 rename crates/{horizon-client/src/command => horizon-command/src}/component.rs (98%)
 rename crates/{horizon-client/src/command => horizon-command/src}/item.rs (99%)
 rename crates/{horizon-client/src/command/mod.rs => horizon-command/src/lib.rs} (99%)
 rename crates/{horizon-client/src/command => horizon-command/src}/network.rs (100%)
 rename crates/{horizon-client/src/command => horizon-command/src}/packrat.rs (99%)
 rename crates/{horizon-client/src/command => horizon-command/src}/selector.rs (99%)
 rename crates/{horizon-client/src/command => horizon-command/src}/snbt.rs (100%)
 rename crates/{horizon-client/src/command => horizon-command/src}/tests.rs (100%)
 rename crates/{horizon-client/src/command => horizon-command/src}/tree_data.rs (100%)
 rename crates/{horizon-client/src/command => horizon-command/src}/tree_execute.rs (100%)
 rename crates/{horizon-client/src/command => horizon-command/src}/tree_extra.rs (100%)
 rename crates/{horizon-client/src/command => horizon-command/src}/tree_misc.rs (99%)
 rename crates/{horizon-client/src/command => horizon-command/src}/tree_scoreboard.rs (100%)
 rename crates/{horizon-client/src/command => horizon-command/src}/tree_world.rs (99%)
 rename crates/{horizon-client/src/command => horizon-command/src}/vanilla.rs (99%)
 rename crates/{horizon-client/src/command => horizon-command/src}/vanilla_order.rs (100%)

diff --git a/AGENTS.md b/AGENTS.md
index dcd4ca595..24dc38b8e 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -34,7 +34,9 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 
 | Crate | Owns |
 |---|---|
-| `horizon-client` | The game: a lib (`src/lib.rs`, ~190 flat modules) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) |
+| `horizon-client` | The game: a lib (`src/lib.rs`, ~180 flat modules) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) |
+| `horizon-command` | Command parsing (Brigadier): the vanilla tree, argument types, selectors, suggestions, the tree's network form. Re-exported as `horizon_client::command` |
+| `horizon-client-core` | The client lib's bottom layer: `text.rs`, `lang.rs`, `snbt.rs`, `nbt_path.rs`, `component.rs`, `scoreboard.rs`, `bossbar.rs`, `gamerules.rs`, `block_entity_nbt.rs`, registry/particle/sound tables. Re-exported under the old paths (`horizon_client::text`...) |
 | `horizon-world` | Vanilla world data with no gameplay loop: NBT, regions, chunks, `datafix/`, `worldgen/`, `level/` (server-side block behaviour, ticks, redstone), entity physics, items, effects, food, damage |
 | `horizon-core` | Simulation primitives: Java `Random`s, `jmath` (HotSpot-exact `Math`), positions, noise, density, paletted storage, `version.rs` (the pinned version) |
 | `horizon-protocol` | Network protocol 777: codecs, framing, encryption, `packets/{handshake,status,login,configuration,play}.rs`, `entity_data.rs` |
@@ -117,16 +119,16 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 | Other entities | L: `entities.rs`, `projectiles.rs`, `arrows.rs`; G: `boats.rs`, `minecarts.rs`, `mounts.rs`, `armor_stands.rs`, `paintings.rs`, `frames.rs`, `fireworks.rs`, `tnt.rs`, `explosion.rs` |
 | Player actions | game.rs (`fn use_hand`, `fn use_item`, `fn attack`, `fn tick_mining`, `fn break_block`); G: `hand.rs`, `combat.rs`, `consume.rs`, `potions.rs`, `shield.rs`, `crossbow.rs`, `trident.rs`, `fishing.rs`; L: `motion.rs` + `motion/` (movement), `collisions.rs`, `items.rs`, `item_data.rs` |
 | Inventory and containers | L: `menu.rs` (`AbstractContainerMenu.clicked`), `container_screen.rs`, `containers.rs`, `creative.rs`, `crafting.rs`, `recipe_book*.rs`, `stations.rs`, `merchant.rs`; game.rs `fn menu_ops`, `fn click_inventory`; G: `stations.rs`, `trading.rs`, `recipe_book.rs`, `machines.rs` |
-| Commands | parse: L: `command/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`); run: G: `commands.rs` (dispatch) + `commands/*.rs` (`admin`, `execute`, `items`, `players`, `world_cmds`...); L: `scoreboard_cmd.rs`, `data_cmd.rs`, `nbt_path.rs`; G: `functions.rs`, `command_blocks.rs` |
+| Commands | parse: crate `horizon-command` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`); run: G: `commands.rs` (dispatch) + `commands/*.rs` (`admin`, `execute`, `items`, `players`, `world_cmds`...); L: `scoreboard_cmd.rs`, `data_cmd.rs`; `horizon-client-core`: `nbt_path.rs`, `scoreboard.rs`; G: `functions.rs`, `command_blocks.rs` |
 | UI screens | `Screen` enum in game.rs; L: `title.rs` + `title/`, `options_ui.rs`, `multiplayer.rs`, `pack_screen.rs`, `graphics_ui.rs`, `screen_draw.rs`, `ui.rs` (widgets), `hud.rs`, `hud_layout.rs`, `hud_overlays.rs`, `chat.rs`, `tab_list.rs`; G: `startup_menu.rs`, `screens.rs` (pause, death), `options.rs`, `lan_screen.rs`, `chat.rs`, `sign_edit.rs`, `books.rs` |
 | Multiplayer client | L: `net.rs` (network thread); G: `remote.rs` (`fn handle_packet`, `fn tick_remote`), `remote_*.rs` (mob data, objects, projectiles, vehicles, stations) |
 | LAN host / server side | L: `lan/` (`conn.rs` handshake + login threads, `hub.rs` + `hub/` play state, `chunks.rs`, `entity.rs`, `tracking.rs`, `guest.rs`, `playerdata.rs`); G: `lan.rs` (`LanHost`), `lan_actions.rs` (`fn as_guest`, `fn tick_guests`), `lan_*.rs` per feature, `lan_entities.rs` (tracked entities) |
 | Integrated server | G: `integrated.rs` (the server thread), `levels.rs` (one level per dimension, `fn tick_server`), `server_travel.rs` |
 | Dedicated server | G: `dedicated.rs`, `dedicated/status.rs`; crates `horizon-server-files`, `horizon-server` |
-| Save and load | L: `save.rs` (level.dat, regions, playerdata), `entity_nbt.rs`, `block_entity_nbt.rs`, `options_file.rs`; G: `saving.rs`, `persist.rs` (entities); `crates/horizon-world/src/{region.rs,nbt.rs,datafix/}` |
+| Save and load | L: `save.rs` (level.dat, regions, playerdata), `entity_nbt.rs`, `options_file.rs`; `horizon-client-core/src/block_entity_nbt.rs`; G: `saving.rs`, `persist.rs` (entities); `crates/horizon-world/src/{region.rs,nbt.rs,datafix/}` |
 | Input | game.rs `fn window_event`, `fn key_pressed`, `fn play_mouse`; L: `keybinds.rs`, `keymapping.rs`, `key_names.rs`, `mouse.rs`, `input.rs`, `interaction_input.rs`, `gamepad.rs`, `osk.rs`, `clipboard.rs`; G: `pad.rs`, `pad_menu.rs` |
 | Audio | L: `audio.rs` (mixer), `sound_engine.rs`, `sound_events.rs`, `music.rs`, `ambience.rs`; G: `music.rs`, `subtitle_hud.rs` |
-| Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`, `lang.rs`; crate `horizon-assets`; G: `packs.rs` |
+| Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`; `horizon-client-core/src/lang.rs`; crate `horizon-assets`; G: `packs.rs` |
 | Agent control | L: `control.rs` (socket), `bin/horizon-ctl/`; G: `control.rs`, `agent.rs`, `events.rs`, `ui_control.rs` ([docs/agent-control.md](docs/agent-control.md)) |
 | Mods | crate `horizon-mods`; G: `mods.rs`; L: `mod_content.rs`, `mod_list.rs` |
 | Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs`, `tweaks.rs`, `options.rs` |
diff --git a/Cargo.lock b/Cargo.lock
index 0e93bba0e..1d3b52a3b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1365,6 +1365,8 @@ dependencies = [
  "glam",
  "horizon-assets",
  "horizon-bench",
+ "horizon-client-core",
+ "horizon-command",
  "horizon-core",
  "horizon-dualsense",
  "horizon-friends",
@@ -1395,6 +1397,23 @@ dependencies = [
  "zip",
 ]
 
+[[package]]
+name = "horizon-client-core"
+version = "0.1.0"
+dependencies = [
+ "horizon-world",
+ "serde_json",
+]
+
+[[package]]
+name = "horizon-command"
+version = "0.1.0"
+dependencies = [
+ "horizon-client-core",
+ "horizon-protocol",
+ "horizon-world",
+]
+
 [[package]]
 name = "horizon-core"
 version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index e4628f962..181ab1832 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [workspace]
 exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"]
-members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/zoom", "xtask"]
+members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-client-core", "crates/horizon-command", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/zoom", "xtask"]
 resolver = "2"
 
 [workspace.package]
diff --git a/crates/horizon-client-core/Cargo.toml b/crates/horizon-client-core/Cargo.toml
new file mode 100644
index 000000000..8809a5216
--- /dev/null
+++ b/crates/horizon-client-core/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "horizon-client-core"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+rust-version = "1.90"
+description = "The client's lowest layer: chat text and translations, SNBT and NBT paths, the scoreboard, boss bars, game rules and the registry and particle tables commands name"
+
+[dependencies]
+horizon-world = { path = "../horizon-world" }
+serde_json = { version = "1.0.151", features = ["raw_value"] }
+
+[lints]
+workspace = true
diff --git a/crates/horizon-client/src/block_entity_nbt.rs b/crates/horizon-client-core/src/block_entity_nbt.rs
similarity index 99%
rename from crates/horizon-client/src/block_entity_nbt.rs
rename to crates/horizon-client-core/src/block_entity_nbt.rs
index 54d230eb4..93f290515 100644
--- a/crates/horizon-client/src/block_entity_nbt.rs
+++ b/crates/horizon-client-core/src/block_entity_nbt.rs
@@ -259,7 +259,7 @@ fn is_pos(tag: &Tag) -> bool {
     matches!(tag, Tag::IntArray(v) if v.len() == 3)
 }
 /// The loaded `SignText` of one side, or the empty text.
-pub(crate) fn sign_side(tag: Option<&Tag>) -> Tag {
+pub fn sign_side(tag: Option<&Tag>) -> Tag {
     let empty = || string("");
     let mut messages: Vec<Tag> = match tag.and_then(|t| t.get("messages")) {
         Some(Tag::List(list)) => list.iter().filter_map(component).collect(),
diff --git a/crates/horizon-client/src/bossbar.rs b/crates/horizon-client-core/src/bossbar.rs
similarity index 100%
rename from crates/horizon-client/src/bossbar.rs
rename to crates/horizon-client-core/src/bossbar.rs
diff --git a/crates/horizon-client/src/component.rs b/crates/horizon-client-core/src/component.rs
similarity index 99%
rename from crates/horizon-client/src/component.rs
rename to crates/horizon-client-core/src/component.rs
index fced49898..5b828b305 100644
--- a/crates/horizon-client/src/component.rs
+++ b/crates/horizon-client-core/src/component.rs
@@ -252,7 +252,7 @@ pub fn to_text_with(
             } else if let Some(sel) = o.get("selector").and_then(Value::as_str) {
                 resolve(sel)
             } else if let Some(key) = o.get("keybind").and_then(Value::as_str) {
-                crate::keybinds::display_name(key)
+                crate::key_display::display_name(key)
             } else {
                 Text::empty()
             };
diff --git a/crates/horizon-client/src/fastutil_order.rs b/crates/horizon-client-core/src/fastutil_order.rs
similarity index 100%
rename from crates/horizon-client/src/fastutil_order.rs
rename to crates/horizon-client-core/src/fastutil_order.rs
diff --git a/crates/horizon-client/src/gamerules.rs b/crates/horizon-client-core/src/gamerules.rs
similarity index 90%
rename from crates/horizon-client/src/gamerules.rs
rename to crates/horizon-client-core/src/gamerules.rs
index 7198fd202..6715e01ec 100644
--- a/crates/horizon-client/src/gamerules.rs
+++ b/crates/horizon-client-core/src/gamerules.rs
@@ -292,27 +292,4 @@ mod tests {
         assert_eq!(GameRules::load(&dir), rules);
         let _ = fs::remove_dir_all(dir);
     }
-    /// The world's save (Level.write) writes the rules as they are now, and a
-    /// world opened again reads them back (#74).
-    #[test]
-    fn level_save_keeps_changed_rules() {
-        let dir =
-            std::env::temp_dir().join(format!("horizon-gamerules-level-{}", std::process::id()));
-        let _ = fs::remove_dir_all(&dir);
-        let mut level = crate::save::Level::default();
-        level.write(&dir).unwrap();
-        // Rules changed while playing, then saved and loaded again.
-        let mut rules = GameRules::load(&dir);
-        assert_eq!(rules, GameRules::default());
-        assert!(rules.set("advance_time", Value::Bool(false)));
-        assert!(rules.set("advance_weather", Value::Bool(false)));
-        assert!(rules.set("random_tick_speed", Value::Int(0)));
-        level.game_rules = rules.by_name();
-        level.write(&dir).unwrap();
-        assert_eq!(GameRules::load(&dir), rules);
-        let read = crate::save::Level::read(&dir).unwrap();
-        assert_eq!(read.game_rules, rules.by_name());
-        assert_eq!(read.game_rule("advance_time"), 0);
-        let _ = fs::remove_dir_all(dir);
-    }
 }
diff --git a/crates/horizon-client-core/src/identifier.rs b/crates/horizon-client-core/src/identifier.rs
new file mode 100644
index 000000000..1e76f7731
--- /dev/null
+++ b/crates/horizon-client-core/src/identifier.rs
@@ -0,0 +1,18 @@
+//! Resource identifiers (`Identifier`).
+
+/// Identifier.parse: `ns:path` or `path`, validated.
+pub fn parse_identifier(raw: &str) -> Option<String> {
+    let (ns, path) = match raw.split_once(':') {
+        Some(("", path)) => ("minecraft", path),
+        Some((ns, path)) => (ns, path),
+        None => ("minecraft", raw),
+    };
+    let ns_ok = ns != ".."
+        && ns
+            .chars()
+            .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-'));
+    let path_ok = path.chars().all(|c| {
+        c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-' | '/')
+    });
+    (ns_ok && path_ok).then(|| format!("{ns}:{path}"))
+}
diff --git a/crates/horizon-client-core/src/key_display.rs b/crates/horizon-client-core/src/key_display.rs
new file mode 100644
index 000000000..fc57c97bd
--- /dev/null
+++ b/crates/horizon-client-core/src/key_display.rs
@@ -0,0 +1,38 @@
+//! Key display names (`InputConstants.Key.getDisplayName`), shared by key
+//! mappings and `keybind` text components.
+use crate::text::Text;
+
+/// InputConstants.Key.getDisplayName: one-character keys as the upper-case
+/// character, others by translation.
+pub fn display_name(key: &str) -> Text {
+    if let Some(rest) = key.strip_prefix("key.keyboard.")
+        && rest.chars().count() == 1
+    {
+        let c = rest.to_uppercase();
+        return Text::literal(c);
+    }
+    let symbol = match key {
+        "key.keyboard.minus" => Some("-"),
+        "key.keyboard.equal" => Some("="),
+        "key.keyboard.left.bracket" => Some("["),
+        "key.keyboard.right.bracket" => Some("]"),
+        "key.keyboard.backslash" => Some("\\"),
+        "key.keyboard.semicolon" => Some(";"),
+        "key.keyboard.apostrophe" => Some("'"),
+        "key.keyboard.grave.accent" => Some("`"),
+        "key.keyboard.comma" => Some(","),
+        "key.keyboard.period" => Some("."),
+        "key.keyboard.slash" => Some("/"),
+        _ => None,
+    };
+    if let Some(s) = symbol {
+        return Text::literal(s);
+    }
+    if let Some(n) = key.strip_prefix("key.mouse.")
+        && n.parse::<u32>().is_ok()
+        && !crate::lang::has(key)
+    {
+        return Text::translate("key.mouse", &[Text::literal(n)]);
+    }
+    Text::translate(key, &[])
+}
diff --git a/crates/horizon-client/src/lang.rs b/crates/horizon-client-core/src/lang.rs
similarity index 96%
rename from crates/horizon-client/src/lang.rs
rename to crates/horizon-client-core/src/lang.rs
index cb96cc373..6213cedc8 100644
--- a/crates/horizon-client/src/lang.rs
+++ b/crates/horizon-client-core/src/lang.rs
@@ -42,8 +42,12 @@ struct Bundled;
 impl ResourceSource for Bundled {
     fn read(&self, path: &str) -> Option<Vec<u8>> {
         let body = match path {
-            "assets/horizon/lang/en_us.json" => include_str!("../assets/horizon/lang/en_us.json"),
-            "assets/horizon/lang/ru_ru.json" => include_str!("../assets/horizon/lang/ru_ru.json"),
+            "assets/horizon/lang/en_us.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/en_us.json")
+            }
+            "assets/horizon/lang/ru_ru.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ru_ru.json")
+            }
             _ => return None,
         };
         Some(body.as_bytes().to_vec())
diff --git a/crates/horizon-client-core/src/lib.rs b/crates/horizon-client-core/src/lib.rs
new file mode 100644
index 000000000..ca40141d1
--- /dev/null
+++ b/crates/horizon-client-core/src/lib.rs
@@ -0,0 +1,23 @@
+//! The client's lowest layer, below commands and gameplay: chat text and
+//! translations, SNBT and NBT paths, text components, the scoreboard, boss
+//! bars, game rules, block entity NBT tables, and the registry, particle and
+//! sound source tables commands name. horizon-client re-exports each module
+//! under its old path (`horizon_client::text`, ...).
+#![forbid(unsafe_code)]
+pub mod block_entity_nbt;
+pub mod bossbar;
+pub mod component;
+pub mod fastutil_order;
+pub mod gamerules;
+pub mod identifier;
+pub mod key_display;
+pub mod lang;
+pub mod nbt_path;
+pub mod particle_type;
+pub mod registries;
+pub mod scoreboard;
+pub mod snbt;
+pub mod sound_source;
+pub mod text;
+pub mod uuid;
+pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
diff --git a/crates/horizon-client/src/nbt_path.rs b/crates/horizon-client-core/src/nbt_path.rs
similarity index 100%
rename from crates/horizon-client/src/nbt_path.rs
rename to crates/horizon-client-core/src/nbt_path.rs
diff --git a/crates/horizon-client-core/src/particle_type.rs b/crates/horizon-client-core/src/particle_type.rs
new file mode 100644
index 000000000..98de2380b
--- /dev/null
+++ b/crates/horizon-client-core/src/particle_type.rs
@@ -0,0 +1,209 @@
+//! Particle types (`ParticleTypes`): the vanilla particle types with a client
+//! implementation, by registry name, and their per-type flags.
+
+macro_rules! particle_types {
+    ($($variant:ident = $name:literal),* $(,)?) => {
+        /// Vanilla particle types with a client implementation here.
+        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+        pub enum ParticleType { $($variant),* }
+        impl ParticleType {
+            pub const ALL: &'static [ParticleType] = &[$(ParticleType::$variant),*];
+            /// Registry path (`minecraft:<name>`), also the sprite-set file name.
+            pub fn name(self) -> &'static str {
+                match self { $(ParticleType::$variant => $name),* }
+            }
+            pub fn from_name(name: &str) -> Option<Self> {
+                let name = name.strip_prefix("minecraft:").unwrap_or(name);
+                match name { $($name => Some(ParticleType::$variant),)* _ => None }
+            }
+        }
+    };
+}
+particle_types! {
+    Block = "block",
+    BlockCrumble = "block_crumble",
+    Trail = "trail",
+    DustPillar = "dust_pillar",
+    FallingDust = "falling_dust",
+    Smoke = "smoke",
+    LargeSmoke = "large_smoke",
+    WhiteSmoke = "white_smoke",
+    Flame = "flame",
+    SoulFireFlame = "soul_fire_flame",
+    CopperFireFlame = "copper_fire_flame",
+    SmallFlame = "small_flame",
+    Lava = "lava",
+    DrippingWater = "dripping_water",
+    FallingWater = "falling_water",
+    DrippingLava = "dripping_lava",
+    FallingLava = "falling_lava",
+    LandingLava = "landing_lava",
+    DrippingHoney = "dripping_honey",
+    FallingHoney = "falling_honey",
+    LandingHoney = "landing_honey",
+    FallingNectar = "falling_nectar",
+    FallingSporeBlossom = "falling_spore_blossom",
+    SporeBlossomAir = "spore_blossom_air",
+    DrippingObsidianTear = "dripping_obsidian_tear",
+    FallingObsidianTear = "falling_obsidian_tear",
+    LandingObsidianTear = "landing_obsidian_tear",
+    DrippingDripstoneWater = "dripping_dripstone_water",
+    FallingDripstoneWater = "falling_dripstone_water",
+    DrippingDripstoneLava = "dripping_dripstone_lava",
+    FallingDripstoneLava = "falling_dripstone_lava",
+    Splash = "splash",
+    Rain = "rain",
+    Bubble = "bubble",
+    SulfurBubbles = "sulfur_bubbles",
+    BubblePop = "bubble_pop",
+    BubbleColumnUp = "bubble_column_up",
+    CurrentDown = "current_down",
+    Underwater = "underwater",
+    Portal = "portal",
+    ReversePortal = "reverse_portal",
+    Enchant = "enchant",
+    Nautilus = "nautilus",
+    VaultConnection = "vault_connection",
+    Crit = "crit",
+    EnchantedHit = "enchanted_hit",
+    DamageIndicator = "damage_indicator",
+    Heart = "heart",
+    AngryVillager = "angry_villager",
+    HappyVillager = "happy_villager",
+    Composter = "composter",
+    Mycelium = "mycelium",
+    Dolphin = "dolphin",
+    EggCrack = "egg_crack",
+    Poof = "poof",
+    Explosion = "explosion",
+    ExplosionEmitter = "explosion_emitter",
+    CampfireCosySmoke = "campfire_cosy_smoke",
+    CampfireSignalSmoke = "campfire_signal_smoke",
+    Note = "note",
+    Dust = "dust",
+    TotemOfUndying = "totem_of_undying",
+    Firework = "firework",
+    EndRod = "end_rod",
+    Ash = "ash",
+    WhiteAsh = "white_ash",
+    CrimsonSpore = "crimson_spore",
+    WarpedSpore = "warped_spore",
+    CherryLeaves = "cherry_leaves",
+    PaleOakLeaves = "pale_oak_leaves",
+    TintedLeaves = "tinted_leaves",
+    Effect = "effect",
+    InstantEffect = "instant_effect",
+    EntityEffect = "entity_effect",
+    Witch = "witch",
+    Infested = "infested",
+    Cloud = "cloud",
+    Sneeze = "sneeze",
+    Snowflake = "snowflake",
+    Soul = "soul",
+    SculkSoul = "sculk_soul",
+    DragonBreath = "dragon_breath",
+    Gust = "gust",
+    SmallGust = "small_gust",
+    GustEmitterLarge = "gust_emitter_large",
+    GustEmitterSmall = "gust_emitter_small",
+    DustColorTransition = "dust_color_transition",
+    SculkCharge = "sculk_charge",
+    SculkChargePop = "sculk_charge_pop",
+    Shriek = "shriek",
+    SonicBoom = "sonic_boom",
+    Vibration = "vibration",
+    SweepAttack = "sweep_attack",
+    Glow = "glow",
+    WaxOn = "wax_on",
+    WaxOff = "wax_off",
+    ElectricSpark = "electric_spark",
+    Scrape = "scrape",
+    SquidInk = "squid_ink",
+    GlowSquidInk = "glow_squid_ink",
+    Item = "item",
+    ItemSlime = "item_slime",
+    ItemSnowball = "item_snowball",
+    ItemCobweb = "item_cobweb",
+    SulfurCubeGoo = "sulfur_cube_goo",
+    Flash = "flash",
+    Firefly = "firefly",
+    TrialSpawnerDetection = "trial_spawner_detection",
+    TrialSpawnerDetectionOminous = "trial_spawner_detection_ominous",
+    TrialOmen = "trial_omen",
+    RaidOmen = "raid_omen",
+    OminousSpawning = "ominous_spawning",
+    Spit = "spit",
+    Fishing = "fishing",
+    DustPlume = "dust_plume",
+    RedPoplarLeaves = "red_poplar_leaves",
+    OrangePoplarLeaves = "orange_poplar_leaves",
+    YellowPoplarLeaves = "yellow_poplar_leaves",
+    PauseMobGrowth = "pause_mob_growth",
+    ResetMobGrowth = "reset_mob_growth",
+    BlockMarker = "block_marker",
+}
+impl ParticleType {
+    /// `ParticleType.getOverrideLimiter` (`ParticleTypes.register(name, true)`):
+    /// spawned regardless of distance.
+    pub fn override_limiter(self) -> bool {
+        matches!(
+            self,
+            Self::BlockMarker
+                | Self::DamageIndicator
+                | Self::ExplosionEmitter
+                | Self::Explosion
+                | Self::Gust
+                | Self::GustEmitterLarge
+                | Self::GustEmitterSmall
+                | Self::SonicBoom
+                | Self::SculkCharge
+                | Self::SculkChargePop
+                | Self::Vibration
+                | Self::Poof
+                | Self::Spit
+                | Self::SquidInk
+                | Self::SweepAttack
+                | Self::CampfireCosySmoke
+                | Self::CampfireSignalSmoke
+                | Self::GlowSquidInk
+                | Self::Glow
+                | Self::WaxOn
+                | Self::WaxOff
+                | Self::ElectricSpark
+                | Self::Scrape
+                | Self::TrialSpawnerDetection
+                | Self::TrialSpawnerDetectionOminous
+                | Self::VaultConnection
+                | Self::OminousSpawning
+        )
+    }
+    /// `SingleQuadParticle.Layer.translucent`: types whose vanilla particle class
+    /// hardcodes the translucent layer, drawn after translucent terrain.
+    /// `TerrainParticle`, `BreakingItemParticle` and `BlockMarker` resolve their
+    /// layer from the sprite instead (`Layer.bySprite`); see the `translucent`
+    /// sprite set on the engine.
+    pub fn translucent_layer(self) -> bool {
+        match self {
+            // CampfireSmokeParticle.
+            Self::CampfireCosySmoke | Self::CampfireSignalSmoke
+            // PlayerCloudParticle.
+            | Self::Cloud | Self::Sneeze
+            // SpellParticle.
+            | Self::Effect | Self::InstantEffect | Self::EntityEffect
+            | Self::Witch | Self::Infested | Self::TrialOmen | Self::RaidOmen
+            // EmissiveRisingParticle.
+            | Self::Soul | Self::SculkSoul
+            // SculkChargeParticle, SculkChargePopParticle, ShriekParticle,
+            // VibrationSignalParticle, FireflyParticle, OverlayParticle.
+            | Self::SculkCharge | Self::SculkChargePop | Self::Shriek
+            | Self::Vibration | Self::Firefly | Self::Flash
+            // SimpleAnimatedParticle and its subclasses: EndRodParticle,
+            // SparkParticle (firework), SquidInkParticle, TotemParticle.
+            | Self::EndRod | Self::Firework | Self::SquidInk | Self::GlowSquidInk
+            | Self::TotemOfUndying
+            // FlyTowardsPositionParticle: its LifetimeAlpha(0, 0.6, 0.25, 1) is not opaque.
+            | Self::VaultConnection => true,
+            _ => false,
+        }
+    }
+}
diff --git a/crates/horizon-client-core/src/registries.rs b/crates/horizon-client-core/src/registries.rs
new file mode 100644
index 000000000..310115cf8
--- /dev/null
+++ b/crates/horizon-client-core/src/registries.rs
@@ -0,0 +1,188 @@
+//! Registry contents and source state that commands validate and complete
+//! arguments against (what the server's registry access holds).
+use std::collections::BTreeMap;
+
+/// Registry contents and source state used to validate and complete arguments.
+#[derive(Clone, Debug, Default)]
+pub struct Registries {
+    /// Permission level of the command source.
+    pub permission: u8,
+    pub items: Vec<String>,
+    pub item_tags: Vec<String>,
+    /// Block id -> (property, allowed values).
+    pub blocks: BTreeMap<String, Vec<(String, Vec<String>)>>,
+    pub block_tags: Vec<String>,
+    /// Entity types that `summon` can create.
+    pub summonable: Vec<String>,
+    /// Every entity type (selector `type=`).
+    pub entity_types: Vec<String>,
+    pub effects: Vec<String>,
+    pub enchantments: Vec<String>,
+    pub structures: Vec<String>,
+    pub biomes: Vec<String>,
+    pub dimensions: Vec<String>,
+    pub clocks: Vec<String>,
+    pub timelines: Vec<String>,
+    pub time_markers: Vec<String>,
+    pub advancements: Vec<String>,
+    /// Game rule name -> integer-valued.
+    pub game_rules: Vec<(String, bool)>,
+    pub players: Vec<String>,
+    /// Scoreboard objective names, team names and tracked score holders.
+    pub objectives: Vec<String>,
+    pub teams: Vec<String>,
+    pub tracked: Vec<String>,
+    /// Loaded datapack functions (`ns:path`) and function tags (`ns:path`).
+    pub functions: Vec<String>,
+    /// `/data ... storage` ids.
+    pub storages: Vec<String>,
+    /// Boss bar ids and datapack predicate ids.
+    pub bossbars: Vec<String>,
+    pub predicates: Vec<String>,
+    pub item_modifiers: Vec<String>,
+    pub schedules: Vec<String>,
+    pub stopwatches: Vec<String>,
+    pub recipes: Vec<String>,
+    pub sounds: Vec<String>,
+    pub damage_types: Vec<String>,
+    pub attributes: Vec<String>,
+    pub loot_tables: Vec<String>,
+    pub templates: Vec<String>,
+    pub random_sequences: Vec<String>,
+    pub datapacks_enabled: Vec<String>,
+    pub datapacks_disabled: Vec<String>,
+    pub function_tags: Vec<String>,
+    /// The block the source is looking at (relevant coordinates).
+    pub target_block: Option<[i32; 3]>,
+    /// Every registry's element and tag ids (`minecraft:item` -> ...), as
+    /// the server's registry access and reloadable registries hold them.
+    pub by_registry: BTreeMap<String, RegistryIds>,
+    /// Blocks whose default state has a block entity.
+    pub block_entities: std::collections::BTreeSet<String>,
+    /// Block tag -> member blocks.
+    pub block_tag_members: BTreeMap<String, Vec<String>>,
+    /// Data component types with a codec (not transient).
+    pub persistent_components: Vec<String>,
+    /// Recipes `/recipe` can give (not special).
+    pub learnable_recipes: Vec<String>,
+    /// Advancement id -> criterion names.
+    pub advancement_criteria: BTreeMap<String, Vec<String>>,
+    /// World clock -> time markers shown in commands.
+    pub clock_time_markers: BTreeMap<String, Vec<String>>,
+    /// Trigger objectives the source may use (`/trigger` suggestions).
+    pub trigger_objectives: Vec<String>,
+    /// Objectives with the `trigger` criterion -> holder -> whether its score is locked.
+    pub trigger_scores: BTreeMap<String, BTreeMap<String, bool>>,
+}
+/// The ids and tag ids of one registry.
+#[derive(Clone, Debug, Default)]
+pub struct RegistryIds {
+    pub ids: Vec<String>,
+    pub tags: Vec<String>,
+}
+const EMPTY: &[String] = &[];
+impl Registries {
+    /// Fill what the game did not build itself from vanilla's exported
+    /// registries (`command-registries.json`, written by
+    /// `VanillaCommandParseOracle registries`): built-in registries such as
+    /// mob effects, data component types and dialogs, block entities and tag
+    /// members. Registries that data packs reload stay with the game.
+    pub fn fill_from_export(&mut self, r: &serde_json::Value) {
+        fn strings(v: &serde_json::Value) -> Vec<String> {
+            v.as_array()
+                .map(|a| {
+                    a.iter()
+                        .filter_map(|x| x.as_str().map(str::to_owned))
+                        .collect()
+                })
+                .unwrap_or_default()
+        }
+        let fill = |field: &mut Vec<String>, key: &str| {
+            if field.is_empty() {
+                *field = strings(&r[key]);
+            }
+        };
+        fill(&mut self.effects, "effects");
+        fill(&mut self.enchantments, "enchantments");
+        fill(&mut self.attributes, "attributes");
+        fill(&mut self.damage_types, "damage_types");
+        fill(&mut self.templates, "templates");
+        fill(&mut self.persistent_components, "persistent_components");
+        fill(&mut self.learnable_recipes, "learnable_recipes");
+        const RELOADED: [&str; 5] = [
+            "minecraft:advancement",
+            "minecraft:recipe",
+            "minecraft:loot_table",
+            "minecraft:predicate",
+            "minecraft:item_modifier",
+        ];
+        for (name, entry) in r["by_registry"].as_object().into_iter().flatten() {
+            if RELOADED.contains(&name.as_str()) || self.by_registry.contains_key(name) {
+                continue;
+            }
+            self.by_registry.insert(
+                name.clone(),
+                RegistryIds {
+                    ids: strings(&entry["ids"]),
+                    tags: strings(&entry["tags"]),
+                },
+            );
+        }
+        if self.block_entities.is_empty() {
+            self.block_entities = strings(&r["block_entities"]).into_iter().collect();
+        }
+        if self.block_tag_members.is_empty() {
+            for (tag, members) in r["block_tag_members"].as_object().into_iter().flatten() {
+                self.block_tag_members.insert(tag.clone(), strings(members));
+            }
+        }
+        if self.clock_time_markers.is_empty() {
+            for (clock, markers) in r["clock_time_markers"].as_object().into_iter().flatten() {
+                self.clock_time_markers
+                    .insert(clock.clone(), strings(markers));
+            }
+        }
+        if self.advancement_criteria.is_empty() {
+            for (id, criteria) in r["advancement_criteria"].as_object().into_iter().flatten() {
+                self.advancement_criteria
+                    .insert(id.clone(), strings(criteria));
+            }
+        }
+    }
+    /// The element ids of a registry (sorted).
+    pub fn ids(&self, registry: &str) -> &[String] {
+        if let Some(r) = self.by_registry.get(registry) {
+            return &r.ids;
+        }
+        match registry {
+            "minecraft:item" => &self.items,
+            "minecraft:entity_type" => &self.entity_types,
+            "minecraft:mob_effect" => &self.effects,
+            "minecraft:enchantment" => &self.enchantments,
+            "minecraft:worldgen/structure" => &self.structures,
+            "minecraft:worldgen/biome" => &self.biomes,
+            "minecraft:world_clock" => &self.clocks,
+            "minecraft:timeline" => &self.timelines,
+            "minecraft:attribute" => &self.attributes,
+            "minecraft:damage_type" => &self.damage_types,
+            "minecraft:sound_event" => &self.sounds,
+            "minecraft:predicate" => &self.predicates,
+            "minecraft:item_modifier" => &self.item_modifiers,
+            "minecraft:loot_table" => &self.loot_tables,
+            "minecraft:recipe" => &self.recipes,
+            "minecraft:advancement" => &self.advancements,
+            _ => EMPTY,
+        }
+    }
+    /// The tag ids of a registry (sorted).
+    pub fn tags(&self, registry: &str) -> &[String] {
+        if let Some(r) = self.by_registry.get(registry) {
+            return &r.tags;
+        }
+        match registry {
+            "minecraft:item" => &self.item_tags,
+            "minecraft:block" => &self.block_tags,
+            _ => EMPTY,
+        }
+    }
+}
diff --git a/crates/horizon-client/src/scoreboard.rs b/crates/horizon-client-core/src/scoreboard.rs
similarity index 99%
rename from crates/horizon-client/src/scoreboard.rs
rename to crates/horizon-client-core/src/scoreboard.rs
index 4796be51a..3e820e4eb 100644
--- a/crates/horizon-client/src/scoreboard.rs
+++ b/crates/horizon-client-core/src/scoreboard.rs
@@ -2,9 +2,9 @@
 //! `ObjectiveCriteria`, `NumberFormat`) and its saved data
 //! (`data/minecraft/scoreboard.dat`, `ScoreboardSaveData.Packed`).
 use crate::{
-    command::Registries,
     component,
     fastutil_order::{HashSetOrder, OpenOrder},
+    registries::Registries,
     text::{self, Style, Text},
 };
 use horizon_world::nbt::Tag;
@@ -1266,7 +1266,7 @@ fn entity_uuids(tag: &mut Tag) {
                             })
                             .collect::<Option<Vec<i32>>>(),
                         Tag::String(s) => {
-                            crate::save::uuid_from_text(&s.to_string_lossy()).map(Vec::from)
+                            crate::uuid::uuid_from_text(&s.to_string_lossy()).map(Vec::from)
                         }
                         _ => None,
                     };
diff --git a/crates/horizon-client/src/snbt.rs b/crates/horizon-client-core/src/snbt.rs
similarity index 100%
rename from crates/horizon-client/src/snbt.rs
rename to crates/horizon-client-core/src/snbt.rs
diff --git a/crates/horizon-client-core/src/sound_source.rs b/crates/horizon-client-core/src/sound_source.rs
new file mode 100644
index 000000000..d181d6ac5
--- /dev/null
+++ b/crates/horizon-client-core/src/sound_source.rs
@@ -0,0 +1,7 @@
+//! Sound sources (`SoundSource`), by name.
+
+/// SoundSource names in vanilla order.
+pub const SOUND_SOURCES: [&str; 11] = [
+    "master", "music", "record", "weather", "block", "hostile", "neutral", "player", "ambient",
+    "voice", "ui",
+];
diff --git a/crates/horizon-client/src/text.rs b/crates/horizon-client-core/src/text.rs
similarity index 99%
rename from crates/horizon-client/src/text.rs
rename to crates/horizon-client-core/src/text.rs
index 4c04c9da5..0a2b6eadb 100644
--- a/crates/horizon-client/src/text.rs
+++ b/crates/horizon-client-core/src/text.rs
@@ -67,7 +67,7 @@ pub struct Style {
 }
 /// A style's `font` field: an identifier (`alt` is `minecraft:alt`).
 pub fn font_id(v: &Value) -> Option<String> {
-    crate::command::args::parse_identifier(v.as_str()?)
+    crate::identifier::parse_identifier(v.as_str()?)
 }
 impl Style {
     pub fn color(c: u32) -> Self {
diff --git a/crates/horizon-client-core/src/uuid.rs b/crates/horizon-client-core/src/uuid.rs
new file mode 100644
index 000000000..4ede9b141
--- /dev/null
+++ b/crates/horizon-client-core/src/uuid.rs
@@ -0,0 +1,24 @@
+//! UUIDs as vanilla's four-int form, to and from their text form.
+
+pub fn uuid_text(u: [i32; 4]) -> String {
+    let hex: String = u.iter().map(|v| format!("{:08x}", *v as u32)).collect();
+    format!(
+        "{}-{}-{}-{}-{}",
+        &hex[0..8],
+        &hex[8..12],
+        &hex[12..16],
+        &hex[16..20],
+        &hex[20..32]
+    )
+}
+pub fn uuid_from_text(s: &str) -> Option<[i32; 4]> {
+    let hex: String = s.chars().filter(|c| *c != '-').collect();
+    if hex.len() != 32 {
+        return None;
+    }
+    let mut out = [0i32; 4];
+    for (i, v) in out.iter_mut().enumerate() {
+        *v = u32::from_str_radix(&hex[i * 8..i * 8 + 8], 16).ok()? as i32;
+    }
+    Some(out)
+}
diff --git a/crates/horizon-client/Cargo.toml b/crates/horizon-client/Cargo.toml
index d7c6d812b..923a48a34 100644
--- a/crates/horizon-client/Cargo.toml
+++ b/crates/horizon-client/Cargo.toml
@@ -9,6 +9,8 @@ description = "Horizon native development client"
 
 [dependencies]
 horizon-assets = { path = "../horizon-assets" }
+horizon-client-core = { path = "../horizon-client-core" }
+horizon-command = { path = "../horizon-command" }
 horizon-core = { path = "../horizon-core" }
 # The server thread ahead of the workers (MinecraftServer.spin's Thread.setPriority).
 horizon-threads = { path = "../horizon-threads" }
diff --git a/crates/horizon-client/src/keybinds.rs b/crates/horizon-client/src/keybinds.rs
index a59aa627c..fb0d04344 100644
--- a/crates/horizon-client/src/keybinds.rs
+++ b/crates/horizon-client/src/keybinds.rs
@@ -2,7 +2,6 @@
 //! defaults, `key_<name>:key.keyboard.x` persistence, display names, and the
 //! translation of rebound physical keys back to the default keys the game
 //! logic listens for.
-use crate::text::Text;
 use std::collections::BTreeMap;
 use winit::{event::MouseButton, keyboard::KeyCode};
 
@@ -225,40 +224,7 @@ pub fn mouse_button(name: &str) -> Option<MouseButton> {
         _ => return None,
     })
 }
-/// InputConstants.Key.getDisplayName: one-character keys as the upper-case
-/// character, others by translation.
-pub fn display_name(key: &str) -> Text {
-    if let Some(rest) = key.strip_prefix("key.keyboard.")
-        && rest.chars().count() == 1
-    {
-        let c = rest.to_uppercase();
-        return Text::literal(c);
-    }
-    let symbol = match key {
-        "key.keyboard.minus" => Some("-"),
-        "key.keyboard.equal" => Some("="),
-        "key.keyboard.left.bracket" => Some("["),
-        "key.keyboard.right.bracket" => Some("]"),
-        "key.keyboard.backslash" => Some("\\"),
-        "key.keyboard.semicolon" => Some(";"),
-        "key.keyboard.apostrophe" => Some("'"),
-        "key.keyboard.grave.accent" => Some("`"),
-        "key.keyboard.comma" => Some(","),
-        "key.keyboard.period" => Some("."),
-        "key.keyboard.slash" => Some("/"),
-        _ => None,
-    };
-    if let Some(s) = symbol {
-        return Text::literal(s);
-    }
-    if let Some(n) = key.strip_prefix("key.mouse.")
-        && n.parse::<u32>().is_ok()
-        && !crate::lang::has(key)
-    {
-        return Text::translate("key.mouse", &[Text::literal(n)]);
-    }
-    Text::translate(key, &[])
-}
+pub use horizon_client_core::key_display::display_name;
 
 /// Current bindings by mapping name.
 #[derive(Clone, Debug, PartialEq, Eq)]
diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs
index 6bf40d1f0..232904b7a 100644
--- a/crates/horizon-client/src/lib.rs
+++ b/crates/horizon-client/src/lib.rs
@@ -19,13 +19,11 @@ pub mod biome;
 pub mod block_entities;
 pub mod block_entity_anim;
 pub mod block_entity_item;
-pub mod block_entity_nbt;
 pub mod block_entity_render;
 pub mod block_transform;
 pub mod blocks;
 pub mod border_render;
 pub mod boss_overlay;
-pub mod bossbar;
 pub mod breaking;
 pub mod brewing;
 pub mod bundle;
@@ -38,10 +36,8 @@ pub mod clipboard;
 pub mod clock;
 pub mod clouds;
 pub mod collisions;
-pub mod command;
 pub mod command_block;
 pub mod command_storage;
-pub mod component;
 pub mod confirm_screen;
 pub mod container_screen;
 pub mod containers;
@@ -70,7 +66,6 @@ pub mod extras;
 pub mod extras_hud;
 pub mod falling_block;
 pub mod fast_hash;
-pub mod fastutil_order;
 pub mod fire_render;
 pub mod first_person;
 pub mod flatgen;
@@ -79,7 +74,6 @@ pub mod font;
 pub mod friends_screen;
 pub mod game_mode_switcher;
 pub mod gamepad;
-pub mod gamerules;
 pub mod gfx;
 pub mod gizmos;
 pub mod gossip;
@@ -108,7 +102,6 @@ pub mod keybinds;
 pub mod keymapping;
 pub mod lan;
 pub mod landing;
-pub mod lang;
 pub mod level_loading;
 pub mod light;
 pub mod locator_bar;
@@ -130,7 +123,6 @@ pub mod mouse;
 pub mod moved_extras;
 pub mod multiplayer;
 pub mod music;
-pub mod nbt_path;
 pub mod net;
 pub mod nether_portal;
 pub mod offline_name;
@@ -159,7 +151,6 @@ pub mod recipe_book;
 pub mod recipe_book_screen;
 pub mod reconnect;
 pub mod save;
-pub mod scoreboard;
 pub mod scoreboard_cmd;
 pub mod screen_draw;
 pub mod screen_effects;
@@ -172,7 +163,6 @@ pub mod shader_pack_list;
 pub mod shadows;
 pub mod signs;
 pub mod skins;
-pub mod snbt;
 pub mod sound_engine;
 pub mod sound_events;
 pub mod spans;
@@ -185,7 +175,6 @@ pub mod structure_blocks;
 pub mod tab_list;
 pub mod telemetry;
 pub mod testgen;
-pub mod text;
 pub mod text_display;
 pub mod tick_chunk_membership;
 pub mod ticket_levels;
@@ -205,4 +194,15 @@ pub mod world;
 pub mod world_spawn;
 pub mod worldborder;
 pub mod zip;
-pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
+pub use horizon_client_core::Result;
+pub use horizon_client_core::block_entity_nbt;
+pub use horizon_client_core::bossbar;
+pub use horizon_client_core::component;
+pub use horizon_client_core::fastutil_order;
+pub use horizon_client_core::gamerules;
+pub use horizon_client_core::lang;
+pub use horizon_client_core::nbt_path;
+pub use horizon_client_core::scoreboard;
+pub use horizon_client_core::snbt;
+pub use horizon_client_core::text;
+pub use horizon_command as command;
diff --git a/crates/horizon-client/src/particles.rs b/crates/horizon-client/src/particles.rs
index fa9dc9c6e..17064c163 100644
--- a/crates/horizon-client/src/particles.rs
+++ b/crates/horizon-client/src/particles.rs
@@ -23,212 +23,7 @@ use std::{
     path::Path,
 };
 
-macro_rules! particle_types {
-    ($($variant:ident = $name:literal),* $(,)?) => {
-        /// Vanilla particle types with a client implementation here.
-        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-        pub enum ParticleType { $($variant),* }
-        impl ParticleType {
-            pub const ALL: &'static [ParticleType] = &[$(ParticleType::$variant),*];
-            /// Registry path (`minecraft:<name>`), also the sprite-set file name.
-            pub fn name(self) -> &'static str {
-                match self { $(ParticleType::$variant => $name),* }
-            }
-            pub fn from_name(name: &str) -> Option<Self> {
-                let name = name.strip_prefix("minecraft:").unwrap_or(name);
-                match name { $($name => Some(ParticleType::$variant),)* _ => None }
-            }
-        }
-    };
-}
-particle_types! {
-    Block = "block",
-    BlockCrumble = "block_crumble",
-    Trail = "trail",
-    DustPillar = "dust_pillar",
-    FallingDust = "falling_dust",
-    Smoke = "smoke",
-    LargeSmoke = "large_smoke",
-    WhiteSmoke = "white_smoke",
-    Flame = "flame",
-    SoulFireFlame = "soul_fire_flame",
-    CopperFireFlame = "copper_fire_flame",
-    SmallFlame = "small_flame",
-    Lava = "lava",
-    DrippingWater = "dripping_water",
-    FallingWater = "falling_water",
-    DrippingLava = "dripping_lava",
-    FallingLava = "falling_lava",
-    LandingLava = "landing_lava",
-    DrippingHoney = "dripping_honey",
-    FallingHoney = "falling_honey",
-    LandingHoney = "landing_honey",
-    FallingNectar = "falling_nectar",
-    FallingSporeBlossom = "falling_spore_blossom",
-    SporeBlossomAir = "spore_blossom_air",
-    DrippingObsidianTear = "dripping_obsidian_tear",
-    FallingObsidianTear = "falling_obsidian_tear",
-    LandingObsidianTear = "landing_obsidian_tear",
-    DrippingDripstoneWater = "dripping_dripstone_water",
-    FallingDripstoneWater = "falling_dripstone_water",
-    DrippingDripstoneLava = "dripping_dripstone_lava",
-    FallingDripstoneLava = "falling_dripstone_lava",
-    Splash = "splash",
-    Rain = "rain",
-    Bubble = "bubble",
-    SulfurBubbles = "sulfur_bubbles",
-    BubblePop = "bubble_pop",
-    BubbleColumnUp = "bubble_column_up",
-    CurrentDown = "current_down",
-    Underwater = "underwater",
-    Portal = "portal",
-    ReversePortal = "reverse_portal",
-    Enchant = "enchant",
-    Nautilus = "nautilus",
-    VaultConnection = "vault_connection",
-    Crit = "crit",
-    EnchantedHit = "enchanted_hit",
-    DamageIndicator = "damage_indicator",
-    Heart = "heart",
-    AngryVillager = "angry_villager",
-    HappyVillager = "happy_villager",
-    Composter = "composter",
-    Mycelium = "mycelium",
-    Dolphin = "dolphin",
-    EggCrack = "egg_crack",
-    Poof = "poof",
-    Explosion = "explosion",
-    ExplosionEmitter = "explosion_emitter",
-    CampfireCosySmoke = "campfire_cosy_smoke",
-    CampfireSignalSmoke = "campfire_signal_smoke",
-    Note = "note",
-    Dust = "dust",
-    TotemOfUndying = "totem_of_undying",
-    Firework = "firework",
-    EndRod = "end_rod",
-    Ash = "ash",
-    WhiteAsh = "white_ash",
-    CrimsonSpore = "crimson_spore",
-    WarpedSpore = "warped_spore",
-    CherryLeaves = "cherry_leaves",
-    PaleOakLeaves = "pale_oak_leaves",
-    TintedLeaves = "tinted_leaves",
-    Effect = "effect",
-    InstantEffect = "instant_effect",
-    EntityEffect = "entity_effect",
-    Witch = "witch",
-    Infested = "infested",
-    Cloud = "cloud",
-    Sneeze = "sneeze",
-    Snowflake = "snowflake",
-    Soul = "soul",
-    SculkSoul = "sculk_soul",
-    DragonBreath = "dragon_breath",
-    Gust = "gust",
-    SmallGust = "small_gust",
-    GustEmitterLarge = "gust_emitter_large",
-    GustEmitterSmall = "gust_emitter_small",
-    DustColorTransition = "dust_color_transition",
-    SculkCharge = "sculk_charge",
-    SculkChargePop = "sculk_charge_pop",
-    Shriek = "shriek",
-    SonicBoom = "sonic_boom",
-    Vibration = "vibration",
-    SweepAttack = "sweep_attack",
-    Glow = "glow",
-    WaxOn = "wax_on",
-    WaxOff = "wax_off",
-    ElectricSpark = "electric_spark",
-    Scrape = "scrape",
-    SquidInk = "squid_ink",
-    GlowSquidInk = "glow_squid_ink",
-    Item = "item",
-    ItemSlime = "item_slime",
-    ItemSnowball = "item_snowball",
-    ItemCobweb = "item_cobweb",
-    SulfurCubeGoo = "sulfur_cube_goo",
-    Flash = "flash",
-    Firefly = "firefly",
-    TrialSpawnerDetection = "trial_spawner_detection",
-    TrialSpawnerDetectionOminous = "trial_spawner_detection_ominous",
-    TrialOmen = "trial_omen",
-    RaidOmen = "raid_omen",
-    OminousSpawning = "ominous_spawning",
-    Spit = "spit",
-    Fishing = "fishing",
-    DustPlume = "dust_plume",
-    RedPoplarLeaves = "red_poplar_leaves",
-    OrangePoplarLeaves = "orange_poplar_leaves",
-    YellowPoplarLeaves = "yellow_poplar_leaves",
-    PauseMobGrowth = "pause_mob_growth",
-    ResetMobGrowth = "reset_mob_growth",
-    BlockMarker = "block_marker",
-}
-impl ParticleType {
-    /// `ParticleType.getOverrideLimiter` (`ParticleTypes.register(name, true)`):
-    /// spawned regardless of distance.
-    pub fn override_limiter(self) -> bool {
-        matches!(
-            self,
-            Self::BlockMarker
-                | Self::DamageIndicator
-                | Self::ExplosionEmitter
-                | Self::Explosion
-                | Self::Gust
-                | Self::GustEmitterLarge
-                | Self::GustEmitterSmall
-                | Self::SonicBoom
-                | Self::SculkCharge
-                | Self::SculkChargePop
-                | Self::Vibration
-                | Self::Poof
-                | Self::Spit
-                | Self::SquidInk
-                | Self::SweepAttack
-                | Self::CampfireCosySmoke
-                | Self::CampfireSignalSmoke
-                | Self::GlowSquidInk
-                | Self::Glow
-                | Self::WaxOn
-                | Self::WaxOff
-                | Self::ElectricSpark
-                | Self::Scrape
-                | Self::TrialSpawnerDetection
-                | Self::TrialSpawnerDetectionOminous
-                | Self::VaultConnection
-                | Self::OminousSpawning
-        )
-    }
-    /// `SingleQuadParticle.Layer.translucent`: types whose vanilla particle class
-    /// hardcodes the translucent layer, drawn after translucent terrain.
-    /// `TerrainParticle`, `BreakingItemParticle` and `BlockMarker` resolve their
-    /// layer from the sprite instead (`Layer.bySprite`); see the `translucent`
-    /// sprite set on the engine.
-    pub fn translucent_layer(self) -> bool {
-        match self {
-            // CampfireSmokeParticle.
-            Self::CampfireCosySmoke | Self::CampfireSignalSmoke
-            // PlayerCloudParticle.
-            | Self::Cloud | Self::Sneeze
-            // SpellParticle.
-            | Self::Effect | Self::InstantEffect | Self::EntityEffect
-            | Self::Witch | Self::Infested | Self::TrialOmen | Self::RaidOmen
-            // EmissiveRisingParticle.
-            | Self::Soul | Self::SculkSoul
-            // SculkChargeParticle, SculkChargePopParticle, ShriekParticle,
-            // VibrationSignalParticle, FireflyParticle, OverlayParticle.
-            | Self::SculkCharge | Self::SculkChargePop | Self::Shriek
-            | Self::Vibration | Self::Firefly | Self::Flash
-            // SimpleAnimatedParticle and its subclasses: EndRodParticle,
-            // SparkParticle (firework), SquidInkParticle, TotemParticle.
-            | Self::EndRod | Self::Firework | Self::SquidInk | Self::GlowSquidInk
-            | Self::TotemOfUndying
-            // FlyTowardsPositionParticle: its LifetimeAlpha(0, 0.6, 0.25, 1) is not opaque.
-            | Self::VaultConnection => true,
-            _ => false,
-        }
-    }
-}
+pub use horizon_client_core::particle_type::ParticleType;
 
 /// `ParticleOptions` with the parameters of the option classes used here.
 #[derive(Clone, Debug)]
diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs
index 0c353bb38..6f4082ec3 100644
--- a/crates/horizon-client/src/save.rs
+++ b/crates/horizon-client/src/save.rs
@@ -1988,28 +1988,7 @@ fn write_saved_data(world: &Path, name: &str, data: Tag) -> Result<()> {
         Tag::compound([("data", data), ("DataVersion", Tag::Int(DATA_VERSION))]),
     )
 }
-pub fn uuid_text(u: [i32; 4]) -> String {
-    let hex: String = u.iter().map(|v| format!("{:08x}", *v as u32)).collect();
-    format!(
-        "{}-{}-{}-{}-{}",
-        &hex[0..8],
-        &hex[8..12],
-        &hex[12..16],
-        &hex[16..20],
-        &hex[20..32]
-    )
-}
-pub fn uuid_from_text(s: &str) -> Option<[i32; 4]> {
-    let hex: String = s.chars().filter(|c| *c != '-').collect();
-    if hex.len() != 32 {
-        return None;
-    }
-    let mut out = [0i32; 4];
-    for (i, v) in out.iter_mut().enumerate() {
-        *v = u32::from_str_radix(&hex[i * 8..i * 8 + 8], 16).ok()? as i32;
-    }
-    Some(out)
-}
+pub use horizon_client_core::uuid::{uuid_from_text, uuid_text};
 /// A random (version 4) UUID as vanilla's four-int form.
 pub fn random_uuid() -> [i32; 4] {
     let t = std::time::SystemTime::now()
@@ -4382,4 +4361,28 @@ mod tests {
         };
         assert_eq!(back.recipes_used.get("minecraft:cooked_porkchop"), Some(&3));
     }
+    /// The world's save (Level.write) writes the rules as they are now, and a
+    /// world opened again reads them back (#74).
+    #[test]
+    fn level_save_keeps_changed_rules() {
+        use crate::gamerules::{GameRules, Value};
+        let dir =
+            std::env::temp_dir().join(format!("horizon-gamerules-level-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        let mut level = super::Level::default();
+        level.write(&dir).unwrap();
+        // Rules changed while playing, then saved and loaded again.
+        let mut rules = GameRules::load(&dir);
+        assert_eq!(rules, GameRules::default());
+        assert!(rules.set("advance_time", Value::Bool(false)));
+        assert!(rules.set("advance_weather", Value::Bool(false)));
+        assert!(rules.set("random_tick_speed", Value::Int(0)));
+        level.game_rules = rules.by_name();
+        level.write(&dir).unwrap();
+        assert_eq!(GameRules::load(&dir), rules);
+        let read = super::Level::read(&dir).unwrap();
+        assert_eq!(read.game_rules, rules.by_name());
+        assert_eq!(read.game_rule("advance_time"), 0);
+        let _ = std::fs::remove_dir_all(dir);
+    }
 }
diff --git a/crates/horizon-client/src/settings.rs b/crates/horizon-client/src/settings.rs
index 74c428923..2308794d3 100644
--- a/crates/horizon-client/src/settings.rs
+++ b/crates/horizon-client/src/settings.rs
@@ -5,11 +5,7 @@ use crate::keybinds::KeyBinds;
 use crate::options_file::{OptionsFile, V};
 use std::{fs, path::Path};
 
-/// SoundSource names in vanilla order.
-pub const SOUND_SOURCES: [&str; 11] = [
-    "master", "music", "record", "weather", "block", "hostile", "neutral", "player", "ambient",
-    "voice", "ui",
-];
+pub use horizon_client_core::sound_source::SOUND_SOURCES;
 
 /// Per-source volumes for the mixer (soundCategory_* except master).
 static SOURCE_VOLUMES: std::sync::RwLock<[f32; 11]> = std::sync::RwLock::new([1.0; 11]);
diff --git a/crates/horizon-command/Cargo.toml b/crates/horizon-command/Cargo.toml
new file mode 100644
index 000000000..10191ed6f
--- /dev/null
+++ b/crates/horizon-command/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "horizon-command"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+rust-version = "1.90"
+description = "Commands (Brigadier): the vanilla command tree, argument types, selectors, parsing, suggestions and the network form of the tree"
+
+[dependencies]
+horizon-client-core = { path = "../horizon-client-core" }
+horizon-protocol = { path = "../horizon-protocol" }
+horizon-world = { path = "../horizon-world" }
+
+[lints]
+workspace = true
diff --git a/crates/horizon-client/src/command/args.rs b/crates/horizon-command/src/args.rs
similarity index 87%
rename from crates/horizon-client/src/command/args.rs
rename to crates/horizon-command/src/args.rs
index ccced67a7..9d24d672f 100644
--- a/crates/horizon-client/src/command/args.rs
+++ b/crates/horizon-command/src/args.rs
@@ -1,192 +1,8 @@
 //! Argument types (Brigadier's and Minecraft's `ArgumentType`s): parsing with
 //! the vanilla error messages and completion suggestions.
 use super::{CmdResult, CommandError, Context, Reader, SuggestionsBuilder};
-use std::collections::BTreeMap;
 
-/// Registry contents and source state used to validate and complete arguments.
-#[derive(Clone, Debug, Default)]
-pub struct Registries {
-    /// Permission level of the command source.
-    pub permission: u8,
-    pub items: Vec<String>,
-    pub item_tags: Vec<String>,
-    /// Block id -> (property, allowed values).
-    pub blocks: BTreeMap<String, Vec<(String, Vec<String>)>>,
-    pub block_tags: Vec<String>,
-    /// Entity types that `summon` can create.
-    pub summonable: Vec<String>,
-    /// Every entity type (selector `type=`).
-    pub entity_types: Vec<String>,
-    pub effects: Vec<String>,
-    pub enchantments: Vec<String>,
-    pub structures: Vec<String>,
-    pub biomes: Vec<String>,
-    pub dimensions: Vec<String>,
-    pub clocks: Vec<String>,
-    pub timelines: Vec<String>,
-    pub time_markers: Vec<String>,
-    pub advancements: Vec<String>,
-    /// Game rule name -> integer-valued.
-    pub game_rules: Vec<(String, bool)>,
-    pub players: Vec<String>,
-    /// Scoreboard objective names, team names and tracked score holders.
-    pub objectives: Vec<String>,
-    pub teams: Vec<String>,
-    pub tracked: Vec<String>,
-    /// Loaded datapack functions (`ns:path`) and function tags (`ns:path`).
-    pub functions: Vec<String>,
-    /// `/data ... storage` ids.
-    pub storages: Vec<String>,
-    /// Boss bar ids and datapack predicate ids.
-    pub bossbars: Vec<String>,
-    pub predicates: Vec<String>,
-    pub item_modifiers: Vec<String>,
-    pub schedules: Vec<String>,
-    pub stopwatches: Vec<String>,
-    pub recipes: Vec<String>,
-    pub sounds: Vec<String>,
-    pub damage_types: Vec<String>,
-    pub attributes: Vec<String>,
-    pub loot_tables: Vec<String>,
-    pub templates: Vec<String>,
-    pub random_sequences: Vec<String>,
-    pub datapacks_enabled: Vec<String>,
-    pub datapacks_disabled: Vec<String>,
-    pub function_tags: Vec<String>,
-    /// The block the source is looking at (relevant coordinates).
-    pub target_block: Option<[i32; 3]>,
-    /// Every registry's element and tag ids (`minecraft:item` -> ...), as
-    /// the server's registry access and reloadable registries hold them.
-    pub by_registry: BTreeMap<String, RegistryIds>,
-    /// Blocks whose default state has a block entity.
-    pub block_entities: std::collections::BTreeSet<String>,
-    /// Block tag -> member blocks.
-    pub block_tag_members: BTreeMap<String, Vec<String>>,
-    /// Data component types with a codec (not transient).
-    pub persistent_components: Vec<String>,
-    /// Recipes `/recipe` can give (not special).
-    pub learnable_recipes: Vec<String>,
-    /// Advancement id -> criterion names.
-    pub advancement_criteria: BTreeMap<String, Vec<String>>,
-    /// World clock -> time markers shown in commands.
-    pub clock_time_markers: BTreeMap<String, Vec<String>>,
-    /// Trigger objectives the source may use (`/trigger` suggestions).
-    pub trigger_objectives: Vec<String>,
-    /// Objectives with the `trigger` criterion -> holder -> whether its score is locked.
-    pub trigger_scores: BTreeMap<String, BTreeMap<String, bool>>,
-}
-/// The ids and tag ids of one registry.
-#[derive(Clone, Debug, Default)]
-pub struct RegistryIds {
-    pub ids: Vec<String>,
-    pub tags: Vec<String>,
-}
-const EMPTY: &[String] = &[];
-impl Registries {
-    /// Fill what the game did not build itself from vanilla's exported
-    /// registries (`command-registries.json`, written by
-    /// `VanillaCommandParseOracle registries`): built-in registries such as
-    /// mob effects, data component types and dialogs, block entities and tag
-    /// members. Registries that data packs reload stay with the game.
-    pub fn fill_from_export(&mut self, r: &serde_json::Value) {
-        fn strings(v: &serde_json::Value) -> Vec<String> {
-            v.as_array()
-                .map(|a| {
-                    a.iter()
-                        .filter_map(|x| x.as_str().map(str::to_owned))
-                        .collect()
-                })
-                .unwrap_or_default()
-        }
-        let fill = |field: &mut Vec<String>, key: &str| {
-            if field.is_empty() {
-                *field = strings(&r[key]);
-            }
-        };
-        fill(&mut self.effects, "effects");
-        fill(&mut self.enchantments, "enchantments");
-        fill(&mut self.attributes, "attributes");
-        fill(&mut self.damage_types, "damage_types");
-        fill(&mut self.templates, "templates");
-        fill(&mut self.persistent_components, "persistent_components");
-        fill(&mut self.learnable_recipes, "learnable_recipes");
-        const RELOADED: [&str; 5] = [
-            "minecraft:advancement",
-            "minecraft:recipe",
-            "minecraft:loot_table",
-            "minecraft:predicate",
-            "minecraft:item_modifier",
-        ];
-        for (name, entry) in r["by_registry"].as_object().into_iter().flatten() {
-            if RELOADED.contains(&name.as_str()) || self.by_registry.contains_key(name) {
-                continue;
-            }
-            self.by_registry.insert(
-                name.clone(),
-                RegistryIds {
-                    ids: strings(&entry["ids"]),
-                    tags: strings(&entry["tags"]),
-                },
-            );
-        }
-        if self.block_entities.is_empty() {
-            self.block_entities = strings(&r["block_entities"]).into_iter().collect();
-        }
-        if self.block_tag_members.is_empty() {
-            for (tag, members) in r["block_tag_members"].as_object().into_iter().flatten() {
-                self.block_tag_members.insert(tag.clone(), strings(members));
-            }
-        }
-        if self.clock_time_markers.is_empty() {
-            for (clock, markers) in r["clock_time_markers"].as_object().into_iter().flatten() {
-                self.clock_time_markers
-                    .insert(clock.clone(), strings(markers));
-            }
-        }
-        if self.advancement_criteria.is_empty() {
-            for (id, criteria) in r["advancement_criteria"].as_object().into_iter().flatten() {
-                self.advancement_criteria
-                    .insert(id.clone(), strings(criteria));
-            }
-        }
-    }
-    /// The element ids of a registry (sorted).
-    pub fn ids(&self, registry: &str) -> &[String] {
-        if let Some(r) = self.by_registry.get(registry) {
-            return &r.ids;
-        }
-        match registry {
-            "minecraft:item" => &self.items,
-            "minecraft:entity_type" => &self.entity_types,
-            "minecraft:mob_effect" => &self.effects,
-            "minecraft:enchantment" => &self.enchantments,
-            "minecraft:worldgen/structure" => &self.structures,
-            "minecraft:worldgen/biome" => &self.biomes,
-            "minecraft:world_clock" => &self.clocks,
-            "minecraft:timeline" => &self.timelines,
-            "minecraft:attribute" => &self.attributes,
-            "minecraft:damage_type" => &self.damage_types,
-            "minecraft:sound_event" => &self.sounds,
-            "minecraft:predicate" => &self.predicates,
-            "minecraft:item_modifier" => &self.item_modifiers,
-            "minecraft:loot_table" => &self.loot_tables,
-            "minecraft:recipe" => &self.recipes,
-            "minecraft:advancement" => &self.advancements,
-            _ => EMPTY,
-        }
-    }
-    /// The tag ids of a registry (sorted).
-    pub fn tags(&self, registry: &str) -> &[String] {
-        if let Some(r) = self.by_registry.get(registry) {
-            return &r.tags;
-        }
-        match registry {
-            "minecraft:item" => &self.item_tags,
-            "minecraft:block" => &self.block_tags,
-            _ => EMPTY,
-        }
-    }
-}
+pub use horizon_client_core::registries::{Registries, RegistryIds};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Resource {
@@ -637,22 +453,7 @@ pub fn read_identifier(reader: &mut Reader) -> CmdResult<String> {
         }
     }
 }
-/// Identifier.parse: `ns:path` or `path`, validated.
-pub fn parse_identifier(raw: &str) -> Option<String> {
-    let (ns, path) = match raw.split_once(':') {
-        Some(("", path)) => ("minecraft", path),
-        Some((ns, path)) => (ns, path),
-        None => ("minecraft", raw),
-    };
-    let ns_ok = ns != ".."
-        && ns
-            .chars()
-            .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-'));
-    let path_ok = path.chars().all(|c| {
-        c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-' | '/')
-    });
-    (ns_ok && path_ok).then(|| format!("{ns}:{path}"))
-}
+pub use horizon_client_core::identifier::parse_identifier;
 pub fn normalize(id: &str) -> String {
     match id.split_once(':') {
         Some(("", path)) => format!("minecraft:{path}"),
@@ -1220,7 +1021,10 @@ impl ArgType {
                     reader.cursor = start;
                     return Err(CommandError::tr_at(
                         "argument.float.low",
-                        &[&crate::snbt::java_float(*min), &crate::snbt::java_float(v)],
+                        &[
+                            &horizon_client_core::snbt::java_float(*min),
+                            &horizon_client_core::snbt::java_float(v),
+                        ],
                         reader,
                     ));
                 }
@@ -1228,7 +1032,10 @@ impl ArgType {
                     reader.cursor = start;
                     return Err(CommandError::tr_at(
                         "argument.float.big",
-                        &[&crate::snbt::java_float(*max), &crate::snbt::java_float(v)],
+                        &[
+                            &horizon_client_core::snbt::java_float(*max),
+                            &horizon_client_core::snbt::java_float(v),
+                        ],
                         reader,
                     ));
                 }
@@ -1241,8 +1048,8 @@ impl ArgType {
                     return Err(CommandError::tr_at(
                         "argument.double.low",
                         &[
-                            &crate::snbt::java_double(*min),
-                            &crate::snbt::java_double(v),
+                            &horizon_client_core::snbt::java_double(*min),
+                            &horizon_client_core::snbt::java_double(v),
                         ],
                         reader,
                     ));
@@ -1252,8 +1059,8 @@ impl ArgType {
                     return Err(CommandError::tr_at(
                         "argument.double.big",
                         &[
-                            &crate::snbt::java_double(*max),
-                            &crate::snbt::java_double(v),
+                            &horizon_client_core::snbt::java_double(*max),
+                            &horizon_client_core::snbt::java_double(v),
                         ],
                         reader,
                     ));
@@ -1597,7 +1404,7 @@ impl ArgType {
                     return Err(CommandError::tr_at(key, &[&m], reader));
                 }
                 let text = &reader.string[start..reader.cursor];
-                match crate::component::parse_snbt(text) {
+                match horizon_client_core::component::parse_snbt(text) {
                     Ok((v, _)) => Arg::Str(v.to_string()),
                     Err(_) => Arg::Str(text.to_owned()),
                 }
@@ -1645,7 +1452,7 @@ impl ArgType {
                 }
                 let id = &reader.string[start..reader.cursor];
                 // ObjectiveCriteria.byName: statistics resolve to their canonical name.
-                match crate::scoreboard::criteria_by_name(id, reg) {
+                match horizon_client_core::scoreboard::criteria_by_name(id, reg) {
                     Ok(Some(canonical)) => Arg::Str(canonical),
                     Ok(None) => {
                         reader.cursor = start;
@@ -1667,7 +1474,7 @@ impl ArgType {
             }
             ArgType::ScoreboardSlot => {
                 let name = reader.read_unquoted_string();
-                if !crate::scoreboard::display_slot_valid(name) {
+                if !horizon_client_core::scoreboard::display_slot_valid(name) {
                     return Err(CommandError::tr_at(
                         "argument.scoreboardDisplaySlot.invalid",
                         &[&name],
@@ -1695,7 +1502,7 @@ impl ArgType {
             }
             ArgType::TeamColor => {
                 let name = reader.read_unquoted_string();
-                if crate::scoreboard::team_color_rgb(name).is_none() {
+                if horizon_client_core::scoreboard::team_color_rgb(name).is_none() {
                     return Err(CommandError::tr_at(
                         "argument.color.invalid",
                         &[&name],
@@ -1743,7 +1550,7 @@ impl ArgType {
                 let id = read_identifier(reader)?;
                 let known = reg.ids("minecraft:particle_type");
                 let exists = if known.is_empty() {
-                    crate::particles::ParticleType::from_name(&id).is_some()
+                    horizon_client_core::particle_type::ParticleType::from_name(&id).is_some()
                 } else {
                     known.contains(&id)
                 };
@@ -1931,15 +1738,16 @@ impl ArgType {
             }
             ArgType::Team => builder.suggest_matching(reg.teams.iter().map(String::as_str)),
             ArgType::Criteria => {
-                let mut ids: Vec<String> = crate::scoreboard::CUSTOM_CRITERIA
+                let mut ids: Vec<String> = horizon_client_core::scoreboard::CUSTOM_CRITERIA
                     .iter()
                     .map(|s| (*s).to_owned())
                     .collect();
-                for c in crate::scoreboard::team_colors() {
+                for c in horizon_client_core::scoreboard::team_colors() {
                     ids.push(format!("teamkill.{c}"));
                     ids.push(format!("killedByTeam.{c}"));
                 }
-                let stat = |ty: &str, key: &str| crate::scoreboard::stat_criteria(ty, key);
+                let stat =
+                    |ty: &str, key: &str| horizon_client_core::scoreboard::stat_criteria(ty, key);
                 ids.extend(reg.blocks.keys().map(|b| stat("mined", b)));
                 for ty in ["crafted", "used", "broken", "picked_up", "dropped"] {
                     ids.extend(reg.items.iter().map(|i| stat(ty, i)));
@@ -1948,14 +1756,14 @@ impl ArgType {
                     ids.extend(reg.entity_types.iter().map(|e| stat(ty, e)));
                 }
                 ids.extend(
-                    crate::scoreboard::CUSTOM_STATS
+                    horizon_client_core::scoreboard::CUSTOM_STATS
                         .iter()
                         .map(|c| stat("custom", &format!("minecraft:{c}"))),
                 );
                 builder.suggest_matching(ids.iter().map(String::as_str));
             }
             ArgType::ScoreboardSlot => {
-                let slots = crate::scoreboard::display_slots();
+                let slots = horizon_client_core::scoreboard::display_slots();
                 builder.suggest_matching(slots.iter().map(String::as_str));
             }
             ArgType::Operation => builder.suggest_matching(OPERATIONS),
@@ -1963,7 +1771,7 @@ impl ArgType {
             ArgType::Particle => {
                 let known = reg.ids("minecraft:particle_type");
                 if known.is_empty() {
-                    let names: Vec<String> = crate::particles::ParticleType::ALL
+                    let names: Vec<String> = horizon_client_core::particle_type::ParticleType::ALL
                         .iter()
                         .map(|t| format!("minecraft:{}", t.name()))
                         .collect();
@@ -1999,7 +1807,9 @@ impl ArgType {
                 suggest_resources(builder, reg.ids("minecraft:slot_source"), "");
             }
             ArgType::ResourceOrId(registry) => suggest_resources(builder, reg.ids(registry), ""),
-            ArgType::TeamColor => builder.suggest_matching(crate::scoreboard::team_colors()),
+            ArgType::TeamColor => {
+                builder.suggest_matching(horizon_client_core::scoreboard::team_colors())
+            }
             ArgType::Anchor => builder.suggest_matching(["eyes", "feet"]),
             ArgType::Component | ArgType::Style | ArgType::NbtTag => super::snbt::suggest(builder),
             ArgType::Swizzle | ArgType::Message | ArgType::Nbt => {}
diff --git a/crates/horizon-client/src/command/block.rs b/crates/horizon-command/src/block.rs
similarity index 100%
rename from crates/horizon-client/src/command/block.rs
rename to crates/horizon-command/src/block.rs
diff --git a/crates/horizon-client/src/command/codec.rs b/crates/horizon-command/src/codec.rs
similarity index 99%
rename from crates/horizon-client/src/command/codec.rs
rename to crates/horizon-command/src/codec.rs
index 7c4d26682..40f5c1ce0 100644
--- a/crates/horizon-client/src/command/codec.rs
+++ b/crates/horizon-command/src/codec.rs
@@ -6,7 +6,7 @@ use super::{CmdResult, CommandError, Reader};
 use horizon_world::nbt::{Compound, JavaString, Tag};
 
 pub fn snbt(t: &Tag) -> String {
-    crate::snbt::to_snbt(t)
+    horizon_client_core::snbt::to_snbt(t)
 }
 pub fn not_map(t: &Tag) -> String {
     format!("Not a map: {}", snbt(t))
diff --git a/crates/horizon-client/src/command/component.rs b/crates/horizon-command/src/component.rs
similarity index 98%
rename from crates/horizon-client/src/command/component.rs
rename to crates/horizon-command/src/component.rs
index 15a8fa6a0..2933afeca 100644
--- a/crates/horizon-client/src/command/component.rs
+++ b/crates/horizon-command/src/component.rs
@@ -164,7 +164,7 @@ fn color(t: &Tag) -> R {
             _ => partial(format!("Invalid color value: {s}")),
         };
     }
-    if crate::text::named_color(&s).is_some() {
+    if horizon_client_core::text::named_color(&s).is_some() {
         Ok(())
     } else {
         partial(format!("Invalid color name: {s}"))
@@ -278,7 +278,7 @@ fn content(kind: &str, map: &Compound) -> bool {
         "nbt" => {
             let path_ok = get(map, "nbt")
                 .and_then(string_of)
-                .is_some_and(|p| crate::nbt_path::NbtPath::parse(&p).is_ok());
+                .is_some_and(|p| horizon_client_core::nbt_path::NbtPath::parse(&p).is_ok());
             let source = if let Some(e) = get(map, "entity") {
                 selector_string(e)
             } else if let Some(b) = get(map, "block") {
diff --git a/crates/horizon-client/src/command/item.rs b/crates/horizon-command/src/item.rs
similarity index 99%
rename from crates/horizon-client/src/command/item.rs
rename to crates/horizon-command/src/item.rs
index f2abc91ef..da9c4b8b0 100644
--- a/crates/horizon-client/src/command/item.rs
+++ b/crates/horizon-command/src/item.rs
@@ -72,9 +72,9 @@ pub fn decode_component(id: &str, t: &Tag) -> Result<(), String> {
                     } else {
                         format!("minecraft:{id}")
                     };
-                    let known = crate::block_entity_nbt::TYPES
+                    let known = horizon_client_core::block_entity_nbt::TYPES
                         .iter()
-                        .chain(&crate::block_entity_nbt::NEWEST)
+                        .chain(&horizon_client_core::block_entity_nbt::NEWEST)
                         .any(|k| *k == id);
                     if known {
                         Ok(())
diff --git a/crates/horizon-client/src/command/mod.rs b/crates/horizon-command/src/lib.rs
similarity index 99%
rename from crates/horizon-client/src/command/mod.rs
rename to crates/horizon-command/src/lib.rs
index a61c8c08d..838c8de87 100644
--- a/crates/horizon-client/src/command/mod.rs
+++ b/crates/horizon-command/src/lib.rs
@@ -3,6 +3,7 @@
 //! relevant child and keeps the best result, completion suggestions, smart
 //! usage text and the vanilla error messages. Argument types live in
 //! [`args`]; the vanilla command tree in [`vanilla`].
+#![forbid(unsafe_code)]
 pub mod args;
 pub mod block;
 pub mod codec;
@@ -21,8 +22,8 @@ pub mod tree_world;
 pub mod vanilla;
 mod vanilla_order;
 
-use crate::text::Text;
 pub use args::{Arg, ArgType, Registries};
+use horizon_client_core::text::Text;
 
 /// The command id of a mod's command (`Dispatcher::with_mod_commands`).
 pub const MOD_COMMAND: &str = "mod";
@@ -623,8 +624,10 @@ impl Suggests {
                 for id in &reg.summonable {
                     if args::resource_matches(&contents, id) {
                         let (ns, path) = id.split_once(':').unwrap_or(("minecraft", id));
-                        let name =
-                            crate::lang::get(&format!("entity.{ns}.{}", path.replace('/', ".")));
+                        let name = horizon_client_core::lang::get(&format!(
+                            "entity.{ns}.{}",
+                            path.replace('/', ".")
+                        ));
                         builder.suggest_tooltip(id.clone(), name);
                     }
                 }
diff --git a/crates/horizon-client/src/command/network.rs b/crates/horizon-command/src/network.rs
similarity index 100%
rename from crates/horizon-client/src/command/network.rs
rename to crates/horizon-command/src/network.rs
diff --git a/crates/horizon-client/src/command/packrat.rs b/crates/horizon-command/src/packrat.rs
similarity index 99%
rename from crates/horizon-client/src/command/packrat.rs
rename to crates/horizon-command/src/packrat.rs
index 42f42d9f4..ebe9df09d 100644
--- a/crates/horizon-client/src/command/packrat.rs
+++ b/crates/horizon-command/src/packrat.rs
@@ -402,7 +402,7 @@ impl<'g, V: Value> State<'g, V> {
                 Reason::Error(e) => e.clone(),
             };
         }
-        CommandError::new(crate::text::Text::literal("Failed to parse"))
+        CommandError::new(horizon_client_core::text::Text::literal("Failed to parse"))
     }
     /// CachedParseState.parse: a named rule, memoised per position.
     pub fn parse(&mut self, rule: RuleId) -> Option<V> {
diff --git a/crates/horizon-client/src/command/selector.rs b/crates/horizon-command/src/selector.rs
similarity index 99%
rename from crates/horizon-client/src/command/selector.rs
rename to crates/horizon-command/src/selector.rs
index eb4e637a4..777124f60 100644
--- a/crates/horizon-client/src/command/selector.rs
+++ b/crates/horizon-command/src/selector.rs
@@ -687,7 +687,7 @@ impl<'r, 'a> SelectorParser<'r, 'a> {
 
     fn fill_selectors(builder: &mut SuggestionsBuilder) {
         for (s, tip) in SELECTOR_KINDS {
-            builder.suggest_tooltip(s, crate::lang::get(tip));
+            builder.suggest_tooltip(s, horizon_client_core::lang::get(tip));
         }
     }
 
@@ -785,7 +785,9 @@ impl<'r, 'a> SelectorParser<'r, 'a> {
             if self.can_use(o) && o.starts_with(&lower) {
                 b.suggest_tooltip(
                     format!("{o}="),
-                    crate::lang::get(&format!("argument.entity.options.{o}.description")),
+                    horizon_client_core::lang::get(&format!(
+                        "argument.entity.options.{o}.description"
+                    )),
                 );
             }
         }
diff --git a/crates/horizon-client/src/command/snbt.rs b/crates/horizon-command/src/snbt.rs
similarity index 100%
rename from crates/horizon-client/src/command/snbt.rs
rename to crates/horizon-command/src/snbt.rs
diff --git a/crates/horizon-client/src/command/tests.rs b/crates/horizon-command/src/tests.rs
similarity index 100%
rename from crates/horizon-client/src/command/tests.rs
rename to crates/horizon-command/src/tests.rs
diff --git a/crates/horizon-client/src/command/tree_data.rs b/crates/horizon-command/src/tree_data.rs
similarity index 100%
rename from crates/horizon-client/src/command/tree_data.rs
rename to crates/horizon-command/src/tree_data.rs
diff --git a/crates/horizon-client/src/command/tree_execute.rs b/crates/horizon-command/src/tree_execute.rs
similarity index 100%
rename from crates/horizon-client/src/command/tree_execute.rs
rename to crates/horizon-command/src/tree_execute.rs
diff --git a/crates/horizon-client/src/command/tree_extra.rs b/crates/horizon-command/src/tree_extra.rs
similarity index 100%
rename from crates/horizon-client/src/command/tree_extra.rs
rename to crates/horizon-command/src/tree_extra.rs
diff --git a/crates/horizon-client/src/command/tree_misc.rs b/crates/horizon-command/src/tree_misc.rs
similarity index 99%
rename from crates/horizon-client/src/command/tree_misc.rs
rename to crates/horizon-command/src/tree_misc.rs
index a66fd5f37..1bcd880bb 100644
--- a/crates/horizon-client/src/command/tree_misc.rs
+++ b/crates/horizon-command/src/tree_misc.rs
@@ -230,12 +230,12 @@ fn bossbar(d: &mut Dispatcher, root: usize) {
     let name = d.argument(name_l, "name", ArgType::Component);
     d.executes(name, "bossbar.set.name");
     let color = d.literal(id, "color");
-    for c in crate::bossbar::COLORS {
+    for c in horizon_client_core::bossbar::COLORS {
         let l = d.literal(color, c);
         d.executes(l, "bossbar.set.color");
     }
     let style = d.literal(id, "style");
-    for s in crate::bossbar::STYLES {
+    for s in horizon_client_core::bossbar::STYLES {
         let l = d.literal(style, s);
         d.executes(l, "bossbar.set.style");
     }
diff --git a/crates/horizon-client/src/command/tree_scoreboard.rs b/crates/horizon-command/src/tree_scoreboard.rs
similarity index 100%
rename from crates/horizon-client/src/command/tree_scoreboard.rs
rename to crates/horizon-command/src/tree_scoreboard.rs
diff --git a/crates/horizon-client/src/command/tree_world.rs b/crates/horizon-command/src/tree_world.rs
similarity index 99%
rename from crates/horizon-client/src/command/tree_world.rs
rename to crates/horizon-command/src/tree_world.rs
index 0bd2edd3b..86ebba0ca 100644
--- a/crates/horizon-client/src/command/tree_world.rs
+++ b/crates/horizon-command/src/tree_world.rs
@@ -7,7 +7,7 @@ use super::{
     args::{ArgType, integer},
     vanilla::{ENTITIES, ENTITY, GAMEMASTERS, PLAYERS},
 };
-use crate::settings::SOUND_SOURCES;
+use horizon_client_core::sound_source::SOUND_SOURCES;
 
 fn float(min: f32) -> ArgType {
     ArgType::Float { min, max: f32::MAX }
diff --git a/crates/horizon-client/src/command/vanilla.rs b/crates/horizon-command/src/vanilla.rs
similarity index 99%
rename from crates/horizon-client/src/command/vanilla.rs
rename to crates/horizon-command/src/vanilla.rs
index 2ce892077..37ec1c3de 100644
--- a/crates/horizon-client/src/command/vanilla.rs
+++ b/crates/horizon-command/src/vanilla.rs
@@ -5,7 +5,7 @@ use super::{
     Dispatcher,
     args::{ArgType, Resource, integer},
 };
-use crate::gamerules::{RULES, Value};
+use horizon_client_core::gamerules::{RULES, Value};
 
 /// Permission levels (Commands.LEVEL_*).
 pub const ALL: u8 = 0;
diff --git a/crates/horizon-client/src/command/vanilla_order.rs b/crates/horizon-command/src/vanilla_order.rs
similarity index 100%
rename from crates/horizon-client/src/command/vanilla_order.rs
rename to crates/horizon-command/src/vanilla_order.rs
diff --git a/docs/architecture.md b/docs/architecture.md
index 0350bd1ea..7646ccc17 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -5,8 +5,9 @@ counted only for the game loop because nearly every gameplay change touches it).
 organised and how to build and test are in [AGENTS.md](../AGENTS.md).
 
 Paths: `L/` = `crates/horizon-client/src/`, `G/` = `crates/horizon-client/src/game/`, `W/` =
-`crates/horizon-world/src/`. Checks: a bare name is a harness (`python3 tools/parity.py <name>`, script
-`tools/test_<name>_parity.py`); `lan_e2e <check>` is `python3 tools/lan_e2e.py --check <check>`.
+`crates/horizon-world/src/`, `K/` = `crates/horizon-client-core/src/`, `C/` = `crates/horizon-command/src/`.
+Checks: a bare name is a harness (`python3 tools/parity.py <name>`, script `tools/test_<name>_parity.py`);
+`lan_e2e <check>` is `python3 tools/lan_e2e.py --check <check>`.
 
 For the full set of harnesses a file can affect, ask the runner:
 `printf '%s\n' <paths> > /tmp/p.txt && python3 tools/parity.py --changed-files /tmp/p.txt --list`.
@@ -17,7 +18,7 @@ file selects ~103.
 |---|---|---|---|
 | 1 | Game loop, tick order, frame pacing (554) | `L/game.rs` (`fn tick`, `fn tick_world`, `fn render`, `about_to_wait`), `L/clock.rs`, `L/window.rs`, `L/spans.rs` | game_loop, frame_limiter, interaction_input, tick |
 | 2 | Mobs in the game loop, spawning (166) | `G/creatures.rs`, `G/natural_spawning.rs`, `L/mobs/spawning.rs`, `L/mobs/spawn_rules.rs`, `L/mobs/spawn_selection.rs`, `L/mobs/finalize.rs`, `G/spawner.rs`, `G/trial_spawner.rs` | natural_spawn, spawn_rules, finalize_spawn, spawner, trial_spawner, mob_ai |
-| 3 | World save and load (163) | `L/save.rs`, `G/saving.rs`, `G/persist.rs` (entities), `L/entity_nbt.rs`, `L/block_entity_nbt.rs`, `W/region.rs`, `W/nbt.rs` | save_roundtrip, world_reopen, world, datafix |
+| 3 | World save and load (163) | `L/save.rs`, `G/saving.rs`, `G/persist.rs` (entities), `L/entity_nbt.rs`, `K/block_entity_nbt.rs`, `W/region.rs`, `W/nbt.rs` | save_roundtrip, world_reopen, world, datafix |
 | 4 | World generation (153) | `W/worldgen.rs`, `W/worldgen/` (`generator*.rs`, `feature_graph.rs`, `structure/`, `placement/`), `L/vanillagen.rs` | chunk_generation, worldgen, server_world_gen, world_spawn, feature_graph, feature_placement, decoration and the other worldgen harnesses |
 | 5 | Multiplayer client, packets in (145) | `G/remote.rs` (`fn handle_packet`, `fn tick_remote`), `G/remote_*.rs`, `L/net.rs` | dedicated_server, server_entities, lan_e2e (all) |
 | 6 | Agent control, horizon-ctl (145) | `L/control.rs`, `L/bin/horizon-ctl/`, `G/control.rs`, `G/agent.rs`, `G/events.rs`, `G/ui_control.rs` | `python3 tools/agent_control_e2e.py`; `cargo test -p horizon-client --bin horizon-ctl` |
@@ -32,7 +33,7 @@ file selects ~103.
 | 15 | Items and item use (96) | `L/items.rs`, `L/item_data.rs`, `G/hand.rs`, `G/consume.rs`, `G/potions.rs`, `L/effects.rs`; game.rs `fn use_hand`, `fn use_item` | use_item_on, item_use, item_use_lifecycle, consumable, consume_effect, status_effect |
 | 16 | Options and settings screens (93) | `L/options_ui.rs`, `G/options.rs`, `L/settings.rs`, `L/options_file.rs`, `L/graphics_ui.rs`, `L/graphics.rs` | options, toggle_keys |
 | 17 | HUD, chat, tab list (93) | `L/hud.rs`, `L/hud_layout.rs`, `L/hud_overlays.rs`, `L/chat.rs`, `G/chat.rs`, `L/tab_list.rs`, `L/locator_bar.rs`, `G/locator_bar.rs` | hud, tab_list, locator_bar, chat_screen, secure_chat |
-| 18 | Command execution (88) | `G/commands.rs`, `G/commands/*.rs`, `L/scoreboard_cmd.rs`, `L/data_cmd.rs`, `G/functions.rs` | command_exec (corpus `tools/command_exec_corpus.py`), scoreboard, server_ops_feedback, lan_e2e commands |
+| 18 | Command execution (88) | `G/commands.rs`, `G/commands/*.rs`, `L/scoreboard_cmd.rs`, `L/data_cmd.rs`, `K/scoreboard.rs`, `G/functions.rs` | command_exec (corpus `tools/command_exec_corpus.py`), scoreboard, server_ops_feedback, lan_e2e commands |
 | 19 | Chunk streaming, light, tickets (85) | `L/streaming.rs`, `L/world.rs`, `L/chunk.rs`, `L/chunk_map.rs`, `L/light.rs`, `L/ticket_levels.rs`, `L/tick_chunk_membership.rs`, `G/world_loading.rs` | light, chunk_status, random_tick_sections; `cargo test -p horizon-client --test streaming_meshes` |
 | 20 | Mob models and animation (78) | `L/mobs/render.rs`, `L/mobs/anim.rs`, `L/mobs/body_anim.rs`, `L/mobs/keyframes.rs`, `L/entity.wgsl` | entity_model |
 | 21 | Block behaviour, server side (78) | `W/level/` (`mod.rs`, `tick.rs`, `hooks.rs`, `data.rs`, `redstone.rs`, `place.rs`), `G/block_entity_ticks.rs`, `G/moving_pistons.rs` | block_update, redstone, random_tick, simple_block, piston_movement, block_entity_tickers |
@@ -52,6 +53,6 @@ file selects ~103.
 | 35 | Dispensers (43) | `G/dispenser.rs`, `G/dispense_fixture.rs` (the harness side) | dispenser |
 | 36 | Audio and music (38) | `L/audio.rs`, `L/sound_engine.rs`, `L/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) | `L/command/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`) | command_parse (corpus `tools/command_parse_corpus.py`) |
+| 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) | `L/benchmark.rs`, `tools/perf_bench.py`, `L/telemetry.rs`, `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 |
diff --git a/docs/version-ports.md b/docs/version-ports.md
index 623e3c082..4ecad210f 100644
--- a/docs/version-ports.md
+++ b/docs/version-ports.md
@@ -43,7 +43,7 @@ to players. Players still prepare their own copy from their official launcher (`
   | `crates/horizon-client/src/lan/tracking.rs` | `generate_entity_tracking.py` | decompiled `EntityTypes` |
   | `crates/horizon-client/src/lan/command_suggestions.rs` | `generate_command_suggestions.py` | `VanillaCommandSuggestionsExporter` |
   | `crates/horizon-client/src/lan/command_order.rs` | `generate_lan_command_order.py` | vanilla's command tree |
-  | `crates/horizon-client/src/command/vanilla_order.rs` | `generate_command_order.py` | command-parse harness export |
+  | `crates/horizon-command/src/vanilla_order.rs` | `generate_command_order.py` | command-parse harness export |
   | `crates/horizon-world/src/datafix/block_state_data.txt` | `gen_block_state_data.py` | decompiled `BlockStateData` |
   | `crates/horizon-world/src/datafix/flat_tables.rs` | `gen_flat_tables.py` | 1.13 flattening fixers (never change) |
 
diff --git a/tools/generate_command_order.py b/tools/generate_command_order.py
index ab78b3ada..e7e1175ae 100644
--- a/tools/generate_command_order.py
+++ b/tools/generate_command_order.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Generate crates/horizon-client/src/command/vanilla_order.rs: the order of
+"""Generate crates/horizon-command/src/vanilla_order.rs: the order of
 the children of each node of vanilla's command tree where Horizon's tree
 registers them in a different order. Brigadier keeps children in
 registration order, and /help (smart usage) lists them that way.
@@ -19,7 +19,7 @@ def main():
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     parser.add_argument("vanilla", type=Path)
     parser.add_argument("rust", type=Path)
-    parser.add_argument("--out", type=Path, default=ROOT / "crates/horizon-client/src/command/vanilla_order.rs")
+    parser.add_argument("--out", type=Path, default=ROOT / "crates/horizon-command/src/vanilla_order.rs")
     args = parser.parse_args()
     vanilla = json.loads(args.vanilla.read_text())
     rust = json.loads(args.rust.read_text())
diff --git a/tools/port_regen.py b/tools/port_regen.py
index 8ce639f21..4d69b0986 100644
--- a/tools/port_regen.py
+++ b/tools/port_regen.py
@@ -251,7 +251,7 @@ GENERATORS = [
     ("lan_command_order", ["crates/horizon-client/src/lan/command_order.rs"],
      lambda root, version, store, build: [python(), "tools/generate_lan_command_order.py"]),
     ("command_suggestions", ["crates/horizon-client/src/lan/command_suggestions.rs"], gen_suggestions),
-    ("vanilla_command_order", ["crates/horizon-client/src/command/vanilla_order.rs"], gen_vanilla_order),
+    ("vanilla_command_order", ["crates/horizon-command/src/vanilla_order.rs"], gen_vanilla_order),
 ]
 
 
diff --git a/tools/port_report.py b/tools/port_report.py
index 9006576dd..f8e81b6ee 100644
--- a/tools/port_report.py
+++ b/tools/port_report.py
@@ -40,7 +40,7 @@ GENERATORS = [
      lambda d: bool(d["commands"]["added"] or d["commands"]["removed"] or d["commands"]["changed"])),
     ("crates/horizon-client/src/lan/command_order.rs", "python3 tools/generate_lan_command_order.py",
      lambda d: bool(d["commands"]["added"] or d["commands"]["removed"])),
-    ("crates/horizon-client/src/command/vanilla_order.rs", "python3 tools/generate_command_order.py",
+    ("crates/horizon-command/src/vanilla_order.rs", "python3 tools/generate_command_order.py",
      lambda d: bool(d["commands"]["added"] or d["commands"]["removed"])),
     ("crates/horizon-world/src/datafix/block_state_data.txt", "python3 tools/gen_block_state_data.py",
      lambda d: "net/minecraft/util/datafix/fixes/BlockStateData" in d["classes"]["changed"]),
diff --git a/tools/test_lore_tooltip_parity.py b/tools/test_lore_tooltip_parity.py
index d262a3542..e6869f7e9 100644
--- a/tools/test_lore_tooltip_parity.py
+++ b/tools/test_lore_tooltip_parity.py
@@ -35,7 +35,7 @@ if __name__ == '__main__':
         sources=[
             lab.ROOT / 'crates/horizon-client/src/item_tooltip.rs',
             lab.ROOT / 'crates/horizon-client/src/item_data.rs',
-            lab.ROOT / 'crates/horizon-client/src/text.rs',
-            lab.ROOT / 'crates/horizon-client/src/component.rs',
+            lab.ROOT / 'crates/horizon-client-core/src/text.rs',
+            lab.ROOT / 'crates/horizon-client-core/src/component.rs',
         ],
         expected_lines=len(CASES))
diff --git a/tools/test_resource_pack_parity.py b/tools/test_resource_pack_parity.py
index 2d9ae2a85..a935e0b34 100644
--- a/tools/test_resource_pack_parity.py
+++ b/tools/test_resource_pack_parity.py
@@ -129,7 +129,7 @@ def main():
                                     "Pack discovery, overlays, filters and the resource stacks vanilla merges.",
                                     sources=[lab.ROOT / "crates/horizon-client/src/packs.rs",
                                              lab.ROOT / "crates/horizon-client/src/sound_events.rs",
-                                             lab.ROOT / "crates/horizon-client/src/lang.rs"])
+                                             lab.ROOT / "crates/horizon-client-core/src/lang.rs"])
         total += len(QUERIES)
     print(f"{total} resource pack queries match the pinned client over {len(SELECTIONS)} selections")
 

From aec3b7e2624ea88f8d5ccd2019a9b13e03700e04 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:43:51 +0100
Subject: [PATCH 026/475] Scale mob damage to players with the difficulty

Damage types marked when_caused_by_living_non_player now scale when a mob
(or the owner of its projectile, or an exploding mob) caused the hit.
---
 crates/horizon-client/src/game/creatures.rs |  6 ++++-
 crates/horizon-client/src/game/explosion.rs |  4 +++-
 crates/horizon-client/src/health.rs         | 26 +++++++++++++++++++--
 crates/horizon-client/src/hunger.rs         |  1 +
 4 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 3a8562ee1..e27e6b175 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1509,15 +1509,19 @@ impl Game<'_> {
         if let Some(a) = attacker.or(owner) {
             self.note_attacker(damage_type, a);
         }
+        // DamageSource.scalesWithDifficulty: a mob (or its projectile's
+        // owner) caused the hit, not a player.
+        let living_cause = attacker.or(owner).is_some();
         let mut outcome = horizon_client::health::BlockOutcome::default();
         if let Some(player) = self.player.as_mut()
             && let Some(id) = self.motion.health.damage.id(damage_type)
-            && let Ok(o) = player.hurt_blocking(
+            && let Ok(o) = player.hurt_caused_by(
                 &self.motion.health,
                 self.world.health_rules,
                 id,
                 amount,
                 blocking,
+                living_cause,
             )
             && {
                 outcome = o;
diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs
index 6ecba3a54..8800e29d8 100644
--- a/crates/horizon-client/src/game/explosion.rs
+++ b/crates/horizon-client/src/game/explosion.rs
@@ -296,12 +296,14 @@ impl Game<'_> {
             if !creative
                 && !spectator
                 && hurtable
-                && let Ok(o) = p.hurt_blocking(
+                && let Ok(o) = p.hurt_caused_by(
                     &self.motion.health,
                     self.world.health_rules,
                     id,
                     amount,
                     blocking,
+                    // The exploding mob is the causing entity.
+                    exploding.is_some(),
                 )
             {
                 outcome = o;
diff --git a/crates/horizon-client/src/health.rs b/crates/horizon-client/src/health.rs
index 25c719bfb..4f7824b25 100644
--- a/crates/horizon-client/src/health.rs
+++ b/crates/horizon-client/src/health.rs
@@ -295,6 +295,20 @@ impl PlayerMotion {
         source: DamageTypeId,
         amount: f32,
         blocking: Option<Blocking>,
+    ) -> Result<BlockOutcome> {
+        self.hurt_caused_by(resources, rules, source, amount, blocking, false)
+    }
+    /// `hurt_blocking` from a source whose causing entity is a living
+    /// non-player (`living_cause`), which the `when_caused_by_living_non_player`
+    /// damage types scale with the difficulty.
+    pub fn hurt_caused_by(
+        &mut self,
+        resources: &HealthResources,
+        rules: HealthRules,
+        source: DamageTypeId,
+        amount: f32,
+        blocking: Option<Blocking>,
+        living_cause: bool,
     ) -> Result<BlockOutcome> {
         if self.client_side {
             return Ok(BlockOutcome::default());
@@ -315,6 +329,7 @@ impl PlayerMotion {
             invulnerable,
             rules,
             source,
+            living_cause,
             events: &mut self.events,
             dead: &mut h.dead,
             sync_velocity: &mut h.sync_velocity,
@@ -390,6 +405,8 @@ pub(crate) struct Environment<'a> {
     pub(crate) invulnerable: bool,
     pub(crate) rules: HealthRules,
     pub(crate) source: DamageSource<'a, ()>,
+    /// The causing entity is a living non-player (a mob, or its projectile's owner).
+    pub(crate) living_cause: bool,
     pub(crate) events: &'a mut Vec<MotionEvent>,
     pub(crate) dead: &'a mut bool,
     pub(crate) sync_velocity: &'a mut bool,
@@ -773,8 +790,13 @@ impl PlayerHurtWorld for Environment<'_> {
         Ok(())
     }
     fn scales_with_difficulty(&mut self, _: &mut State) -> io::Result<bool> {
-        Ok(self.source.definition().scaling == Scaling::Always)
-    } // no causing entity
+        // DamageSource.scalesWithDifficulty.
+        Ok(match self.source.definition().scaling {
+            Scaling::Never => false,
+            Scaling::Always => true,
+            Scaling::LivingNonPlayer => self.living_cause,
+        })
+    }
     fn difficulty(&mut self, _: &mut State) -> io::Result<Difficulty> {
         Ok(self.rules.difficulty)
     }
diff --git a/crates/horizon-client/src/hunger.rs b/crates/horizon-client/src/hunger.rs
index 15eac144f..34f414d50 100644
--- a/crates/horizon-client/src/hunger.rs
+++ b/crates/horizon-client/src/hunger.rs
@@ -151,6 +151,7 @@ impl FoodWorld for TickWorld<'_> {
                 .damage
                 .source::<()>(id, None, None, None)
                 .expect("validated starvation source"),
+            living_cause: false,
             events: self.events,
             dead: self.dead,
             sync_velocity: self.sync_velocity,

From d0af8430948c1f277a7f3e1b574dd2c7311babb8 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:44:16 +0100
Subject: [PATCH 027/475] Daylight detectors follow the sky and update when
 used

A daylight detector never changed its power: nothing ran its update.
It now has a block entity with the ticker vanilla has, and updates its
power every 20 game ticks from the sky light, the sky darkening and the
sun angle. Using it to flip inverted mode recomputes the power at once.
---
 crates/horizon-client/src/containers.rs       | 16 ++++++++--
 crates/horizon-client/src/game.rs             | 18 +++++++++--
 .../src/game/block_entity_ticks.rs            | 15 +++++++++-
 crates/horizon-client/src/save.rs             |  4 ++-
 crates/horizon-world/src/level/interact.rs    |  1 +
 crates/horizon-world/src/level/mod.rs         | 22 ++++++++++++++
 crates/horizon-world/src/level/redstone.rs    | 30 ++++++++++++++++++-
 7 files changed, 98 insertions(+), 8 deletions(-)

diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs
index d13c5e45b..895ea5769 100644
--- a/crates/horizon-client/src/containers.rs
+++ b/crates/horizon-client/src/containers.rs
@@ -85,6 +85,9 @@ pub enum BlockEntity {
     CommandBlock(Box<crate::command_block::CommandBlock>),
     /// `SkullBlockEntity` of every skull and head block.
     Skull(Skull),
+    /// `DaylightDetectorBlockEntity`: no data, only the ticker
+    /// (`DaylightDetectorBlock.tickEntity`).
+    DaylightDetector,
 }
 /// `SkullBlockEntity`: the player profile the head shows (kept as loaded:
 /// a compound, or a string when it names a player only), the note block
@@ -295,6 +298,9 @@ impl BlockEntity {
         if is_skull(name) {
             return Some(Self::Skull(Skull::default()));
         }
+        if name == "minecraft:daylight_detector" {
+            return Some(Self::DaylightDetector);
+        }
         if name == "minecraft:beacon" {
             return Some(Self::Beacon(Box::new(Beacon {
                 last_check_y: i32::MIN / 2,
@@ -341,6 +347,7 @@ impl BlockEntity {
             Self::Beehive(_) => "minecraft:beehive",
             Self::CommandBlock(_) => "minecraft:command_block",
             Self::Skull(_) => "minecraft:skull",
+            Self::DaylightDetector => "minecraft:daylight_detector",
         }
     }
     pub fn contents(&self) -> Vec<ItemStack> {
@@ -357,7 +364,8 @@ impl BlockEntity {
             | Self::Vault(_)
             | Self::Beehive(_)
             | Self::CommandBlock(_)
-            | Self::Skull(_) => Vec::new(),
+            | Self::Skull(_)
+            | Self::DaylightDetector => Vec::new(),
             Self::Lectern(l) => l.book.iter().cloned().collect(),
             Self::Sculk(_) => Vec::new(),
             Self::Banner(_) => Vec::new(),
@@ -375,7 +383,8 @@ impl BlockEntity {
             | Self::Lectern(_)
             | Self::Sculk(_)
             | Self::Banner(_)
-            | Self::Skull(_) => &[],
+            | Self::Skull(_)
+            | Self::DaylightDetector => &[],
             Self::Crafter(c) => &c.items,
             Self::CreakingHeart(_)
             | Self::Spawner(_)
@@ -396,7 +405,8 @@ impl BlockEntity {
             | Self::Lectern(_)
             | Self::Sculk(_)
             | Self::Banner(_)
-            | Self::Skull(_) => &mut [],
+            | Self::Skull(_)
+            | Self::DaylightDetector => &mut [],
             Self::Crafter(c) => &mut c.items,
             Self::CreakingHeart(_)
             | Self::Spawner(_)
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index b397882cd..4c866a203 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -532,6 +532,8 @@ struct GameLevel<'w> {
     events: &'w mut Vec<LevelEvent>,
     dimension: LevelDimension,
     darken: i32,
+    /// The environment of the level's dimension (`SUN_ANGLE`).
+    environment: &'w Environment,
     raining: bool,
     thundering: bool,
     player_box: Option<([f64; 3], [f64; 3])>,
@@ -759,6 +761,11 @@ impl LevelAccess for GameLevel<'_> {
     fn sky_darken(&self) -> i32 {
         self.darken
     }
+    fn sun_angle(&self, _pos: BlockPos) -> f32 {
+        self.environment
+            .sample(self.world.day_time, None, None)
+            .sun_angle
+    }
     fn is_raining(&self) -> bool {
         self.raining
     }
@@ -2469,6 +2476,11 @@ impl Game<'_> {
             events: &mut self.level_events,
             dimension,
             darken,
+            environment: match dimension {
+                LevelDimension::Overworld => self.res.environment(),
+                LevelDimension::Nether => self.res.nether_environment(),
+                LevelDimension::End => self.res.end_environment(),
+            },
             raining: rain > 0.2,
             thundering: thunder > 0.9,
             player_box,
@@ -5278,7 +5290,8 @@ impl Game<'_> {
                 | BlockEntity::Vault(_)
                 | BlockEntity::Beehive(_)
                 | BlockEntity::CommandBlock(_)
-                | BlockEntity::Skull(_),
+                | BlockEntity::Skull(_)
+                | BlockEntity::DaylightDetector,
             ) => {}
             None => {
                 v.extend((0..self.craft_size * self.craft_size).map(|i| 100 + i));
@@ -5548,7 +5561,8 @@ impl Game<'_> {
                     | BlockEntity::Vault(_)
                     | BlockEntity::Beehive(_)
                     | BlockEntity::CommandBlock(_)
-                    | BlockEntity::Skull(_),
+                    | BlockEntity::Skull(_)
+                    | BlockEntity::DaylightDetector,
                 ) => {}
                 None if self.mount_active() => self.draw_mount_background(batch, ox, oy),
                 None => {
diff --git a/crates/horizon-client/src/game/block_entity_ticks.rs b/crates/horizon-client/src/game/block_entity_ticks.rs
index e48c8f398..3ddf58281 100644
--- a/crates/horizon-client/src/game/block_entity_ticks.rs
+++ b/crates/horizon-client/src/game/block_entity_ticks.rs
@@ -10,6 +10,7 @@ use horizon_client::{
     block_entities::{Pos, Ticking},
     containers::{BlockEntity, FurnaceKind, HOPPER_SLOTS},
 };
+use horizon_core::position::BlockPos;
 use horizon_world::registry::BlockStateId;
 
 impl Game<'_> {
@@ -56,6 +57,7 @@ impl Game<'_> {
                 Some(BlockEntity::Beehive(_)) => self.tick_beehive(pos),
                 Some(BlockEntity::Furnace(_)) => self.tick_furnace(pos)?,
                 Some(BlockEntity::Brewing(_)) => self.tick_brewing_stand(pos)?,
+                Some(BlockEntity::DaylightDetector) => self.tick_daylight_detector(pos),
                 _ => {}
             }
         }
@@ -92,7 +94,8 @@ impl Game<'_> {
                     | "minecraft:vault"
                     | "minecraft:beehive"
                     | "minecraft:bee_nest"
-                    | "minecraft:brewing_stand" => Ticking::Yes,
+                    | "minecraft:brewing_stand"
+                    | "minecraft:daylight_detector" => Ticking::Yes,
                     "minecraft:jukebox" => {
                         let record = registry
                             .state(state)
@@ -113,6 +116,16 @@ impl Game<'_> {
         let levels = self.tickets.levels();
         move |x, z| levels.block_ticking_at(x, z)
     }
+    /// `DaylightDetectorBlock.tickEntity` of the detector at `pos`.
+    fn tick_daylight_detector(&mut self, pos: Pos) {
+        // It updates every 20 game ticks (the behaviour checks this too).
+        if self.world.game_time % 20 != 0 {
+            return;
+        }
+        let at = BlockPos::new(pos.0, pos.1, pos.2);
+        self.with_level(|b, level, ticks| b.tick_daylight_detector(level, ticks, at));
+        let _ = self.process_level_events();
+    }
     /// `AbstractFurnaceBlockEntity.serverTick` of the furnace at `pos`, and
     /// its block's `lit` following it.
     fn tick_furnace(&mut self, pos: Pos) -> Result<()> {
diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs
index 0c353bb38..f848277b4 100644
--- a/crates/horizon-client/src/save.rs
+++ b/crates/horizon-client/src/save.rs
@@ -569,6 +569,7 @@ pub fn encode_block_entity(
         BlockEntity::Vault(v) => entries.extend(v.save()),
         BlockEntity::Beehive(h) => entries.extend(h.to_nbt()),
         BlockEntity::CommandBlock(c) => entries.extend(c.save()),
+        BlockEntity::DaylightDetector => {}
     }
     Tag::compound(entries)
 }
@@ -724,7 +725,8 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain
         | BlockEntity::Lectern(_)
         | BlockEntity::Banner(_)
         | BlockEntity::CreakingHeart(_)
-        | BlockEntity::Skull(_) => {}
+        | BlockEntity::Skull(_)
+        | BlockEntity::DaylightDetector => {}
         BlockEntity::Spawner(s) => **s = crate::mobs::spawner::Spawner::load(tag),
         BlockEntity::TrialSpawner(s) => **s = crate::mobs::trial_spawner::TrialSpawner::load(tag),
         BlockEntity::Vault(v) => **v = crate::vault::Vault::load(tag),
diff --git a/crates/horizon-world/src/level/interact.rs b/crates/horizon-world/src/level/interact.rs
index 7b2195c34..11d4d36e1 100644
--- a/crates/horizon-world/src/level/interact.rs
+++ b/crates/horizon-world/src/level/interact.rs
@@ -195,6 +195,7 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
                     let next = table.cycle(state, p.inverted);
                     self.set_block(pos, next, 2);
                     self.game_event(pos, "minecraft:block_change");
+                    self.daylight_detector_update_signal(pos, next);
                     Success
                 }
                 Class::Cake => {
diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs
index 3831efbd6..342ad6f2f 100644
--- a/crates/horizon-world/src/level/mod.rs
+++ b/crates/horizon-world/src/level/mod.rs
@@ -319,6 +319,10 @@ pub trait LevelAccess {
     fn sky_darken(&self) -> i32 {
         0
     }
+    /// `EnvironmentAttributes.SUN_ANGLE` at `pos`, in degrees (0 at noon).
+    fn sun_angle(&self, _pos: BlockPos) -> f32 {
+        0.0
+    }
     fn is_raining(&self) -> bool {
         false
     }
@@ -749,6 +753,24 @@ impl Behaviours {
     ) {
         self.sim(level, ticks).entity_inside(pos);
     }
+    /// `DaylightDetectorBlock.tickEntity` of the daylight detector at `pos`:
+    /// its signal follows the sky every 20 game ticks. The detector's ticker
+    /// exists only where the dimension has sky light.
+    pub fn tick_daylight_detector<L: LevelAccess + ?Sized>(
+        &self,
+        level: &mut L,
+        ticks: &mut Ticks,
+        pos: BlockPos,
+    ) {
+        if level.dimension() == Dimension::Nether || level.game_time() % 20 != 0 {
+            return;
+        }
+        let mut sim = self.sim(level, ticks);
+        let state = sim.state(pos);
+        if sim.b.data(state).is(classes::Class::DaylightDetector) {
+            sim.daylight_detector_update_signal(pos, state);
+        }
+    }
     /// `BigDripleafBlock.entityInside` for an entity whose box is inside
     /// `pos`: whether it is on the ground and its feet's y (`canEntityTilt`).
     pub fn entity_on_big_dripleaf<L: LevelAccess + ?Sized>(
diff --git a/crates/horizon-world/src/level/redstone.rs b/crates/horizon-world/src/level/redstone.rs
index 92f9059e5..5c7bb5cc9 100644
--- a/crates/horizon-world/src/level/redstone.rs
+++ b/crates/horizon-world/src/level/redstone.rs
@@ -11,7 +11,10 @@ use super::{
 };
 use crate::registry::BlockStateId;
 use horizon_core::{
-    geometry::Direction, position::BlockPos, random::RandomSource, ticks::TickPriority,
+    geometry::{Direction, trig},
+    position::BlockPos,
+    random::RandomSource,
+    ticks::TickPriority,
 };
 
 const SIGNAL_ORDER: [Direction; 6] = [
@@ -892,6 +895,31 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
         }
         self.game_event(pos, "minecraft:block_deactivate");
     }
+    /// `DaylightDetectorBlock.updateSignalStrength`: the effective sky light
+    /// at the detector, shaped by the sun's angle (or inverted), as its
+    /// power.
+    pub(crate) fn daylight_detector_update_signal(&mut self, pos: BlockPos, state: BlockStateId) {
+        let b = self.b;
+        let mut target = (self.level.sky_light(pos) - self.level.sky_darken()).max(0);
+        if b.table.bool(state, b.props.inverted) {
+            target = 15 - target;
+        } else if target > 0 {
+            let mut sun_angle = self.level.sun_angle(pos) * trig::DEG_TO_RAD;
+            let offset = if sun_angle < std::f32::consts::PI {
+                0.0
+            } else {
+                std::f32::consts::TAU
+            };
+            sun_angle += (offset - sun_angle) * 0.2;
+            // Math.round(float).
+            let scaled = target as f32 * trig::cos(f64::from(sun_angle));
+            target = (f64::from(scaled) + 0.5).floor() as i32;
+        }
+        let target = target.clamp(0, 15);
+        if b.table.int(state, b.props.power) != target {
+            self.set_block_and_update(pos, b.table.set_int(state, b.props.power, target));
+        }
+    }
     /// `LeverBlock.pull`.
     pub(crate) fn lever_pull(&mut self, pos: BlockPos, state: BlockStateId) {
         let b = self.b;

From c4b9067d6df0f685d1390dbe7fdad341742032e0 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:45:54 +0100
Subject: [PATCH 028/475] Infinity only saves plain arrows, not tipped or
 spectral ones

---
 crates/horizon-client/src/game.rs                 | 8 ++++----
 crates/horizon-client/src/game/enchant_effects.rs | 6 ++++--
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index b397882cd..5dda8c67f 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -9105,7 +9105,10 @@ impl Game<'_> {
         };
         // BowItem.shootProjectile: shootFromRotation(power * 3, inaccuracy 1).
         let p = Vec3::new(eye[0], eye[1] - 0.1, eye[2]);
-        let (power_bonus, infinity) = self.bow_enchantments();
+        let ammo = arrow_slot
+            .and_then(|i| self.stack_in(i).cloned())
+            .unwrap_or_else(|| ItemStack::new("minecraft:arrow", 1));
+        let (power_bonus, infinity) = self.bow_enchantments(&ammo.item);
         let kind = horizon_client::projectiles::ProjectileKind::Arrow {
             base_damage: 2.0 + power_bonus,
             critical: power >= 1.0,
@@ -9119,9 +9122,6 @@ impl Game<'_> {
         // ProjectileWeaponItem.useAmmo: creative and Infinity draw without
         // using the ammo, so the arrow is CREATIVE_ONLY; else setOwner(player)
         // lets it be picked up.
-        let ammo = arrow_slot
-            .and_then(|i| self.stack_in(i).cloned())
-            .unwrap_or_else(|| ItemStack::new("minecraft:arrow", 1));
         if let Some(a) = arrow.arrow.as_mut() {
             a.set_item(&horizon_client::arrows::drawn_ammo(
                 &ammo,
diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs
index aa9f75e06..b9fe56ebd 100644
--- a/crates/horizon-client/src/game/enchant_effects.rs
+++ b/crates/horizon-client/src/game/enchant_effects.rs
@@ -388,7 +388,9 @@ impl Game<'_> {
         }
     }
     /// Bow enchantments at release: (extra base damage, infinity keeps the arrow).
-    pub(super) fn bow_enchantments(&mut self) -> (f64, bool) {
+    /// `ammo` is the item being fired: `Enchantment.itemContext` hands it to the
+    /// `ammo_use` conditions as the tool, so Infinity only frees plain arrows.
+    pub(super) fn bow_enchantments(&mut self, ammo: &str) -> (f64, bool) {
         let Some(bow) = self.inventory[self.selected].clone() else {
             return (0.0, false);
         };
@@ -407,7 +409,7 @@ impl Game<'_> {
             0.0,
         );
         let ammo_ctx = EffectContext {
-            tool: Some("minecraft:arrow"),
+            tool: Some(ammo),
             items: Some(self.res.items()),
             ..Default::default()
         };

From 65bebdfc49cd86f09ba18bd2eeb2f536c0816ad9 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:47:18 +0100
Subject: [PATCH 029/475] Make a sword sweep hurt the mobs next to the target

The sweep only drew the particle and played the sound. Mobs in the sweep
box now take the sweep damage (with Sweeping Edge) and 0.4 knockback.
---
 crates/horizon-client/src/game.rs      | 64 ++++++++++++++++++++++++++
 crates/horizon-client/src/game/mace.rs |  2 +-
 2 files changed, 65 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index b397882cd..4e795c3c5 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -7465,6 +7465,69 @@ impl Game<'_> {
         self.audio
             .play("minecraft:entity.player.attack.sweep", from, 1.0, 1.0);
     }
+    /// The damage and knockback part of `Player.doSweepAttack` after a sweep
+    /// hit on the mob at `target`: every other living mob in its box grown by
+    /// (1, 0.25, 1) and within the player's reach, but the player's allies
+    /// (`isAlliedTo`), takes `1 + sweeping_damage_ratio * baseDamage` with the
+    /// weapon's enchantments, scaled by the attack strength, and is pushed 0.4
+    /// along the player's yaw.
+    pub(super) fn sweep_damage(&mut self, target: usize, scale: f32) {
+        let Some(p) = self.player.as_ref() else {
+            return;
+        };
+        let from = [p.position.x, p.position.y, p.position.z];
+        // `baseDamage` of `Player.attack` before a critical hit (a sweep has
+        // none) and the enchantments: the attack damage attribute with the
+        // strength and weakness effects, scaled by the attack strength.
+        let hand_damage = 1.0 + self.attack_item_info().map_or(0.0, |i| i.attack_damage);
+        let base_damage = (hand_damage + self.effect_attack_bonus()) * (0.2 + scale * scale * 0.8);
+        // The enchantment's attribute modifier on the attribute's 0 to 1 range.
+        let ratio = self
+            .res
+            .stations()
+            .enchantments
+            .attribute_add(
+                self.inventory[self.selected].as_ref(),
+                "minecraft:sweeping_damage_ratio",
+            )
+            .clamp(0.0, 1.0) as f32;
+        let sweep_damage = 1.0 + ratio * base_damage;
+        let hit_box = self.mobs[target]
+            .bounds()
+            .inflate(horizon_core::geometry::Vec3::new(1.0, 0.25, 1.0));
+        let reach = if self.creative { 5.0 } else { 3.0 };
+        let (uuid, allies) = (
+            self.level.player_uuid.or(Some([0, 0, 0, 1])),
+            self.player_allies(),
+        );
+        let nearby: Vec<usize> = self
+            .mobs
+            .iter()
+            .enumerate()
+            .filter(|(i, m)| {
+                *i != target
+                    && m.alive()
+                    && !m.removed
+                    && !allies.contains(&m.id)
+                    && !mace::ally_of_player(m, uuid)
+                    && m.bounds().intersects(hit_box)
+                    && m.position.distance_squared(p.position) < reach * reach
+            })
+            .map(|(i, _)| i)
+            .collect();
+        let (xd, zd) = self.extra_knockback_direction();
+        for i in nearby {
+            let kind = self.mobs[i].kind.id.clone();
+            let kind = format!("minecraft:{}", kind.trim_start_matches("minecraft:"));
+            let damage = (sweep_damage + self.enchant_damage_bonus(&kind)) * scale;
+            let source = self.attack_source(from);
+            if self.hurt_by_player(i, damage, source) {
+                self.mobs[i].knockback(0.4, xd, zd);
+                self.last_hurt_by_player
+                    .insert(self.mobs[i].id, self.lan_acting);
+            }
+        }
+    }
     /// `Player.attack`'s sounds when a vehicle takes the hit (it always does,
     /// and can't be hit critically): knockback when sprinting at full
     /// strength, then strong or weak. Before `swing_arm` resets the charge.
@@ -7638,6 +7701,7 @@ impl Game<'_> {
             // Player.playServerSideSound: at the player.
             if let Some(at) = sweep {
                 self.sweep_attack(at, from);
+                self.sweep_damage(index, scale);
             } else {
                 self.audio.play(sound, from, 1.0, 1.0);
             }
diff --git a/crates/horizon-client/src/game/mace.rs b/crates/horizon-client/src/game/mace.rs
index 8ad5e76c3..34c968980 100644
--- a/crates/horizon-client/src/game/mace.rs
+++ b/crates/horizon-client/src/game/mace.rs
@@ -24,7 +24,7 @@ const KNOCKBACK_POWER: f32 = 0.7;
 /// `Entity.isAlliedTo` between the player (`player` its UUID) and a mob
 /// without teams: `TamableAnimal.considersEntityAsAlly` (a pet it tamed) and
 /// `Allay.considersEntityAsAlly` (an allay that likes it).
-fn ally_of_player(m: &Mob, player: Option<[i32; 4]>) -> bool {
+pub(super) fn ally_of_player(m: &Mob, player: Option<[i32; 4]>) -> bool {
     let tamable = matches!(
         m.species(),
         Species::Wolf

From d68ab989c01e54033e498e8cde9cab84611749d9 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:47:50 +0100
Subject: [PATCH 030/475] Let the fishing bobber hook dropped items, add owner
 luck, count only fish as fish caught

---
 crates/horizon-client/src/game/fishing.rs | 99 +++++++++++++++--------
 1 file changed, 64 insertions(+), 35 deletions(-)

diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs
index d454df406..aba0d04cf 100644
--- a/crates/horizon-client/src/game/fishing.rs
+++ b/crates/horizon-client/src/game/fishing.rs
@@ -154,37 +154,54 @@ impl Game<'_> {
         let mut damage = 0;
         if let State::Hooked(id) = hook.state {
             // pullEntity: 0.1 of the way to the owner.
+            let d = Vec3::new(
+                owner.x - hook.position.x,
+                owner.y - hook.position.y,
+                owner.z - hook.position.z,
+            );
+            let pulled = |v: Vec3| Vec3::new(v.x + d.x * 0.1, v.y + d.y * 0.1, v.z + d.z * 0.1);
+            let mut hooked_item = false;
             if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
-                let d = Vec3::new(
-                    owner.x - hook.position.x,
-                    owner.y - hook.position.y,
-                    owner.z - hook.position.z,
-                );
-                m.velocity = Vec3::new(
-                    m.velocity.x + d.x * 0.1,
-                    m.velocity.y + d.y * 0.1,
-                    m.velocity.z + d.z * 0.1,
-                );
+                m.velocity = pulled(m.velocity);
+            } else if let Some(item) = self.dropped.iter_mut().find(|i| i.id == id) {
+                item.velocity = pulled(item.velocity);
+                hooked_item = true;
             }
-            damage = 5;
+            // `hookedIn instanceof ItemEntity ? 3 : 5`.
+            damage = if hooked_item { 3 } else { 5 };
         } else if hook.nibble > 0 {
             let biome = self.biome_name_at(hook.position);
             let Some(loot) = horizon_client::structure_blocks::loot_data(&self.options.resources)
             else {
                 return damage;
             };
+            // `withLuck(this.luck + owner.getLuck())`: the rod's Luck of the Sea
+            // plus the owner's luck attribute (the Luck and Bad Luck effects).
+            let owner_luck = self
+                .player
+                .as_mut()
+                .and_then(|p| p.attribute("minecraft:luck").ok())
+                .unwrap_or(0.0) as f32;
             let mut random = self.world.random.clone();
             let items = loot.roll(
                 "minecraft:gameplay/fishing",
                 &mut random,
-                hook.luck as f32,
+                hook.luck as f32 + owner_luck,
                 biome.as_deref(),
                 Some(hook.open_water),
             );
             self.world.random = random;
-            // FishingHook.retrieve: fish_caught for a catch.
-            self.stats.custom("fish_caught", 1);
             for stack in items {
+                // FishingHook.retrieve: fish_caught for each catch in #minecraft:fishes.
+                if self
+                    .res
+                    .items()
+                    .item_tags
+                    .get("minecraft:fishes")
+                    .is_some_and(|t| t.contains(stack.item.as_str()))
+                {
+                    self.stats.custom("fish_caught", 1);
+                }
                 let mut item = ItemStack {
                     item: Arc::from(stack.item.as_str()),
                     count: stack.count.max(1) as u32,
@@ -457,35 +474,47 @@ impl Game<'_> {
                     self.hook = Some(h);
                     return;
                 }
-                // checkCollision: hook the first living mob it touches.
+                // checkCollision: hook the first living mob it touches, or (via
+                // `canHitEntity`) a dropped item.
                 let bb = bounds(h.position);
                 let (lo, hi) = (bb.min_position(), bb.max_position());
-                if let Some(m) = self.mobs.iter().find(|m| {
-                    let mb = m.bounds();
-                    let (a, z) = (mb.min_position(), mb.max_position());
-                    m.alive()
-                        && a.x < hi.x
-                        && lo.x < z.x
-                        && a.y < hi.y
-                        && lo.y < z.y
-                        && a.z < hi.z
-                        && lo.z < z.z
-                }) {
-                    h.state = State::Hooked(m.id);
+                let touches = |b: Aabb| {
+                    let (a, z) = (b.min_position(), b.max_position());
+                    a.x < hi.x && lo.x < z.x && a.y < hi.y && lo.y < z.y && a.z < hi.z && lo.z < z.z
+                };
+                let hit = self
+                    .mobs
+                    .iter()
+                    .find(|m| m.alive() && touches(m.bounds()))
+                    .map(|m| m.id)
+                    .or_else(|| {
+                        self.dropped
+                            .iter()
+                            .find(|i| touches(i.bounds()))
+                            .map(|i| i.id)
+                    });
+                if let Some(id) = hit {
+                    h.state = State::Hooked(id);
                     h.velocity = Vec3::ZERO;
                     self.hook = Some(h);
                     return;
                 }
             }
             State::Hooked(id) => {
-                match self.mobs.iter().find(|m| m.id == id && m.alive()) {
-                    Some(m) => {
-                        h.position = Vec3::new(
-                            m.position.x,
-                            m.position.y + f64::from(m.height()) * 0.8,
-                            m.position.z,
-                        )
-                    }
+                // updateHookedEntity: ride the hooked mob or item at 0.8 of its height.
+                let hooked = self
+                    .mobs
+                    .iter()
+                    .find(|m| m.id == id && m.alive())
+                    .map(|m| (m.position, f64::from(m.height())))
+                    .or_else(|| {
+                        self.dropped
+                            .iter()
+                            .find(|i| i.id == id)
+                            .map(|i| (i.position, horizon_client::entities::ItemEntity::WIDTH))
+                    });
+                match hooked {
+                    Some((at, height)) => h.position = Vec3::new(at.x, at.y + height * 0.8, at.z),
                     None => h.state = State::Flying,
                 }
                 self.hook = Some(h);

From 48c289f775c5d544714963f556e9ed521bb814bf Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:47:53 +0100
Subject: [PATCH 031/475] Make Channeling summon lightning when a trident hits

A thrown trident with Channeling now calls down a lightning bolt in a thunderstorm, both on a mob it hurts (if the mob can see the sky) and on a lightning rod it hits (if the rod can see the sky), with the thunder sound.
---
 crates/horizon-client/src/game/trident.rs | 85 ++++++++++++++++++++++-
 1 file changed, 82 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs
index c31094596..f072a0ae1 100644
--- a/crates/horizon-client/src/game/trident.rs
+++ b/crates/horizon-client/src/game/trident.rs
@@ -1,7 +1,8 @@
 //! Tridents: `TridentItem.releaseUsing` (throw after 10 ticks, or Riptide in
 //! water or rain) and `ThrownTrident` (arrow flight with 0.99 water inertia,
 //! 8 damage plus Impaling, the reversed bounce off a hit, sticking, Loyalty's
-//! return to the owner, pickup) with `ThrownTridentRenderer`.
+//! return to the owner, pickup) with `ThrownTridentRenderer`, and Channeling's
+//! lightning on a hit (`channeling.json`).
 use super::{Game, view_vector};
 use horizon_client::{
     collisions::SceneCollisions,
@@ -10,7 +11,8 @@ use horizon_client::{
     mobs::{Damage, DamageKind, Who, anim::Poses},
 };
 use horizon_core::{
-    geometry::{Aabb, Vec3},
+    geometry::{Aabb, Vec3, traverse_blocks},
+    position::BlockPos,
     random::RandomSource,
 };
 
@@ -154,6 +156,69 @@ impl Game<'_> {
             p.auto_spin_attack_dmg = 0.0;
         }
     }
+    /// The `summon_entity` and `play_sound` effects of `channeling.json`: in a
+    /// thunderstorm (`weather_check`) a spot that sees the sky (`can_see_sky`)
+    /// gets a lightning bolt and the thunder sound.
+    fn channel_lightning(&mut self, at: [f64; 3]) {
+        // Level.isThundering: the thunder level, in dimensions with weather.
+        if self.dim != super::Dim::Overworld || self.world.weather.levels(1.0).1 <= 0.9 {
+            return;
+        }
+        // BlockAndLightGetter.canSeeSky: full sky light.
+        let (x, y, z) = (
+            at[0].floor() as i32,
+            at[1].floor() as i32,
+            at[2].floor() as i32,
+        );
+        if self.world.light(x, y, z) >> 4 != 15 {
+            return;
+        }
+        self.spawn_bolt(at, false);
+        self.audio
+            .play("minecraft:item.trident.thunder", Some(at), 5.0, 1.0);
+    }
+    /// `minecraft:hit_block` of Channeling (`AbstractArrow.hitBlockEnchantmentEffects`):
+    /// the block the trident's path first hits, if it is a lightning rod, with
+    /// the hit location clamped into the block (`BlockPos.clampLocationWithin`).
+    fn channel_rod_hit(&mut self, from: Vec3, velocity: Vec3) {
+        let to = Vec3::new(
+            from.x + velocity.x,
+            from.y + velocity.y,
+            from.z + velocity.z,
+        );
+        let mut scene = SceneCollisions {
+            world: &self.world,
+            binding: self.collision,
+            subject: None,
+        };
+        // ClipContext.Block.COLLIDER with Fluid.NONE.
+        let hit = traverse_blocks(from, to, 1024, |p: BlockPos| {
+            let state = self.world.block(p.x, p.y, p.z);
+            if self.res.facts().is_air(state) {
+                return None;
+            }
+            let shape = self
+                .collision
+                .collision_shape(&mut scene, state, [p.x, p.y, p.z])
+                .ok()?;
+            shape.clip(from, to, p)
+        });
+        let Some(hit) = hit.ok().flatten() else {
+            return;
+        };
+        let state = self.world.block(hit.block.x, hit.block.y, hit.block.z);
+        if !self.res.facts().get(state).name.ends_with("lightning_rod") {
+            return;
+        }
+        let edge = f64::from(1.0e-5f32);
+        let clamp =
+            |v: f64, origin: i32| v.clamp(f64::from(origin) + edge, f64::from(origin) + 1.0 - edge);
+        self.channel_lightning([
+            clamp(hit.location.x, hit.block.x),
+            clamp(hit.location.y, hit.block.y),
+            clamp(hit.location.z, hit.block.z),
+        ]);
+    }
     /// `TridentItem.releaseUsing`.
     pub(super) fn release_trident(&mut self, ticks: u32) {
         if ticks < 10 {
@@ -311,9 +376,10 @@ impl Game<'_> {
                     });
                     let damage = 8.0 + if aquatic { 2.5 * impaling } else { 0.0 };
                     t.dealt_damage = true;
+                    let mut hurt_at = None;
                     if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
                         let from = Some([t.position.x, t.position.y, t.position.z]);
-                        m.damage(
+                        let hurt = m.damage(
                             damage,
                             Damage {
                                 kind: DamageKind::Arrow,
@@ -321,6 +387,15 @@ impl Game<'_> {
                                 from,
                             },
                         );
+                        if hurt {
+                            hurt_at = Some([m.position.x, m.position.y, m.position.z]);
+                        }
+                    }
+                    // `minecraft:post_attack` of Channeling, on the victim.
+                    if let Some(at) = hurt_at
+                        && t.stack.enchantment_level("minecraft:channeling") > 0
+                    {
+                        self.channel_lightning(at);
                     }
                     self.audio.play(
                         "minecraft:item.trident.hit",
@@ -341,6 +416,7 @@ impl Game<'_> {
                         subject: None,
                     };
                     if let Ok(moved) = scene.resolve(bounds(t.position), t.velocity, 0.0, false) {
+                        let (from, flight) = (t.position, t.velocity);
                         let blocked = (moved.x - t.velocity.x).abs() > 1e-7
                             || (moved.y - t.velocity.y).abs() > 1e-7
                             || (moved.z - t.velocity.z).abs() > 1e-7;
@@ -350,6 +426,9 @@ impl Game<'_> {
                             t.position.z + moved.z,
                         );
                         if blocked {
+                            if t.stack.enchantment_level("minecraft:channeling") > 0 {
+                                self.channel_rod_hit(from, flight);
+                            }
                             t.in_ground = true;
                             t.velocity = Vec3::ZERO;
                             self.audio.play(

From 4d0116762c9a360490cc5c65510f9fd5b552b8b9 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:48:08 +0100
Subject: [PATCH 032/475] Apply Unbreaking to thrown tridents and stop Riptide
 while riding

Throwing a trident now wears it through the same durability path as Riptide, so Unbreaking applies, and it still never breaks the trident. Riptide no longer launches a player who is riding something.
---
 crates/horizon-client/src/game.rs         | 18 ++++++++++++++++++
 crates/horizon-client/src/game/trident.rs | 13 +++++--------
 2 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index b397882cd..390befe40 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -8660,6 +8660,24 @@ impl Game<'_> {
             }
         }
     }
+    /// `ItemStack.hurtWithoutBreaking`: Unbreaking applies, but the stack stops at
+    /// one point of durability left instead of breaking.
+    fn hurt_held_without_breaking(&mut self, amount: u32) {
+        if self.creative {
+            return;
+        }
+        let Some(held) = self.held().cloned() else {
+            return;
+        };
+        let amount = self.durability_loss(&held, amount);
+        let max = self.res.items().get(&held.item).map_or(0, |i| i.max_damage);
+        if amount == 0 || max == 0 {
+            return;
+        }
+        if let Some(stack) = self.held_mut().as_mut() {
+            stack.damage = (stack.damage + amount).min(max - 1);
+        }
+    }
     /// Block tool use: distinguish success, failure and fall-through for hand feedback.
     fn use_tool(
         &mut self,
diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs
index c31094596..af77ac50f 100644
--- a/crates/horizon-client/src/game/trident.rs
+++ b/crates/horizon-client/src/game/trident.rs
@@ -171,10 +171,11 @@ impl Game<'_> {
             .as_ref()
             .map(|p| [p.position.x, p.position.y, p.position.z]);
         if riptide > 0 {
-            if !self.in_water_or_rain() {
+            // `isInWaterOrRain() && !isPassenger()`.
+            if !self.in_water_or_rain() || self.riding.is_some() {
                 return;
             }
-            self.damage_held(1);
+            self.hurt_held_without_breaking(1);
             // trident_spin_attack_strength: 1.5 + 0.75 per level above the first.
             let strength = 1.5 + 0.75 * (riptide as f32 - 1.0);
             let d = view_vector(self.yaw, self.pitch);
@@ -195,12 +196,8 @@ impl Game<'_> {
             self.audio.play(&sound, at, 1.0, 1.0);
             return;
         }
-        // hurtWithoutBreaking, then the thrown copy.
-        if !self.creative
-            && let Some(s) = self.held_mut().as_mut()
-        {
-            s.damage += 1;
-        }
+        // hurtWithoutBreaking (Unbreaking applies), then the thrown copy.
+        self.hurt_held_without_breaking(1);
         let thrown = self.held().cloned().unwrap_or(stack);
         if !self.creative {
             *self.held_mut() = None;

From 02f222728d7d182d278879fb20e7a9b9d5ccc16d Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:48:13 +0100
Subject: [PATCH 033/475] Respect mobGriefing for mob explosions and endermen

Mob explosions (creepers, ghast fireballs, wither skulls and the wither
spawn blast) now keep blocks when mobGriefing is off, and follow the
mob_explosion_drop_decay rule when it is on. Endermen no longer pick up
or put down blocks with mobGriefing off.
---
 crates/horizon-client/src/game.rs          | 19 +++++++++++--------
 crates/horizon-client/src/mobs/enderman.rs | 14 ++++++++++----
 2 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index b397882cd..3e9a419c3 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -7657,15 +7657,18 @@ impl Game<'_> {
         }
     }
     /// ServerExplosion: rays from a 16^3 grid lose (resistance + 0.3) * 0.3 per step.
-    /// A mob explosion (`Level.ExplosionInteraction.MOB`: drop decay with the
-    /// default mobGriefing rule).
+    /// A mob explosion (`ServerLevel.explode` with `ExplosionInteraction.MOB`:
+    /// blocks are kept without mobGriefing, else the mob_explosion_drop_decay
+    /// rule picks decay).
     fn explode(&mut self, center: [f64; 3], radius: f32) -> Result<()> {
-        self.server_explode(
-            center,
-            radius,
-            explosion::BlockInteraction::DestroyWithDecay,
-            false,
-        )
+        let interaction = if !self.ui.rules.bool("mob_griefing") {
+            explosion::BlockInteraction::Keep
+        } else if self.ui.rules.bool("mob_explosion_drop_decay") {
+            explosion::BlockInteraction::DestroyWithDecay
+        } else {
+            explosion::BlockInteraction::Destroy
+        };
+        self.server_explode(center, radius, interaction, false)
     }
     /// Copies of a save batch carrying its live block entities and save data.
     fn with_entities<'a>(
diff --git a/crates/horizon-client/src/mobs/enderman.rs b/crates/horizon-client/src/mobs/enderman.rs
index c5ed01680..3ccd963a2 100644
--- a/crates/horizon-client/src/mobs/enderman.rs
+++ b/crates/horizon-client/src/mobs/enderman.rs
@@ -331,8 +331,11 @@ impl Goal for TakeBlock {
     fn flags(&self) -> u8 {
         0
     }
-    fn can_use(&mut self, m: &mut Mob, _: &mut Cx) -> bool {
-        m.extra.carried.is_none() && m.random.next_int_bound(reduced(20)).unwrap_or(1) == 0
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        // EndermanTakeBlockGoal.canUse: needs mobGriefing, checked before the draw.
+        m.extra.carried.is_none()
+            && cx.w.mob_griefing
+            && m.random.next_int_bound(reduced(20)).unwrap_or(1) == 0
     }
     fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
         let x = (m.position.x - 2.0 + m.random.next_double() * 4.0).floor() as i32;
@@ -379,8 +382,11 @@ impl Goal for LeaveBlock {
     fn flags(&self) -> u8 {
         0
     }
-    fn can_use(&mut self, m: &mut Mob, _: &mut Cx) -> bool {
-        m.extra.carried.is_some() && m.random.next_int_bound(reduced(2000)).unwrap_or(1) == 0
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        // EndermanLeaveBlockGoal.canUse: needs mobGriefing, checked before the draw.
+        m.extra.carried.is_some()
+            && cx.w.mob_griefing
+            && m.random.next_int_bound(reduced(2000)).unwrap_or(1) == 0
     }
     fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
         let Some(carried) = m.extra.carried else {

From 48c0f39e9677ff52e6027362c4c468cf73360e1b Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:48:15 +0100
Subject: [PATCH 034/475] Farmers make bread and compost seeds when they work
 at a composter

A farmer working at its composter turns wheat into bread (three wheat for one
loaf, up to three loaves, while it holds at most 36 bread) and puts spare wheat
and beetroot seeds into the composter, emptying a full one first, as
WorkAtComposter does. Other professions are unchanged.
---
 crates/horizon-client/src/game/composter.rs   | 77 +++++++++++++++++++
 crates/horizon-client/src/game/creatures.rs   |  1 +
 crates/horizon-client/src/game/villagers.rs   | 32 ++++++++
 crates/horizon-client/src/mobs.rs             |  7 ++
 crates/horizon-client/src/mobs/villager.rs    | 18 +++++
 .../horizon-client/src/mobs/villager_brain.rs | 16 +++-
 crates/horizon-world/src/level/interact.rs    | 71 +++++++++++++----
 7 files changed, 208 insertions(+), 14 deletions(-)

diff --git a/crates/horizon-client/src/game/composter.rs b/crates/horizon-client/src/game/composter.rs
index 3f57229ad..4013155ad 100644
--- a/crates/horizon-client/src/game/composter.rs
+++ b/crates/horizon-client/src/game/composter.rs
@@ -5,6 +5,7 @@
 use super::{Game, commands::compute::ComputeContext};
 use horizon_client::{
     items::ItemStack,
+    mobs::villager,
     particles::{ParticleOptions, ParticleType},
 };
 use horizon_core::{position::BlockPos, random::RandomSource};
@@ -86,6 +87,82 @@ impl Game<'_> {
         self.composter_add(pos, &layers);
         (stack.count > 0).then_some(stack)
     }
+    /// `WorkAtComposter.compostItems` for the villager at `mob`: a full
+    /// composter is emptied, then up to 20 wheat or beetroot seeds go in
+    /// (keeping 10 of each kind) until the composter reaches level 7. Level
+    /// event 1500 plays once, at the end.
+    pub(super) fn villager_compost_items(&mut self, mob: usize, pos: [i32; 3]) {
+        let at = BlockPos::new(pos[0], pos[1], pos[2]);
+        let Some(mut before) = self.composter_level(pos) else {
+            return;
+        };
+        if before == 8 {
+            self.with_level(|b, level, ticks| b.composter_extract(level, ticks, at));
+            let _ = self.process_level_events();
+            before = 0;
+        }
+        let mut remaining = 20;
+        let mut amounts: Vec<(std::sync::Arc<str>, i32)> = Vec::new();
+        let slots = villager::ext(&self.mobs[mob]).map_or(0, |e| e.inventory.len());
+        'slots: for slot in (0..slots).rev() {
+            if remaining <= 0 {
+                break;
+            }
+            let stack = villager::ext_mut(&mut self.mobs[mob]).inventory[slot].clone();
+            if !matches!(
+                &*stack.item,
+                "minecraft:wheat_seeds" | "minecraft:beetroot_seeds"
+            ) {
+                continue;
+            }
+            let known = amounts.iter().position(|(item, _)| *item == stack.item);
+            let total = known.map_or(0, |k| amounts[k].1) + stack.count as i32;
+            match known {
+                Some(k) => amounts[k].1 = total,
+                None => amounts.push((stack.item.clone(), total)),
+            }
+            let uses = (total - 10).min(remaining).min(stack.count as i32);
+            if uses <= 0 {
+                continue;
+            }
+            remaining -= uses;
+            for _ in 0..uses {
+                self.villager_insert_item(mob, slot, &stack, pos);
+                if self.composter_level(pos) == Some(7) {
+                    break 'slots;
+                }
+            }
+        }
+        let after = self.composter_level(pos).unwrap_or(before);
+        self.with_level(|b, level, ticks| {
+            b.composter_fill_effects(level, ticks, at, after != before)
+        });
+        let _ = self.process_level_events();
+    }
+    /// `ComposterBlock.insertItem` with a villager's stack: below level 7 a
+    /// compostable item is used up and may add a layer.
+    fn villager_insert_item(&mut self, mob: usize, slot: usize, stack: &ItemStack, pos: [i32; 3]) {
+        if self.composter_level(pos).is_none_or(|level| level >= 7) {
+            return;
+        }
+        let Some(layers) = self.compostable(stack) else {
+            return;
+        };
+        let context = ComputeContext {
+            block: Some(pos),
+            target: None,
+        };
+        let layers = self.provider_int(&layers, &context, 0).unwrap_or(0);
+        let at = BlockPos::new(pos[0], pos[1], pos[2]);
+        self.with_level(|b, level, ticks| b.composter_layer(level, ticks, at, layers));
+        self.world.modified.insert((pos[0] >> 4, pos[2] >> 4));
+        let _ = self.process_level_events();
+        let inventory = &mut villager::ext_mut(&mut self.mobs[mob]).inventory;
+        inventory[slot].count -= 1;
+        if inventory[slot].count == 0 {
+            inventory.remove(slot);
+        }
+    }
     /// `ComposterBlock.handleFill` (level event 1500) on the client: the
     /// fill sound and ten composter particles above the compost.
     pub(super) fn composter_fill_event(&mut self, pos: BlockPos, success: bool) {
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 3a8562ee1..58e032b78 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1195,6 +1195,7 @@ impl Game<'_> {
                     partner,
                     child,
                 } => self.villager_birth(parent, partner, child),
+                MobEvent::WorkAtComposter { mob, pos } => self.villager_work_at_composter(mob, pos),
                 MobEvent::GolemCheck { mob, needed } => self.villager_golem_check(mob, needed),
                 MobEvent::Firework { at, color, flight } => {
                     self.villager_firework(at, color, flight)
diff --git a/crates/horizon-client/src/game/villagers.rs b/crates/horizon-client/src/game/villagers.rs
index 3cfe8aa1d..c04b18604 100644
--- a/crates/horizon-client/src/game/villagers.rs
+++ b/crates/horizon-client/src/game/villagers.rs
@@ -21,6 +21,38 @@ impl Game<'_> {
     fn item_max_stack(&self, item: &str) -> u32 {
         self.res.items().get(item).map_or(64, |i| i.max_stack)
     }
+    /// `WorkAtComposter.useWorkstation`: at a composter the farmer makes
+    /// bread, then composts seeds.
+    pub(super) fn villager_work_at_composter(&mut self, id: u32, pos: [i32; 3]) {
+        let Some(i) = self.villager_index(id) else {
+            return;
+        };
+        if self.composter_level(pos).is_none() {
+            return;
+        }
+        self.villager_make_bread(i);
+        self.villager_compost_items(i, pos);
+    }
+    /// `WorkAtComposter.makeBread`: up to three loaves from nine wheat while
+    /// the villager holds at most 36 bread; what does not fit drops.
+    fn villager_make_bread(&mut self, i: usize) {
+        let max_stack = self.item_max_stack("minecraft:bread");
+        let e = villager::ext_mut(&mut self.mobs[i]);
+        if e.count_item("minecraft:bread") > 36 {
+            return;
+        }
+        let loaves = (e.count_item("minecraft:wheat") / 3).min(3);
+        if loaves == 0 {
+            return;
+        }
+        e.remove_item("minecraft:wheat", loaves * 3);
+        let left = e.add_item(ItemStack::new("minecraft:bread", loaves), max_stack);
+        if let Some(rest) = left {
+            // spawnAtLocation(level, stack, 0.5F)
+            let p = self.mobs[i].position;
+            self.spawn_item(rest, [p.x, p.y + 0.5, p.z], [0.0, 0.2, 0.0], 10);
+        }
+    }
     /// `BehaviorUtils.throwItem`: toss a stack from a villager's hand toward
     /// a point.
     fn villager_throw(&mut self, from: Vec3, eye: f64, to: Vec3, stack: ItemStack) {
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..c51352f40 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1098,6 +1098,13 @@ pub enum MobEvent {
         partner: u32,
         child: Option<([i32; 3], Option<u8>)>,
     },
+    /// `WorkAtComposter.useWorkstation`: a farmer at its composter makes
+    /// bread and composts seeds (the game applies it to the villager's
+    /// inventory and the block).
+    WorkAtComposter {
+        mob: u32,
+        pos: [i32; 3],
+    },
     /// A villager asks whether enough neighbours want an iron golem.
     GolemCheck {
         mob: u32,
diff --git a/crates/horizon-client/src/mobs/villager.rs b/crates/horizon-client/src/mobs/villager.rs
index 575fafaed..608882a1f 100644
--- a/crates/horizon-client/src/mobs/villager.rs
+++ b/crates/horizon-client/src/mobs/villager.rs
@@ -446,6 +446,24 @@ impl Ext {
         }
         (stack.count > 0).then_some(stack)
     }
+    /// `SimpleContainer.removeItemType`: take up to `count` of the item from
+    /// the first stacks that hold it.
+    pub fn remove_item(&mut self, item: &str, mut count: u32) {
+        let mut slot = 0;
+        while slot < self.inventory.len() && count > 0 {
+            let s = &mut self.inventory[slot];
+            if &*s.item == item {
+                let n = s.count.min(count);
+                s.count -= n;
+                count -= n;
+                if s.count == 0 {
+                    self.inventory.remove(slot);
+                    continue;
+                }
+            }
+            slot += 1;
+        }
+    }
     pub fn count_item(&self, item: &str) -> u32 {
         self.inventory
             .iter()
diff --git a/crates/horizon-client/src/mobs/villager_brain.rs b/crates/horizon-client/src/mobs/villager_brain.rs
index 7b311a9e0..72581360f 100644
--- a/crates/horizon-client/src/mobs/villager_brain.rs
+++ b/crates/horizon-client/src/mobs/villager_brain.rs
@@ -1242,6 +1242,8 @@ enum B {
     WorkAtPoi {
         t: Timed,
         last_check: i64,
+        /// `WorkAtComposter` (a farmer's package) rather than `WorkAtPoi`.
+        composter: bool,
     },
     StrollAroundPoi {
         running: bool,
@@ -1635,7 +1637,11 @@ impl B {
                 *birth = now + 275 + i64::from(m.random.next_int_bound(50).unwrap_or(0));
                 true
             }
-            B::WorkAtPoi { t, last_check } => {
+            B::WorkAtPoi {
+                t,
+                last_check,
+                composter,
+            } => {
                 let mm = mem(m);
                 let Some(site) = mm.job_site.value() else {
                     return false;
@@ -1656,6 +1662,13 @@ impl B {
                 mm.last_worked_at_poi.set(now);
                 mm.look_target.set(Tracker::Block(site));
                 play_work_sound(m, cx);
+                // WorkAtComposter.useWorkstation, before the restock.
+                if *composter {
+                    cx.events.push(MobEvent::WorkAtComposter {
+                        mob: m.id,
+                        pos: site,
+                    });
+                }
                 restock_if_due(m, cx.w);
                 true
             }
@@ -3775,6 +3788,7 @@ fn packages(baby: bool, seed: i64, farmer: bool) -> Vec<Entry> {
                         B::WorkAtPoi {
                             t: timed(60, 60),
                             last_check: 0,
+                            composter: farmer,
                         },
                         7,
                     ),
diff --git a/crates/horizon-world/src/level/interact.rs b/crates/horizon-world/src/level/interact.rs
index 7b2195c34..a1f786184 100644
--- a/crates/horizon-world/src/level/interact.rs
+++ b/crates/horizon-world/src/level/interact.rs
@@ -227,19 +227,7 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
                     if table.int(state, p.level) != 8 {
                         return Pass;
                     }
-                    self.player_effect(
-                        pos,
-                        state,
-                        PlayerEffect::DropItem("minecraft:bone_meal".into()),
-                    );
-                    self.set_block_and_update(pos, table.set_int(state, p.level, 0));
-                    self.game_event(pos, "minecraft:block_change");
-                    self.emit(LevelEvent::Sound {
-                        pos,
-                        sound: "minecraft:block.composter.empty".into(),
-                        volume: 1.0,
-                        pitch: 1.0,
-                    });
+                    self.composter_extract_produce(pos, state);
                     Success
                 }
                 Class::CaveVines | Class::CaveVinesPlant => {
@@ -437,6 +425,25 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
 
     /// `ComposterBlock.addLayer` once its `compostable` provider gave
     /// `layers`: the new state (the old one when no layer is added).
+    /// `ComposterBlock.extractProduce`: the bone meal pops out, the composter
+    /// empties and its sound plays.
+    fn composter_extract_produce(&mut self, pos: BlockPos, state: BlockStateId) {
+        let b = self.b;
+        self.player_effect(
+            pos,
+            state,
+            PlayerEffect::DropItem("minecraft:bone_meal".into()),
+        );
+        self.set_block_and_update(pos, b.table.set_int(state, b.props.level, 0));
+        self.game_event(pos, "minecraft:block_change");
+        self.emit(LevelEvent::Sound {
+            pos,
+            sound: "minecraft:block.composter.empty".into(),
+            volume: 1.0,
+            pitch: 1.0,
+        });
+    }
+
     fn composter_add_layer(&mut self, pos: BlockPos, layers: i32) -> BlockStateId {
         let b = self.b;
         let state = self.state(pos);
@@ -499,6 +506,44 @@ impl Behaviours {
         next
     }
 
+    /// `ComposterBlock.addLayer` without level event 1500, for a villager
+    /// that composts several items and sends the event once at the end
+    /// (`WorkAtComposter.compostItems`). The new state.
+    pub fn composter_layer<L: LevelAccess + ?Sized>(
+        &self,
+        level: &mut L,
+        ticks: &mut Ticks,
+        pos: BlockPos,
+        layers: i32,
+    ) -> BlockStateId {
+        self.sim(level, ticks).composter_add_layer(pos, layers)
+    }
+
+    /// `ComposterBlock.extractProduce` by a villager (`WorkAtComposter`).
+    pub fn composter_extract<L: LevelAccess + ?Sized>(
+        &self,
+        level: &mut L,
+        ticks: &mut Ticks,
+        pos: BlockPos,
+    ) {
+        let mut sim = self.sim(level, ticks);
+        let state = sim.state(pos);
+        sim.composter_extract_produce(pos, state);
+    }
+
+    /// Level event 1500 (`WorkAtComposter.spawnComposterFillEffects`): data 1
+    /// when the composter's state changed.
+    pub fn composter_fill_effects<L: LevelAccess + ?Sized>(
+        &self,
+        level: &mut L,
+        ticks: &mut Ticks,
+        pos: BlockPos,
+        changed: bool,
+    ) {
+        self.sim(level, ticks)
+            .level_event(1500, pos, i32::from(changed));
+    }
+
     /// `ComposterBlock.empty`: the hopper output container took the bone meal.
     pub fn composter_empty<L: LevelAccess + ?Sized>(
         &self,

From 02e5c728c3e886ba29dd4c28c3745c4f83fcd966 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:49:57 +0100
Subject: [PATCH 035/475] Pick the skeleton bow interval by difficulty

Skeletons now shoot every 20 ticks on Hard and every 40 otherwise
(bogged and parched: 50 and 70) instead of always using the normal
interval.
---
 crates/horizon-client/src/mobs/undead.rs | 32 +++++++++++++++++++-----
 1 file changed, 26 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/mobs/undead.rs b/crates/horizon-client/src/mobs/undead.rs
index e77a37641..efff2b73e 100644
--- a/crates/horizon-client/src/mobs/undead.rs
+++ b/crates/horizon-client/src/mobs/undead.rs
@@ -136,12 +136,13 @@ pub fn register(m: &mut Mob) {
             }
             // The AbstractSkeleton constructor's reassessWeaponGoal, after
             // registerGoals; the weapon itself comes with finalizeSpawn.
-            let interval = if matches!(species, S::Bogged | S::Parched) {
-                70
+            // getHardAttackInterval / getAttackInterval.
+            let (hard, normal) = if matches!(species, S::Bogged | S::Parched) {
+                (50, 70)
             } else {
-                40
+                (20, 40)
             };
-            m.ai.goals.add(4, SkeletonWeapon::new(interval));
+            m.ai.goals.add(4, SkeletonWeapon::new(hard, normal));
         }
         _ => {}
     }
@@ -524,13 +525,20 @@ pub struct SkeletonWeapon {
     bow: BowAttack,
     melee: MeleeAttack,
     use_bow: bool,
+    /// The weapon the goal was last reassessed for.
+    assessed: Option<bool>,
+    hard_interval: i32,
+    normal_interval: i32,
 }
 impl SkeletonWeapon {
-    pub fn new(bow_interval: i32) -> Self {
+    pub fn new(hard_interval: i32, normal_interval: i32) -> Self {
         Self {
-            bow: BowAttack::new(1.0, bow_interval, 15.0),
+            bow: BowAttack::new(1.0, normal_interval, 15.0),
             melee: MeleeAttack::new(1.2, false),
             use_bow: false,
+            assessed: None,
+            hard_interval,
+            normal_interval,
         }
     }
 }
@@ -556,6 +564,18 @@ impl Goal for SkeletonWeapon {
     fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
         // The goal registered for the weapon in hand.
         self.use_bow = holding_bow(m);
+        // reassessWeaponGoal: a bow gets the hard interval only on Hard; it
+        // is picked again when the weapon changes (the first check after
+        // spawning or loading stands for finalizeSpawn and
+        // readAdditionalSaveData).
+        if self.assessed != Some(self.use_bow) {
+            self.assessed = Some(self.use_bow);
+            self.bow.interval_min = if cx.w.difficulty.hard {
+                self.hard_interval
+            } else {
+                self.normal_interval
+            };
+        }
         if self.use_bow {
             self.bow.can_use(m, cx)
         } else {

From 8178ec3dae58d4d4f08afcfcf24ff08d56081c30 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:51:46 +0100
Subject: [PATCH 036/475] Let a fire charge light a creeper

A creeper is now lit by any item in the creeper_igniters tag, not only
flint and steel. A fire charge is used up and plays its own sound; flint
and steel still loses durability.
---
 crates/horizon-client/src/game/creatures.rs | 30 ++++++++++++++++++---
 1 file changed, 27 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 119fe2a1e..02ee16236 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2524,6 +2524,19 @@ impl Game<'_> {
             }
             return Ok(true);
         }
+        // Creeper.mobInteract: any item in #creeper_igniters, damaged when it
+        // is damageable and used up otherwise.
+        let creeper_igniter = self
+            .res
+            .items()
+            .item_tags
+            .get("minecraft:creeper_igniters")
+            .is_some_and(|t| t.contains(&*item));
+        let damageable = self
+            .res
+            .items()
+            .get(&item)
+            .is_some_and(|i| i.max_damage > 0);
         let m = &mut self.mobs[index];
         if !m.alive() {
             return Ok(false);
@@ -2764,10 +2777,21 @@ impl Game<'_> {
                 consume = true;
                 sound = Some("entity.iron_golem.repair");
             }
-            Species::Creeper if item == "minecraft:flint_and_steel" => {
+            Species::Creeper if creeper_igniter => {
                 m.extra.flag = true;
-                sound = Some("item.flintandsteel.use");
-                self.damage_held_tool();
+                // FIRECHARGE_USE for a fire charge, else FLINTANDSTEEL_USE,
+                // at the creeper's feet with a pitch from its own random.
+                let event = if item == "minecraft:fire_charge" {
+                    "item.firecharge.use"
+                } else {
+                    "item.flintandsteel.use"
+                };
+                eat = Some((event, 1.0, m.random.next_float() * 0.4 + 0.8));
+                if damageable {
+                    self.damage_held_tool();
+                } else {
+                    consume = true;
+                }
             }
             // Parrot.mobInteract: parrot food may tame a wild one (one time in
             // ten); a parrot never takes it as Animal food (isFood is false).

From 5d30776b07610197935f14ea820ecbd2d4b94a04 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:51:56 +0100
Subject: [PATCH 037/475] Make Piercing crossbow arrows pass through entities

Crossbow arrows now get their pierce level from the Piercing enchantment, go through that many entities plus one without sticking, and are discarded at the next one. Arrows without Piercing behave as before. Pillager arrows now use the pierce level their weapon already carried.
---
 crates/horizon-client/src/arrows.rs        | 35 ++++++++++++++++++++--
 crates/horizon-client/src/game/crossbow.rs | 16 ++++++++++
 crates/horizon-client/src/projectiles.rs   | 11 +++----
 3 files changed, 54 insertions(+), 8 deletions(-)

diff --git a/crates/horizon-client/src/arrows.rs b/crates/horizon-client/src/arrows.rs
index 30b501011..9f584899e 100644
--- a/crates/horizon-client/src/arrows.rs
+++ b/crates/horizon-client/src/arrows.rs
@@ -156,7 +156,11 @@ pub struct ArrowState {
     /// `pickupItemStack`: what picking the arrow up gives.
     pub pickup_item: crate::items::ItemStack,
     pub no_physics: bool,
+    /// `AbstractArrow.getPierceLevel`.
     pub pierce: u8,
+    /// `piercingIgnoreEntityIds`: the entities a piercing arrow has gone
+    /// through (cleared when it sticks in a block).
+    pub pierced: Vec<Who>,
     /// `Entity.remainingFireTicks`.
     pub fire_ticks: i32,
     pub fall_distance: f64,
@@ -199,6 +203,7 @@ impl ArrowState {
             pickup_item: crate::items::ItemStack::new("minecraft:arrow", 1),
             no_physics: false,
             pierce: 0,
+            pierced: Vec::new(),
             fire_ticks: 0,
             fall_distance: 0.0,
             fluids: EntityFluidInteraction::new([WATER, LAVA]),
@@ -431,10 +436,19 @@ pub fn finish_entity_hit(p: &mut Projectile, scene: &ArrowScene, outcome: Entity
     match outcome {
         EntityHit::Hurt => {
             ticker.hit_sound();
-            ticker.st.removed = true;
+            // A piercing arrow flies on (`getPierceLevel() <= 0` discards).
+            if ticker.st.pierce == 0 {
+                ticker.st.removed = true;
+            }
         }
         EntityHit::Refused => ticker.turn_back(),
-        EntityHit::Deflected => {}
+        EntityHit::Deflected => {
+            // The deflection comes before `onHitEntity` adds the entity to
+            // `piercingIgnoreEntityIds`.
+            if ticker.st.pierce > 0 {
+                ticker.st.pierced.pop();
+            }
+        }
     }
     ticker.finish();
     p.stuck = st.in_ground;
@@ -639,7 +653,8 @@ impl Ticker<'_, '_, '_, '_> {
         self.st.life = 0;
     }
     /// `AbstractArrow.stepMoveAndHit`: the nearest entity on the way, else the
-    /// block (piercing is not modelled).
+    /// block. A piercing arrow that hits an entity here goes on from it next
+    /// tick (`finish_entity_hit`); vanilla's loop goes on within the same tick.
     fn step_move_and_hit(&mut self, from: Vec3, to: Vec3, targets: &[(Who, Aabb)]) -> Hit {
         let block = self.scene.clip(from, to);
         let end = block.map_or(to, |b| b.0);
@@ -653,6 +668,10 @@ impl Ticker<'_, '_, '_, '_> {
             if Some(*who) == self.p.owner && !self.p.left_owner || !b.intersects(area) {
                 continue;
             }
+            // canHitEntity: not an entity a piercing arrow has gone through.
+            if self.st.pierced.contains(who) {
+                continue;
+            }
             if let Some(at) = self.entity_hit(b, from, end, margin) {
                 // Sorted by the distance to the entity's position (the
                 // stable sort keeps the first of equals).
@@ -667,6 +686,15 @@ impl Ticker<'_, '_, '_, '_> {
         self.p.position = next;
         self.apply_effects_from_blocks(from, next);
         if let Some((who, at, _)) = best {
+            // AbstractArrow.onHitEntity: past pierce level + 1 entities the
+            // arrow is discarded before it hurts the next one.
+            if self.st.pierce > 0 {
+                if self.st.pierced.len() > usize::from(self.st.pierce) {
+                    self.st.removed = true;
+                    return Hit::None;
+                }
+                self.st.pierced.push(who);
+            }
             return Hit::Entity { who, at };
         }
         let Some((at, pos, face)) = block else {
@@ -752,6 +780,7 @@ impl Ticker<'_, '_, '_, '_> {
         self.st.shake = 7;
         self.p.set_critical(false);
         self.st.pierce = 0;
+        self.st.pierced.clear();
     }
     /// `Projectile.mayInteract`: a mob's arrows need `mob_griefing`.
     fn may_interact(&self) -> bool {
diff --git a/crates/horizon-client/src/game/crossbow.rs b/crates/horizon-client/src/game/crossbow.rs
index 70ccba8d3..bc49c4b90 100644
--- a/crates/horizon-client/src/game/crossbow.rs
+++ b/crates/horizon-client/src/game/crossbow.rs
@@ -6,6 +6,7 @@
 //! finds the ammo for bows and crossbows.
 use super::{Game, shield::OFFHAND_SLOT, view_vector};
 use horizon_client::{
+    enchant::EffectContext,
     items::ItemStack,
     mobs::Who,
     projectiles::{Projectile, ProjectileKind},
@@ -152,6 +153,20 @@ impl Game<'_> {
         };
         let charged = std::mem::take(&mut bow.data_mut().charged);
         bow.tidy();
+        let weapon = bow.clone();
+        // AbstractArrow's constructor: `getPiercingCount` of the weapon.
+        let pierce = self
+            .res
+            .stations()
+            .enchantments
+            .modify_value(
+                Some(&weapon),
+                "minecraft:projectile_piercing",
+                &EffectContext::default(),
+                &mut self.world.random,
+                0.0,
+            )
+            .clamp(0.0, 127.0) as u8;
         let count = charged.len();
         // getShootingPower: a rocket among them slows every shot.
         let power = if charged.iter().any(|s| &*s.item == FIREWORK_ROCKET) {
@@ -204,6 +219,7 @@ impl Game<'_> {
                 if let Some(a) = arrow.arrow.as_mut() {
                     a.set_item(ammo);
                     a.set_owner(Some(Who::Player));
+                    a.pierce = pierce;
                 }
                 arrow.shoot(&mut self.world.random, dir.to_array(), power, 1.0);
                 self.creatures.projectiles.push(arrow);
diff --git a/crates/horizon-client/src/projectiles.rs b/crates/horizon-client/src/projectiles.rs
index 219d59b6b..8a709067d 100644
--- a/crates/horizon-client/src/projectiles.rs
+++ b/crates/horizon-client/src/projectiles.rs
@@ -186,12 +186,13 @@ impl Projectile {
         self
     }
     /// The shooter's bow enchantments; Flame spawns the arrow burning for 100
-    /// seconds (`projectile_spawned` ignite).
+    /// seconds (`projectile_spawned` ignite), Piercing sets its pierce level.
     pub fn set_bonus(&mut self, bonus: crate::mobs::gear::ArrowBonus) {
-        if bonus.flame
-            && let Some(a) = self.arrow.as_mut()
-        {
-            a.ignite_for_seconds(100.0);
+        if let Some(a) = self.arrow.as_mut() {
+            if bonus.flame {
+                a.ignite_for_seconds(100.0);
+            }
+            a.pierce = bonus.pierce.min(127) as u8;
         }
         self.bonus = bonus;
     }

From 688d86db7cc05196a00e9e91c09741e0e123540c Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:51:58 +0100
Subject: [PATCH 038/475] Villagers look for a child's bed in a full 48 block
 sphere and only take one they can reach

The search only covered 8 blocks up and down. It now uses the POI index over
the whole sphere, and a bed only counts when the villager has a path to it,
as VillagerMakeLove.takeVacantBed does.
---
 crates/horizon-client/src/mobs/villager.rs    | 24 -------------------
 .../horizon-client/src/mobs/villager_brain.rs | 24 ++++++++++++++-----
 2 files changed, 18 insertions(+), 30 deletions(-)

diff --git a/crates/horizon-client/src/mobs/villager.rs b/crates/horizon-client/src/mobs/villager.rs
index 575fafaed..83ca28b71 100644
--- a/crates/horizon-client/src/mobs/villager.rs
+++ b/crates/horizon-client/src/mobs/villager.rs
@@ -752,30 +752,6 @@ pub fn finalize_summoned_golem(m: &mut Mob, random: &mut impl RandomSource) {
     }
     m.extra.left_handed = random.next_float() < 0.05;
 }
-/// `PoiManager.take(HOME, ..., 48)`: the nearest bed head not `claimed`
-/// (`free_head`: a bed head that is not occupied).
-pub fn take_vacant_bed(
-    claimed: &[[i32; 3]],
-    from: [i32; 3],
-    mut free_head: impl FnMut(i32, i32, i32) -> bool,
-) -> Option<[i32; 3]> {
-    let mut best: Option<(i32, [i32; 3])> = None;
-    for y in from[1] - 8..=from[1] + 8 {
-        for z in from[2] - 48..=from[2] + 48 {
-            for x in from[0] - 48..=from[0] + 48 {
-                let d = (x - from[0]).pow(2) + (y - from[1]).pow(2) + (z - from[2]).pow(2);
-                if d <= 48 * 48
-                    && best.is_none_or(|(b, _)| d < b)
-                    && free_head(x, y, z)
-                    && !claimed.contains(&[x, y, z])
-                {
-                    best = Some((d, [x, y, z]));
-                }
-            }
-        }
-    }
-    best.map(|(_, p)| p)
-}
 /// `Villager.canBreed`: enough food, awake and an adult.
 pub fn can_breed(m: &Mob) -> bool {
     m.species() == Species::Villager
diff --git a/crates/horizon-client/src/mobs/villager_brain.rs b/crates/horizon-client/src/mobs/villager_brain.rs
index 7b311a9e0..1e39e1da2 100644
--- a/crates/horizon-client/src/mobs/villager_brain.rs
+++ b/crates/horizon-client/src/mobs/villager_brain.rs
@@ -3396,8 +3396,10 @@ fn breeding_possible(m: &mut Mob, w: &MobWorld) -> bool {
         && super::villager::can_breed(m)
         && w.seen(id).is_some_and(|s| s.in_love)
 }
-/// `VillagerMakeLove.takeVacantBed`: a bed head no villager has claimed.
-fn take_bed_for_child(m: &Mob, w: &MobWorld) -> Option<[i32; 3]> {
+/// `VillagerMakeLove.takeVacantBed`: `PoiManager.take(HOME, ..., 48)` over a
+/// sphere of 48 blocks, the nearest bed head no villager has claimed that the
+/// villager can walk to (`canReach`: a path that gets there).
+fn take_bed_for_child(m: &mut Mob, w: &MobWorld) -> Option<[i32; 3]> {
     let claimed: Vec<[i32; 3]> = w
         .others
         .iter()
@@ -3405,10 +3407,20 @@ fn take_bed_for_child(m: &Mob, w: &MobWorld) -> Option<[i32; 3]> {
         .filter_map(|s| s.bed)
         .chain(m.extra.bed)
         .collect();
-    let p = m.position;
-    let from = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32];
-    super::villager::take_vacant_bed(&claimed, from, |x, y, z| {
-        w.prop(x, y, z, "part") == Some("head") && w.prop(x, y, z, "occupied") != Some("true")
+    let from = block_of(m.position);
+    let mut beds: Vec<[i32; 3]> = homes_in_range(m, w, 48)
+        .into_iter()
+        .filter(|p| {
+            w.prop(p[0], p[1], p[2], "part") == Some("head")
+                && w.prop(p[0], p[1], p[2], "occupied") != Some("true")
+                && !claimed.contains(p)
+        })
+        .collect();
+    // Nearest first; equally near beds stay in scan order.
+    beds.sort_by_key(|p| dist_sqr(*p, from));
+    beds.into_iter().find(|&p| {
+        m.create_path_to(w, p, Poi::Home.valid_range())
+            .is_some_and(|path| path.reached)
     })
 }
 /// `BehaviorUtils.lockGazeAndWalkToEachOther`: this villager's half, and

From a489d65ab08bce13daa18a1970baedc1468fbae1 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:52:43 +0100
Subject: [PATCH 039/475] Arrows press wooden buttons and keep them pressed

Wooden buttons ignored arrows: a pressed button always released after
its delay. A button whose type allows arrows is now pressed when an
arrow (or a thrown trident) is inside its shape, and it stays pressed,
scheduling the release again, while one still is. Arrows now also run
the entityInside check on the blocks they pass through each tick.
---
 crates/horizon-client/src/arrows.rs        | 23 ++++++
 crates/horizon-client/src/game.rs          | 45 ++++++++++--
 crates/horizon-world/src/level/hooks.rs    |  7 ++
 crates/horizon-world/src/level/mod.rs      |  3 +
 crates/horizon-world/src/level/redstone.rs | 82 +++++++++++++++++++---
 5 files changed, 148 insertions(+), 12 deletions(-)

diff --git a/crates/horizon-client/src/arrows.rs b/crates/horizon-client/src/arrows.rs
index 30b501011..f6d011e93 100644
--- a/crates/horizon-client/src/arrows.rs
+++ b/crates/horizon-client/src/arrows.rs
@@ -362,6 +362,29 @@ fn bounds(at: Vec3) -> Aabb {
         Vec3::new(at.x + w, at.y + f64::from(HEIGHT), at.z + w),
     )
 }
+/// The bounding box of an arrow, or a thrown trident, at `at`.
+pub fn arrow_bounds(at: Vec3) -> Aabb {
+    bounds(at)
+}
+/// The blocks an arrow that moved from `from` to `to` was inside
+/// (`Entity.checkInsideBlocks`: the sweep of its box, 16 steps at most), for
+/// the blocks that react to it (`entityInside`).
+pub fn blocks_inside(from: Vec3, to: Vec3) -> Vec<BlockPos> {
+    let deflated = bounds(to).deflate(Vec3::new(
+        f64::from(1.0e-5f32),
+        f64::from(1.0e-5f32),
+        f64::from(1.0e-5f32),
+    ));
+    let mut inside = Vec::new();
+    let _ = sweep_intersected_blocks(from, to, deflated, 1_000_000, |p, iteration| {
+        if iteration >= 16 {
+            return false;
+        }
+        inside.push(p);
+        true
+    });
+    inside
+}
 /// `Projectile.lerpRotation`.
 fn lerp_rotation(mut old: f32, new: f32) -> f32 {
     while new - old < -180.0 {
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index b397882cd..8a21ec3ad 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -540,6 +540,8 @@ struct GameLevel<'w> {
     player_collision: Option<PlayerCollision>,
     /// Minecart boxes (detector rails).
     cart_boxes: Vec<([f64; 3], [f64; 3])>,
+    /// Arrow and thrown trident boxes (wooden buttons).
+    arrow_boxes: Vec<([f64; 3], [f64; 3])>,
     /// The other entities that keep blocks from being placed into them.
     blockers: Blockers<'w>,
     biomes: &'w Biomes,
@@ -827,8 +829,9 @@ impl LevelAccess for GameLevel<'_> {
     fn is_ticking_chunk(&self, chunk: horizon_core::position::ChunkPos) -> bool {
         self.tickets.block_ticking(chunk.x, chunk.z) && ticking_chunk(self.world, chunk.x, chunk.z)
     }
-    /// Entities that trigger pressure plates, tripwires and detector rails:
-    /// the players (the host and the LAN guests, mobs) and the minecarts.
+    /// Entities that trigger pressure plates, tripwires, detector rails and
+    /// wooden buttons: the players (the host and the LAN guests, mobs) and
+    /// the minecarts, and for `EntityQuery::Arrows` the arrows.
     fn count_entities(&self, area: Aabb, query: EntityQuery) -> usize {
         let hit = |(lo, hi): &([f64; 3], [f64; 3])| {
             area.intersects(Aabb::new(
@@ -837,6 +840,7 @@ impl LevelAccess for GameLevel<'_> {
             ))
         };
         let carts = || self.cart_boxes.iter().filter(|b| hit(b)).count();
+        let arrows = || self.arrow_boxes.iter().filter(|b| hit(b)).count();
         let players = || {
             self.player_box
                 .iter()
@@ -846,6 +850,7 @@ impl LevelAccess for GameLevel<'_> {
         };
         match query {
             EntityQuery::Minecart => carts(),
+            EntityQuery::Arrows => arrows(),
             EntityQuery::Mobs => players(),
             EntityQuery::Everything => players() + carts(),
         }
@@ -2445,6 +2450,18 @@ impl Game<'_> {
                 )
             })
             .collect();
+        let arrow_boxes = self
+            .creatures
+            .projectiles
+            .iter()
+            .filter(|p| p.arrow.is_some())
+            .map(|p| p.position)
+            .chain(self.tridents.iter().map(|t| t.position))
+            .map(|at| {
+                let b = horizon_client::arrows::arrow_bounds(at);
+                (b.min_position().components(), b.max_position().components())
+            })
+            .collect();
         let guest_boxes = self.lan_block_trigger_boxes();
         let dimension = match self.dim {
             Dim::Overworld => LevelDimension::Overworld,
@@ -2462,6 +2479,7 @@ impl Game<'_> {
         };
         let mut level = GameLevel {
             cart_boxes,
+            arrow_boxes,
             blockers,
             world: &mut self.world,
             facts: self.res.facts(),
@@ -2591,8 +2609,9 @@ impl Game<'_> {
             .copied()
             .filter(|&(x, z)| levels.random_ticking(x, z) && ticking_chunk(&self.world, x, z))
             .collect();
-        // Entity.checkInsideBlocks for the plates, tripwires and detector rails
-        // under the players (the host and the LAN guests) and the minecarts.
+        // Entity.checkInsideBlocks for the plates, tripwires, detector rails and
+        // buttons under the players (the host and the LAN guests), the minecarts
+        // and the arrows.
         let mut inside = Vec::new();
         let guests = self.lan_block_trigger_boxes();
         let boxes = self
@@ -2624,6 +2643,24 @@ impl Game<'_> {
                 }
             }
         }
+        // AbstractArrow.applyEffectsFromBlocks: the blocks every arrow passed
+        // through this tick (a wooden button is pressed by one inside it), and
+        // the ones a thrown trident is in.
+        for p in self
+            .creatures
+            .projectiles
+            .iter()
+            .filter(|p| p.arrow.is_some())
+        {
+            inside.extend(horizon_client::arrows::blocks_inside(
+                p.previous, p.position,
+            ));
+        }
+        for t in &self.tridents {
+            inside.extend(horizon_client::arrows::blocks_inside(
+                t.position, t.position,
+            ));
+        }
         // BigDripleafBlock.entityInside also asks whether the player stands on
         // the ground and how high its feet are: the leaves its box's feet
         // layer is inside (the host and the LAN guests).
diff --git a/crates/horizon-world/src/level/hooks.rs b/crates/horizon-world/src/level/hooks.rs
index 7f9e8d19a..f716449f5 100644
--- a/crates/horizon-world/src/level/hooks.rs
+++ b/crates/horizon-world/src/level/hooks.rs
@@ -447,6 +447,13 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
             if !b.table.bool(state, b.props.powered) {
                 self.detector_rail_check_pressed(pos, state);
             }
+        } else if data.is(Class::Button) {
+            // ButtonBlock.entityInside: a wooden button an arrow is inside.
+            if data.set_type.as_ref().is_some_and(|s| s.arrows)
+                && !b.table.bool(state, b.props.powered)
+            {
+                self.button_check_pressed(pos, state);
+            }
         } else if data.is(Class::TripWire)
             && !b.table.bool(state, b.props.powered)
             && !self.ticks.has_block_tick(pos, b.block(state))
diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs
index 3831efbd6..afba55028 100644
--- a/crates/horizon-world/src/level/mod.rs
+++ b/crates/horizon-world/src/level/mod.rs
@@ -205,6 +205,9 @@ pub enum EntityQuery {
     Mobs,
     /// Minecarts only (detector rails).
     Minecart,
+    /// Arrows only (`AbstractArrow`, thrown tridents included): the entities
+    /// a wooden button senses.
+    Arrows,
 }
 
 /// Side effects reported to the caller, in vanilla call order.
diff --git a/crates/horizon-world/src/level/redstone.rs b/crates/horizon-world/src/level/redstone.rs
index 92f9059e5..0230c76f6 100644
--- a/crates/horizon-world/src/level/redstone.rs
+++ b/crates/horizon-world/src/level/redstone.rs
@@ -879,18 +879,84 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
         }
         self.game_event(pos, "minecraft:block_activate");
     }
-    /// `ButtonBlock.checkPressed` with no arrows present.
+    /// `ButtonBlock.tick`.
     pub(crate) fn button_tick(&mut self, pos: BlockPos, state: BlockStateId) {
         let b = self.b;
-        if !b.table.bool(state, b.props.powered) {
-            return;
+        if b.table.bool(state, b.props.powered) {
+            self.button_check_pressed(pos, state);
         }
-        self.set_block_and_update(pos, b.table.set_bool(state, b.props.powered, false));
-        self.attached_update_neighbours(pos, state);
-        if let Some(set) = b.data(state).set_type.clone() {
-            self.sound(pos, &set.button_off, 1.0, 1.0);
+    }
+    /// `ButtonBlock.checkPressed`: a button whose type allows arrows is
+    /// pressed while an arrow is inside its shape, and stays pressed (the
+    /// release is scheduled again) as long as one is.
+    pub(crate) fn button_check_pressed(&mut self, pos: BlockPos, state: BlockStateId) {
+        let b = self.b;
+        let data = b.data(state);
+        let should_be_pressed = data.set_type.as_ref().is_some_and(|s| s.arrows)
+            && self
+                .level
+                .count_entities(self.button_bounds(pos, state), super::EntityQuery::Arrows)
+                > 0;
+        let was_pressed = b.table.bool(state, b.props.powered);
+        if should_be_pressed != was_pressed {
+            self.set_block_and_update(
+                pos,
+                b.table.set_bool(state, b.props.powered, should_be_pressed),
+            );
+            self.attached_update_neighbours(pos, state);
+            if let Some(set) = data.set_type.clone() {
+                let sound = if should_be_pressed {
+                    &set.button_on
+                } else {
+                    &set.button_off
+                };
+                self.sound(pos, sound, 1.0, 1.0);
+            }
+            self.game_event(
+                pos,
+                if should_be_pressed {
+                    "minecraft:block_activate"
+                } else {
+                    "minecraft:block_deactivate"
+                },
+            );
         }
-        self.game_event(pos, "minecraft:block_deactivate");
+        if should_be_pressed {
+            self.schedule_tick(pos, b.block(state), data.ticks_to_stay_pressed);
+        }
+    }
+    /// `ButtonBlock.getShape(...).bounds().move(pos)`: a 6 by 4 plate on the
+    /// face it is attached to, 2 pixels thick (1 when pressed).
+    fn button_bounds(&self, pos: BlockPos, state: BlockStateId) -> horizon_core::geometry::Aabb {
+        use horizon_core::geometry::{Aabb, Vec3};
+        let b = self.b;
+        let thickness = if b.table.bool(state, b.props.powered) {
+            1.0 / 16.0
+        } else {
+            2.0 / 16.0
+        };
+        let attached = self.face_attached_connected(state).opposite().normal();
+        let thick = attached.iter().position(|&n| n != 0).unwrap_or(1);
+        // The 6 pixel side lies across the button's facing.
+        let wide = if b.facing(state).normal()[2] != 0 {
+            0
+        } else {
+            2
+        };
+        let tall = 3 - thick - wide;
+        let (mut lo, mut hi) = ([0.0; 3], [1.0; 3]);
+        if attached[thick] > 0 {
+            lo[thick] = 1.0 - thickness;
+        } else {
+            hi[thick] = thickness;
+        }
+        (lo[wide], hi[wide]) = (5.0 / 16.0, 11.0 / 16.0);
+        (lo[tall], hi[tall]) = (6.0 / 16.0, 10.0 / 16.0);
+        let origin = [f64::from(pos.x), f64::from(pos.y), f64::from(pos.z)];
+        Aabb::new(
+            Vec3::new(origin[0] + lo[0], origin[1] + lo[1], origin[2] + lo[2]),
+            Vec3::new(origin[0] + hi[0], origin[1] + hi[1], origin[2] + hi[2]),
+        )
     }
     /// `LeverBlock.pull`.
     pub(crate) fn lever_pull(&mut self, pos: BlockPos, state: BlockStateId) {

From b752a821b1f501b78cdf200362ecd9975e277ad7 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:53:21 +0100
Subject: [PATCH 040/475] Wear armor when cactus, fire, lava, campfires and
 other environment damage hurt the player

---
 .../examples/probe/scene_motion_probe.rs      |  2 +
 crates/horizon-client/src/game.rs             | 52 ++++++++++++++++---
 crates/horizon-client/src/game/creatures.rs   |  1 -
 crates/horizon-client/src/game/explosion.rs   |  3 --
 .../horizon-client/src/game/falling_damage.rs | 10 +---
 crates/horizon-client/src/game/fireworks.rs   | 10 +---
 crates/horizon-client/src/game/lan_actions.rs |  1 +
 crates/horizon-client/src/health.rs           | 16 +++++-
 crates/horizon-client/src/items.rs            |  6 +++
 9 files changed, 73 insertions(+), 28 deletions(-)

diff --git a/crates/horizon-client/examples/probe/scene_motion_probe.rs b/crates/horizon-client/examples/probe/scene_motion_probe.rs
index 21977eeab..6153e098b 100644
--- a/crates/horizon-client/examples/probe/scene_motion_probe.rs
+++ b/crates/horizon-client/examples/probe/scene_motion_probe.rs
@@ -164,6 +164,8 @@ fn snapshot(out: &mut impl Write, player: &PlayerMotion) -> Result<()> {
         .iter()
         .filter_map(|e| match e {
             MotionEvent::Fall(e) => Some(e.trace()),
+            // The oracle's player wears no armor; the game applies this one.
+            MotionEvent::Health(horizon_client::health::HealthEvent::ArmorHurt { .. }) => None,
             MotionEvent::Health(e) => Some(e.trace()),
             MotionEvent::Snowflake { position, velocity } => Some(format!(
                 "snowflake {:016x},{:016x},{:016x} {:016x},{:016x},{:016x}",
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index b397882cd..d3b378a76 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4343,6 +4343,7 @@ impl Game<'_> {
         self.tick_avatar(before, riding);
         self.end_spin_attack(spin_hit);
         self.record_combat(&events);
+        self.wear_armor(&events);
         for event in events {
             match event {
                 MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, feet),
@@ -8317,15 +8318,54 @@ impl Game<'_> {
         }
         self.apply_enchantment_attributes();
     }
-    /// Inventory.hurtArmor: each piece loses max(1, damage / 4) durability.
-    fn hurt_armor(&mut self, damage: f32) {
+    /// The armor hits among a tick's motion events (`Player.hurtArmor` from
+    /// `getDamageAfterArmorAbsorb`), whatever the damage: a mob, an explosion,
+    /// a cactus, lava, a campfire.
+    fn wear_armor(&mut self, events: &[MotionEvent]) {
+        for event in events {
+            if let MotionEvent::Health(horizon_client::health::HealthEvent::ArmorHurt {
+                source,
+                amount,
+            }) = event
+            {
+                self.hurt_armor(*source, *amount);
+            }
+        }
+    }
+    /// `Player.hurtArmor` -> `LivingEntity.doHurtEquipment`: each worn piece that
+    /// wears when its wearer is hurt loses max(1, damage / 4) durability, except
+    /// to a fire source when the piece resists fire (`ItemStack.canBeHurtBy`).
+    fn hurt_armor(&mut self, source: horizon_world::damage_source::DamageTypeId, damage: f32) {
+        if damage <= 0.0 {
+            return;
+        }
         let amount = ((damage / 4.0) as u32).max(1);
+        let name = self
+            .motion
+            .health
+            .damage
+            .definition(source)
+            .map(|d| d.name.clone())
+            .unwrap_or_default();
+        let fire = self
+            .motion
+            .health
+            .damage
+            .in_tag(source, "minecraft:is_fire");
         let mut broke = false;
         let losses: Vec<u32> = (0..4)
-            .map(|i| {
-                self.armor[i]
-                    .clone()
-                    .map_or(amount, |s| self.durability_loss(&s, amount))
+            .map(|i| match self.armor[i].clone() {
+                Some(s)
+                    if self
+                        .res
+                        .items()
+                        .get(&s.item)
+                        .is_some_and(|info| info.equip_damage_on_hurt)
+                        && !(fire && self.res.items().resists_fire(&s, &name)) =>
+                {
+                    self.durability_loss(&s, amount)
+                }
+                _ => 0,
             })
             .collect();
         for (slot, amount) in self.armor.iter_mut().zip(losses) {
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 3a8562ee1..150541a49 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1535,7 +1535,6 @@ impl Game<'_> {
                     r.knockback = Some([p.velocity.x, p.velocity.y, p.velocity.z]);
                 }
             }
-            self.hurt_armor(amount);
             self.thorns(from);
         }
         if raised {
diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs
index 6ecba3a54..03b65e795 100644
--- a/crates/horizon-client/src/game/explosion.rs
+++ b/crates/horizon-client/src/game/explosion.rs
@@ -314,9 +314,6 @@ impl Game<'_> {
                 );
             }
         }
-        if outcome.hurt && !creative {
-            self.hurt_armor(amount);
-        }
         if raised {
             self.after_block(outcome, amount, None, false);
         }
diff --git a/crates/horizon-client/src/game/falling_damage.rs b/crates/horizon-client/src/game/falling_damage.rs
index 8eec28d1d..759b4f646 100644
--- a/crates/horizon-client/src/game/falling_damage.rs
+++ b/crates/horizon-client/src/game/falling_damage.rs
@@ -108,16 +108,10 @@ impl Game<'_> {
         } else {
             amount
         };
-        let hurt = if let Some(p) = self.player.as_mut()
+        if let Some(p) = self.player.as_mut()
             && let Some(id) = self.motion.health.damage.id(kind)
         {
-            p.hurt(&self.motion.health, self.world.health_rules, id, amount)
-                .unwrap_or(false)
-        } else {
-            false
-        };
-        if hurt {
-            self.hurt_armor(amount);
+            let _ = p.hurt(&self.motion.health, self.world.health_rules, id, amount);
         }
     }
 }
diff --git a/crates/horizon-client/src/game/fireworks.rs b/crates/horizon-client/src/game/fireworks.rs
index e6b4eb136..825519676 100644
--- a/crates/horizon-client/src/game/fireworks.rs
+++ b/crates/horizon-client/src/game/fireworks.rs
@@ -352,17 +352,11 @@ impl Game<'_> {
         if self.creative || self.spectator() {
             return;
         }
-        let hurt = if let Some(p) = self.player.as_mut()
+        if let Some(p) = self.player.as_mut()
             && !p.health.dead_or_dying()
             && let Some(id) = self.motion.health.damage.id("minecraft:fireworks")
         {
-            p.hurt(&self.motion.health, self.world.health_rules, id, amount)
-                .unwrap_or(false)
-        } else {
-            false
-        };
-        if hurt {
-            self.hurt_armor(amount);
+            let _ = p.hurt(&self.motion.health, self.world.health_rules, id, amount);
         }
     }
     /// `FireworkEntityRenderer.submit`: the item (GROUND) facing the camera,
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index bbb0c37c0..f824d3965 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -2233,6 +2233,7 @@ impl Game<'_> {
             let marked = std::mem::take(&mut player.health.sync_velocity);
             let velocity = marked.then_some(player.velocity);
             game.record_combat(&events);
+            game.wear_armor(&events);
             (events, velocity)
         });
         let Some((events, marked)) = events else {
diff --git a/crates/horizon-client/src/health.rs b/crates/horizon-client/src/health.rs
index 25c719bfb..f45fec1fc 100644
--- a/crates/horizon-client/src/health.rs
+++ b/crates/horizon-client/src/health.rs
@@ -111,6 +111,12 @@ pub enum HealthEvent {
         amount: f32,
     },
     Phase(&'static str),
+    /// `Player.hurtArmor`: a hit that doesn't bypass armor wears the worn
+    /// pieces (`LivingEntity.getDamageAfterArmorAbsorb`); the game applies it.
+    ArmorHurt {
+        source: DamageTypeId,
+        amount: f32,
+    },
     /// `ServerLevel.broadcastDamageEvent`: the client's
     /// `LivingEntity.handleDamageEvent` plays the source's hurt sound.
     DamageBroadcast {
@@ -139,6 +145,7 @@ impl HealthEvent {
                 format!("record-damage {:08x}", amount.to_bits())
             }
             Self::Phase(name) => name.into(),
+            Self::ArmorHurt { amount, .. } => format!("hurt-armor {:08x}", amount.to_bits()),
             Self::DamageBroadcast { .. } => "broadcast-damage".into(),
             Self::Criterion { .. } => "hurt-criterion".into(),
         }
@@ -517,9 +524,14 @@ impl ServerDamageEnvironment<Attributes> for Environment<'_> {
     fn bypasses(&mut self, kind: Bypass) -> io::Result<bool> {
         Ok(self.source.bypasses(kind))
     }
-    fn hurt_armor(&mut self, _: &mut Attributes, _: f32) -> io::Result<()> {
+    fn hurt_armor(&mut self, _: &mut Attributes, damage: f32) -> io::Result<()> {
+        // The worn armor lives in the game, which wears it from this event.
+        self.event(HealthEvent::ArmorHurt {
+            source: self.source.type_id(),
+            amount: damage,
+        });
         Ok(())
-    } // empty equipment
+    }
     fn has_resistance(&mut self) -> io::Result<bool> {
         Ok(self.status.resistance.is_some())
     }
diff --git a/crates/horizon-client/src/items.rs b/crates/horizon-client/src/items.rs
index 8ac450bcb..080c88394 100644
--- a/crates/horizon-client/src/items.rs
+++ b/crates/horizon-client/src/items.rs
@@ -111,6 +111,9 @@ pub struct ItemInfo {
     pub swappable: bool,
     /// `equippable.dispensable` (dispensers may put it on an entity).
     pub equip_dispensable: bool,
+    /// `equippable.damage_on_hurt`: the item wears when its wearer is hurt
+    /// (false for the elytra).
+    pub equip_damage_on_hurt: bool,
     /// `equippable.allowed_entities` resolved to entity type ids; None allows all.
     pub equip_allowed: Option<HashSet<String>>,
     pub equip_sound: Option<String>,
@@ -584,6 +587,9 @@ impl Items {
                     equip_dispensable: c["minecraft:equippable"]["dispensable"]
                         .as_bool()
                         .unwrap_or(true),
+                    equip_damage_on_hurt: c["minecraft:equippable"]["damage_on_hurt"]
+                        .as_bool()
+                        .unwrap_or(true),
                     equip_allowed: match &c["minecraft:equippable"]["allowed_entities"] {
                         Value::String(spec) => Some(entity_spec(&entity_tags, spec)),
                         Value::Array(list) => Some(

From d622030988cc744f6e9ec42ba3e4a42ff89ea70b Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:53:34 +0100
Subject: [PATCH 041/475] Zombies call reinforcements when hurt on Hard

A hurt zombie with a target now tries up to 50 spots 7 to 40 blocks away
for a copy of itself, as Zombie.hurtServer does. The copy takes the
target, and both zombies get the charge that lowers their chance.

New zombies also roll their reinforcement chance and a leader's bonus
(Zombie.handleAttributes); before this the chance stayed at 0.
---
 crates/horizon-client/src/game.rs             |   4 +
 crates/horizon-client/src/game/creatures.rs   |   4 +
 .../src/game/zombie_reinforcements.rs         | 134 ++++++++++++++++++
 crates/horizon-client/src/mobs.rs             |   6 +
 crates/horizon-client/src/mobs/ai.rs          |   5 +
 crates/horizon-client/src/mobs/finalize.rs    | 117 ++++++++-------
 crates/horizon-client/src/mobs/spawning.rs    |  12 ++
 crates/horizon-client/src/mobs/undead.rs      |  12 +-
 8 files changed, 238 insertions(+), 56 deletions(-)
 create mode 100644 crates/horizon-client/src/game/zombie_reinforcements.rs

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index b397882cd..940a0c4aa 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -181,6 +181,7 @@ mod win;
 mod wind;
 mod wither;
 mod world_loading;
+mod zombie_reinforcements;
 mod zombie_villagers;
 use horizon_client::{
     Result,
@@ -7648,6 +7649,9 @@ impl Game<'_> {
                 if let horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) = event {
                     self.audio
                         .play(&format!("minecraft:{s}"), Some(at), volume, pitch);
+                } else {
+                    // Left for the end of the tick.
+                    self.mobs[index].outbox.push(event);
                 }
             }
             self.weapon_hit(index);
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 119fe2a1e..cbc4691cc 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -941,6 +941,9 @@ impl Game<'_> {
                                         volume,
                                         pitch,
                                     );
+                                } else {
+                                    // Left for the end of the tick.
+                                    t.outbox.push(event);
                                 }
                             }
                         }
@@ -1192,6 +1195,7 @@ impl Game<'_> {
                     self.creaking_tear_down(center, spread)
                 }
                 MobEvent::CureZombieVillager { mob } => self.cure_zombie_villager(mob),
+                MobEvent::Reinforcements { mob, target } => self.call_reinforcements(mob, target),
                 MobEvent::VillagerMeet { mob, other } => self.villager_meet(mob, other),
                 MobEvent::VillagerBirth {
                     parent,
diff --git a/crates/horizon-client/src/game/zombie_reinforcements.rs b/crates/horizon-client/src/game/zombie_reinforcements.rs
new file mode 100644
index 000000000..4c6100f43
--- /dev/null
+++ b/crates/horizon-client/src/game/zombie_reinforcements.rs
@@ -0,0 +1,134 @@
+//! `Zombie.hurtServer`'s reinforcements: a hurt zombie on Hard may call
+//! another of its kind from 7 to 40 blocks away to fight its target.
+use super::Game;
+use horizon_client::mobs::{
+    MobType, Species, Who,
+    finalize::{self, Attr, Op},
+    spawn_rules::{self, Reason},
+    spawn_selection::{self, NaturalLevel},
+    spawner::SpawnerLevel,
+};
+use horizon_core::random::{LegacyRandom, RandomSource};
+use horizon_world::food::Difficulty;
+
+/// `Zombie.REINFORCEMENT_ATTEMPTS`.
+const ATTEMPTS: usize = 50;
+/// `Zombie.REINFORCEMENT_RANGE_MIN` and `REINFORCEMENT_RANGE_MAX`.
+const RANGE_MIN: i32 = 7;
+const RANGE_MAX: i32 = 40;
+
+/// One axis of the offset: `Mth.nextInt(random, 7, 40) * Mth.nextInt(random, -1, 1)`.
+fn offset(random: &mut LegacyRandom) -> i32 {
+    let distance = random
+        .next_int_between_inclusive(RANGE_MIN, RANGE_MAX)
+        .unwrap_or(RANGE_MIN);
+    distance * random.next_int_between_inclusive(-1, 1).unwrap_or(0)
+}
+
+impl Game<'_> {
+    /// `Zombie.hurtServer` after the hit: on Hard, with the zombie's chance
+    /// and monsters spawning, a copy of it appears out of sight and takes
+    /// `target`; both then call less often.
+    pub(super) fn call_reinforcements(&mut self, caller: u32, target: Who) {
+        let Some(index) = self.mobs.iter().position(|m| m.id == caller) else {
+            return;
+        };
+        if self.world.health_rules.difficulty != Difficulty::Hard {
+            return;
+        }
+        let zombie = &mut self.mobs[index];
+        if f64::from(zombie.random.next_float()) >= zombie.attrs.spawn_reinforcements {
+            return;
+        }
+        // ServerLevel.isSpawningMonsters.
+        if !self.ui.rules.bool("spawn_mobs") || !self.ui.rules.bool("spawn_monsters") {
+            return;
+        }
+        let kind = zombie.kind.clone();
+        let from = [
+            zombie.position.x.floor() as i32,
+            zombie.position.y.floor() as i32,
+            zombie.position.z.floor() as i32,
+        ];
+        let mut own = std::mem::replace(&mut zombie.random, LegacyRandom::new(0));
+        let mut rules = std::mem::replace(&mut self.world.random, LegacyRandom::new(0));
+        let spot = self.reinforcement_spot(&kind, from, &mut own, &mut rules);
+        self.mobs[index].random = own;
+        self.world.random = rules;
+        let Some(spot) = spot else {
+            return;
+        };
+        let Some(id) = self.spawn_mob(&kind.id, spot.map(f64::from), false) else {
+            return;
+        };
+        if let Some(reinforcement) = self.mobs.iter_mut().find(|m| m.id == id) {
+            reinforcement.ai.target = Some(target);
+            // ZOMBIE_REINFORCEMENT_CALLEE_CHARGE.
+            finalize::add_modifier(
+                reinforcement,
+                Attr::SpawnReinforcements,
+                "minecraft:reinforcement_callee_charge",
+                -f64::from(0.05f32),
+                Op::AddValue,
+            );
+        }
+        // The caller's charge grows by 0.05 each time it calls.
+        let caller = &mut self.mobs[index];
+        let charged = finalize::modifier_amount(
+            caller,
+            Attr::SpawnReinforcements,
+            "minecraft:reinforcement_caller_charge",
+        )
+        .unwrap_or(0.0);
+        finalize::add_modifier(
+            caller,
+            Attr::SpawnReinforcements,
+            "minecraft:reinforcement_caller_charge",
+            charged - 0.05,
+            Op::AddValue,
+        );
+    }
+    /// The block `Zombie.hurtServer` puts the reinforcement at: the first of
+    /// 50 random offsets with a valid spawn surface, no alive player within
+    /// 7 blocks, and room for the zombie standing on the block's corner.
+    fn reinforcement_spot(
+        &self,
+        kind: &MobType,
+        from: [i32; 3],
+        own: &mut LegacyRandom,
+        rules: &mut LegacyRandom,
+    ) -> Option<[i32; 3]> {
+        let level = self.natural_level();
+        let (width, height) = (kind.width as f32, kind.height as f32);
+        for _ in 0..ATTEMPTS {
+            let [x, y, z] = from.map(|v| v + offset(own));
+            if !spawn_rules::is_spawn_position_ok(kind.species, &level, x, y, z)
+                || !spawn_rules::check_spawn_rules(
+                    kind.species,
+                    &level,
+                    Reason::Reinforcement,
+                    rules,
+                    x,
+                    y,
+                    z,
+                )
+            {
+                continue;
+            }
+            // setPos(x, y, z): the box is centred on the block's corner.
+            let bounds =
+                spawn_selection::spawn_box(f64::from(x), f64::from(y), f64::from(z), width, height);
+            // Drowned.canSpawnInLiquids.
+            let wet_ok = kind.species == Species::Drowned
+                || !spawn_selection::contains_any_liquid(&level, bounds);
+            if !level.alive_player_near(f64::from(x), f64::from(y), f64::from(z), 7.0)
+                && level.unobstructed(bounds)
+                && level.no_collision(bounds)
+                && wet_ok
+            {
+                return Some([x, y, z]);
+            }
+        }
+        None
+    }
+}
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..c92378eeb 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1151,6 +1151,12 @@ pub enum MobEvent {
     DigParticles {
         at: [f64; 3],
     },
+    /// `Zombie.hurtServer`: a zombie hurt with a target in sight (its own,
+    /// else the attacker) may call a reinforcement against it on Hard.
+    Reinforcements {
+        mob: u32,
+        target: Who,
+    },
     /// `Warden.applyDarknessAround`: darkness for survival players nearby.
     Darkness {
         at: [f64; 3],
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index c9bc15fda..c30146515 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -1306,6 +1306,11 @@ pub fn after_hurt(m: &mut Mob, source: &Damage) {
         Species::Warden => super::warden::hurt(m, source),
         Species::Wolf => super::tame::after_hurt(m, source),
         Species::Nautilus | Species::ZombieNautilus => super::nautilus::after_hurt(m, source),
+        Species::Zombie
+        | Species::Husk
+        | Species::Drowned
+        | Species::ZombieVillager
+        | Species::ZombifiedPiglin => super::undead::after_hurt(m, source),
         // NeutralMob: an iron golem hit by the player stays angry a while.
         // PiglinAi.wasHurtBy: drop what is being admired, no admiring for
         // a while after a player's hit, and anger.
diff --git a/crates/horizon-client/src/mobs/finalize.rs b/crates/horizon-client/src/mobs/finalize.rs
index 4eeed885b..663b39f0a 100644
--- a/crates/horizon-client/src/mobs/finalize.rs
+++ b/crates/horizon-client/src/mobs/finalize.rs
@@ -590,6 +590,14 @@ pub fn has_modifier(m: &Mob, a: Attr, id: &str) -> bool {
         .as_ref()
         .is_some_and(|s| s.modifiers.iter().any(|x| x.attr == a && x.id == id))
 }
+/// The amount of a permanent modifier, if the mob has it.
+pub fn modifier_amount(m: &Mob, a: Attr, id: &str) -> Option<f64> {
+    m.extra
+        .attributes
+        .as_ref()
+        .and_then(|s| s.modifiers.iter().find(|x| x.attr == a && x.id == id))
+        .map(|x| x.amount)
+}
 /// `addOrReplacePermanentModifier`.
 pub fn add_modifier(m: &mut Mob, a: Attr, id: &'static str, amount: f64, op: Op) {
     let s = m.extra.attributes.get_or_insert_with(Box::default);
@@ -605,6 +613,59 @@ pub fn add_modifier(m: &mut Mob, a: Attr, id: &'static str, amount: f64, op: Op)
     }
     refresh(m, a);
 }
+/// `Zombie.handleAttributes`, from the zombie's own random.
+pub fn zombie_attributes(m: &mut Mob, special: f32, reason: Reason) {
+    let r = &mut m.random;
+    let reinforcements = if m.kind.species == Species::ZombifiedPiglin {
+        0.0
+    } else {
+        r.next_double() * f64::from(0.1f32)
+    };
+    let knockback = r.next_double() * f64::from(0.05f32);
+    let follow = r.next_double() * 1.5 * f64::from(special);
+    let leader = r.next_float() < special * 0.05;
+    let leader_rolls = leader.then(|| (r.next_double() * 0.25 + 0.5, r.next_double() * 3.0 + 1.0));
+    set_base(m, Attr::SpawnReinforcements, reinforcements);
+    add_modifier(
+        m,
+        Attr::KnockbackResistance,
+        "minecraft:random_spawn_bonus",
+        knockback,
+        Op::AddValue,
+    );
+    if follow > 1.0 {
+        add_modifier(
+            m,
+            Attr::FollowRange,
+            "minecraft:zombie_random_spawn_bonus",
+            follow,
+            Op::AddMultipliedTotal,
+        );
+    }
+    if let Some((reinforce, health)) = leader_rolls {
+        add_modifier(
+            m,
+            Attr::SpawnReinforcements,
+            "minecraft:leader_zombie_bonus",
+            reinforce,
+            Op::AddValue,
+        );
+        add_modifier(
+            m,
+            Attr::MaxHealth,
+            "minecraft:leader_zombie_bonus",
+            health,
+            Op::AddMultipliedTotal,
+        );
+        if !matches!(
+            reason,
+            Reason::Conversion | Reason::Load | Reason::DimensionTravel
+        ) {
+            m.health = max_health(m);
+        }
+        m.extra.can_break_doors = true;
+    }
+}
 pub fn max_health(m: &Mob) -> f32 {
     value(m, Attr::MaxHealth) as f32
 }
@@ -1151,63 +1212,9 @@ impl<L: FinalizeLevel + ?Sized, R: RandomSource> Ctx<'_, L, R> {
             }
         }
         self.halloween(m);
-        self.zombie_attributes(m, special, reason);
+        zombie_attributes(m, special, reason);
         g
     }
-    /// `Zombie.handleAttributes`, from the zombie's own random.
-    fn zombie_attributes(&mut self, m: &mut Mob, special: f32, reason: Reason) {
-        let r = &mut m.random;
-        let reinforcements = if m.kind.species == Species::ZombifiedPiglin {
-            0.0
-        } else {
-            r.next_double() * f64::from(0.1f32)
-        };
-        let knockback = r.next_double() * f64::from(0.05f32);
-        let follow = r.next_double() * 1.5 * f64::from(special);
-        let leader = r.next_float() < special * 0.05;
-        let leader_rolls =
-            leader.then(|| (r.next_double() * 0.25 + 0.5, r.next_double() * 3.0 + 1.0));
-        set_base(m, Attr::SpawnReinforcements, reinforcements);
-        add_modifier(
-            m,
-            Attr::KnockbackResistance,
-            "minecraft:random_spawn_bonus",
-            knockback,
-            Op::AddValue,
-        );
-        if follow > 1.0 {
-            add_modifier(
-                m,
-                Attr::FollowRange,
-                "minecraft:zombie_random_spawn_bonus",
-                follow,
-                Op::AddMultipliedTotal,
-            );
-        }
-        if let Some((reinforce, health)) = leader_rolls {
-            add_modifier(
-                m,
-                Attr::SpawnReinforcements,
-                "minecraft:leader_zombie_bonus",
-                reinforce,
-                Op::AddValue,
-            );
-            add_modifier(
-                m,
-                Attr::MaxHealth,
-                "minecraft:leader_zombie_bonus",
-                health,
-                Op::AddMultipliedTotal,
-            );
-            if !matches!(
-                reason,
-                Reason::Conversion | Reason::Load | Reason::DimensionTravel
-            ) {
-                m.health = max_health(m);
-            }
-            m.extra.can_break_doors = true;
-        }
-    }
     fn husk(&mut self, m: &mut Mob, g: Option<Group>, reason: Reason) -> Option<Group> {
         let mut g = self.zombie(m, g, reason);
         if reason != Reason::Conversion {
diff --git a/crates/horizon-client/src/mobs/spawning.rs b/crates/horizon-client/src/mobs/spawning.rs
index 93e3fe119..b08b2b023 100644
--- a/crates/horizon-client/src/mobs/spawning.rs
+++ b/crates/horizon-client/src/mobs/spawning.rs
@@ -264,6 +264,18 @@ pub fn finalize(m: &mut Mob, biome: &BiomeFacts, difficulty: &LocalDifficulty) {
         S::Slime | S::MagmaCube => super::cube::finalize(m),
         _ => {}
     }
+    // Zombie.finalizeSpawn ends with handleAttributes: the reinforcement
+    // chance (and a leader's bonus) that `Zombie.hurtServer` reads.
+    if matches!(
+        m.species(),
+        S::Zombie | S::Husk | S::Drowned | S::ZombieVillager | S::ZombifiedPiglin
+    ) {
+        super::finalize::zombie_attributes(
+            m,
+            difficulty.special(),
+            super::finalize::Reason::Natural,
+        );
+    }
 }
 /// VillagerType.byBiome
 pub fn villager_type(b: &BiomeFacts) -> u8 {
diff --git a/crates/horizon-client/src/mobs/undead.rs b/crates/horizon-client/src/mobs/undead.rs
index e77a37641..56f1dc29e 100644
--- a/crates/horizon-client/src/mobs/undead.rs
+++ b/crates/horizon-client/src/mobs/undead.rs
@@ -1,7 +1,7 @@
 //! Zombies (zombie, husk, drowned, zombie villager) and skeletons (skeleton,
 //! stray, bogged, wither skeleton): goals, bow attacks, water conversion.
 use super::{
-    Mob, MobEvent, Species, Who,
+    Damage, Mob, MobEvent, Species, Who,
     goals::{
         Avoid, AvoidEntity, Cx, FleeSun, Goal, HurtByTarget, LOOK, LookAtPlayer, MOVE, MeleeAttack,
         NearestTarget, RandomLookAround, RestrictSun, Stroll, goal_clone,
@@ -10,6 +10,16 @@ use super::{
 use crate::projectiles::{Projectile, ProjectileKind};
 use horizon_core::{geometry::Vec3, random::RandomSource};
 
+/// `Zombie.hurtServer`, once the hit landed: a zombie with a target (its own,
+/// else a living attacker) asks the game to try calling a reinforcement; the
+/// difficulty, chance and spawn tests are the game's (`call_reinforcements`).
+pub fn after_hurt(m: &mut Mob, source: &Damage) {
+    if let Some(target) = m.ai.target.or(source.attacker) {
+        m.outbox
+            .push(MobEvent::Reinforcements { mob: m.id, target });
+    }
+}
+
 pub fn register(m: &mut Mob) {
     use Species as S;
     match m.species() {

From d057c891642f026589241fabcc82bb83a517be6d Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:59:33 +0100
Subject: [PATCH 042/475] Mobs killed by a charged creeper drop their head

A creeper's explosion hurt mobs with no attacker, and the creeper is
already gone from the mob list when its blast is applied, so the
charged_creeper loot never matched. The creeper now announces itself
(ExplosionSource) before it explodes, its victims name it as the damage
source, and it stays known until they have been looted. One head drops
per charged explosion.
---
 crates/horizon-client/src/game/combat.rs    |  4 ++
 crates/horizon-client/src/game/creatures.rs | 48 +++++++++++++++------
 crates/horizon-client/src/game/explosion.rs |  4 +-
 crates/horizon-client/src/mobs.rs           |  8 ++++
 crates/horizon-client/src/mobs/hostile.rs   |  4 ++
 5 files changed, 53 insertions(+), 15 deletions(-)

diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs
index 227aa0332..09e156aec 100644
--- a/crates/horizon-client/src/game/combat.rs
+++ b/crates/horizon-client/src/game/combat.rs
@@ -31,6 +31,10 @@ pub(super) struct CombatTracker {
     /// The mob exploding now (`ServerExplosion.source`): its team's friendly
     /// fire decides whom the blast may hurt.
     pub(super) explosion_source: Option<u32>,
+    /// Charged creepers whose blast just went off and that have not dropped
+    /// a head yet (`Creeper.droppedSkulls`): they are gone from the mob list,
+    /// but the mobs they killed still ask for their loot.
+    pub(super) charged_exploders: Vec<u32>,
     /// The player's fall distance before this tick's movement (as of the
     /// end of the last one).
     fall_before: f64,
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 119fe2a1e..4b839bd07 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -496,6 +496,8 @@ impl Game<'_> {
             self.died.insert(m.id);
             self.mob_died(&m);
         }
+        // Their victims have been looted: no charged creeper is waiting any more.
+        self.combat.charged_exploders.clear();
         let uuid = self.level.player_uuid;
         let mut snapshot: Vec<Seen> = self.mobs.iter().map(|m| seen(m, uuid)).collect();
         let mut events = Vec::new();
@@ -778,7 +780,17 @@ impl Game<'_> {
                     .mobs
                     .iter()
                     .find(|o| o.id == id)
-                    .map(|o| drops::loot_entity(o, None)),
+                    .map(|o| drops::loot_entity(o, None))
+                    // A charged creeper's blast kills after the creeper left the list.
+                    .or_else(|| {
+                        self.combat
+                            .charged_exploders
+                            .contains(&id)
+                            .then(|| LootEntity {
+                                powered: true,
+                                ..LootEntity::new("minecraft:creeper")
+                            })
+                    }),
                 None => None,
             };
             let direct = match d.kind {
@@ -814,12 +826,12 @@ impl Game<'_> {
             world_seed: self.level.seed,
         };
         let (items, skulls) = drops::die(m, &death, &mut self.rand_sequences);
-        if skulls
-            && let Some(Who::Mob(id)) = m.last_damage.and_then(|(d, _)| d.attacker)
-            && let Some(creeper) = self.mobs.iter_mut().find(|o| o.id == id)
-        {
+        if skulls && let Some(Who::Mob(id)) = m.last_damage.and_then(|(d, _)| d.attacker) {
             // Creeper.droppedSkulls: one head per charged explosion.
-            creeper.extra.charged = false;
+            self.combat.charged_exploders.retain(|c| *c != id);
+            if let Some(creeper) = self.mobs.iter_mut().find(|o| o.id == id) {
+                creeper.extra.charged = false;
+            }
         }
         let raider = horizon_client::mobs::raider::is_raider(m.species());
         for d in items {
@@ -901,16 +913,24 @@ impl Game<'_> {
                     owner,
                 } => self.add_fangs(at, yaw, delay, owner),
                 MobEvent::Shoot(..) => {}
+                MobEvent::ExplosionSource { mob, charged } => {
+                    self.combat.explosion_source = Some(mob);
+                    if charged {
+                        self.combat.charged_exploders.push(mob);
+                    }
+                }
                 MobEvent::Explode(at, radius) => {
                     // The exploding mob causes the damage (Creeper.explodeCreeper).
-                    let source_mob = self
-                        .mobs
-                        .iter()
-                        .filter(|m| {
-                            (m.position.x - at[0]).powi(2) + (m.position.z - at[2]).powi(2) < 1.0
-                        })
-                        .map(|m| m.id)
-                        .next();
+                    let source_mob = self.combat.explosion_source.or_else(|| {
+                        self.mobs
+                            .iter()
+                            .filter(|m| {
+                                (m.position.x - at[0]).powi(2) + (m.position.z - at[2]).powi(2)
+                                    < 1.0
+                            })
+                            .map(|m| m.id)
+                            .next()
+                    });
                     if let Some(id) = source_mob {
                         self.note_attacker("minecraft:explosion", id);
                     }
diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs
index 6ecba3a54..1da018238 100644
--- a/crates/horizon-client/src/game/explosion.rs
+++ b/crates/horizon-client/src/game/explosion.rs
@@ -391,9 +391,11 @@ impl Game<'_> {
                 [feet[0] - w, feet[1], feet[2] - w],
                 [feet[0] + w, feet[1] + h, feet[2] + w],
             );
+            // The exploding mob is the damage source's entity, so victims
+            // it kills drop its charged-creeper loot (`Creeper.killedEntity`).
             let source = horizon_client::mobs::Damage {
                 kind: horizon_client::mobs::DamageKind::Explosion,
-                attacker: None,
+                attacker: exploding.map(horizon_client::mobs::Who::Mob),
                 from: Some(center),
             };
             if hurtable && !m.damage(damage(dist, exposure), source) {
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..7e423512b 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -965,6 +965,14 @@ pub enum MobEvent {
         owner: u32,
     },
     Shoot([f64; 3], [f64; 3]),
+    /// The mob the `Explode` right after this comes from
+    /// (`ServerExplosion.source`), and whether it is a charged creeper: the
+    /// exploding creeper is already out of the mob list when the game applies
+    /// the blast, so its victims' loot cannot look it up.
+    ExplosionSource {
+        mob: u32,
+        charged: bool,
+    },
     Explode([f64; 3], f32),
     /// Melee or ranged damage to another mob.
     AttackMob {
diff --git a/crates/horizon-client/src/mobs/hostile.rs b/crates/horizon-client/src/mobs/hostile.rs
index 0d3feaa6c..f1c990c48 100644
--- a/crates/horizon-client/src/mobs/hostile.rs
+++ b/crates/horizon-client/src/mobs/hostile.rs
@@ -177,6 +177,10 @@ pub fn creeper_tick(m: &mut Mob, events: &mut Vec<MobEvent>) {
     if m.swell >= 30 {
         m.swell = 30;
         let radius = if m.extra.charged { 6.0 } else { 3.0 };
+        events.push(MobEvent::ExplosionSource {
+            mob: m.id,
+            charged: m.extra.charged,
+        });
         events.push(MobEvent::Explode(
             [m.position.x, m.position.y, m.position.z],
             radius,

From d0509e2beeb38dfcb3b927e973e3d3ef6ccd5967 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:02:39 +0100
Subject: [PATCH 043/475] Witches stand still while drinking and skip potions a
 target already has

A drinking witch now gets the -0.25 drinking speed modifier, so it does
not walk for the 32 ticks. When it throws a potion, slowness, poison and
weakness are only picked if the target (player or mob) does not already
have that effect, as Witch.performRangedAttack does.
---
 .../examples/probe/mob_ai_probe.rs            |  1 +
 crates/horizon-client/src/game/creatures.rs   |  1 +
 crates/horizon-client/src/game/lan_mobs.rs    |  1 +
 crates/horizon-client/src/mobs.rs             | 25 ++++++++++++++++++-
 crates/horizon-client/src/mobs/witch.rs       | 20 ++++++++++++---
 5 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs
index 49f56c250..7c501ee77 100644
--- a/crates/horizon-client/examples/probe/mob_ai_probe.rs
+++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs
@@ -1050,6 +1050,7 @@ pub fn main() -> horizon_client::Result<()> {
                 velocity: Vec3::ZERO,
                 yaw: 0.0,
                 hero: false,
+                effects: Vec::new(),
                 uuid: PLAYER_UUID,
                 allies: Default::default(),
                 remote: false,
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 119fe2a1e..9eb37e9d8 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -193,6 +193,7 @@ impl Game<'_> {
             velocity: p.velocity,
             yaw: self.yaw,
             hero: self.potions.effects.get("hero_of_the_village").is_some(),
+            effects: self.potions.effects.list.iter().map(|e| e.id).collect(),
             uuid: self.level.player_uuid.unwrap_or_default(),
             allies: std::sync::Arc::new(self.player_allies()),
             remote: false,
diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs
index 4f53cec60..6527f1015 100644
--- a/crates/horizon-client/src/game/lan_mobs.rs
+++ b/crates/horizon-client/src/game/lan_mobs.rs
@@ -370,6 +370,7 @@ mod tests {
             velocity: Vec3::ZERO,
             yaw: 0.0,
             hero: false,
+            effects: Vec::new(),
             uuid: [0; 4],
             allies: Default::default(),
             remote: false,
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..3ad48df3f 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1243,6 +1243,14 @@ pub struct Seen {
     /// `MAX_HEALTH`, `JUMP_STRENGTH` and `MOVEMENT_SPEED` base values (a
     /// horse's breeding stock).
     pub stats: [f64; 3],
+    /// The active effects, without namespace (`slowness`, `poison`...).
+    pub effects: Vec<&'static str>,
+}
+impl Seen {
+    /// `LivingEntity.hasEffect`, by id without namespace.
+    pub fn has_effect(&self, effect: &str) -> bool {
+        self.effects.contains(&effect)
+    }
 }
 impl Mob {
     pub fn burning_time(&self) -> f64 {
@@ -1315,6 +1323,12 @@ impl Mob {
                 m.extra.vector[0],
                 m.attrs.speed,
             ],
+            effects: m
+                .extra
+                .effects
+                .iter()
+                .map(|e| e.0.trim_start_matches("minecraft:"))
+                .collect(),
         }
     }
     /// `EntityType.getCategory`'s name.
@@ -1459,6 +1473,8 @@ pub struct PlayerView {
     pub yaw: f32,
     /// The Hero of the Village effect.
     pub hero: bool,
+    /// The active effects, without namespace (`slowness`, `poison`...).
+    pub effects: Vec<&'static str>,
     /// The player's UUID (villagers' gossip is keyed by it).
     pub uuid: [i32; 4],
     /// The mobs on the player's team (`isAlliedTo`): combat targeting
@@ -1468,6 +1484,12 @@ pub struct PlayerView {
     /// (`EntitySelector.pushableBy` on the client).
     pub remote: bool,
 }
+impl PlayerView {
+    /// `LivingEntity.hasEffect`, by id without namespace.
+    pub fn has_effect(&self, effect: &str) -> bool {
+        self.effects.contains(&effect)
+    }
+}
 #[derive(Clone)]
 pub struct MobWorld<'a> {
     pub world: &'a World,
@@ -1839,7 +1861,8 @@ impl Mob {
     /// Movement speed attribute bonus (baby zombies, sprinting modifiers).
     /// MOVEMENT_SPEED including effects (speed +20%/level, slowness -15%/level).
     pub fn movement_speed(&self) -> f64 {
-        let mut v = strider::movement_speed(self, self.attrs.speed) * self.speed_bonus();
+        let mut v = strider::movement_speed(self, witch::speed(self, self.attrs.speed))
+            * self.speed_bonus();
         for (e, _, amp) in &self.extra.effects {
             match *e {
                 "minecraft:speed" => v *= 1.0 + 0.2 * f64::from(amp + 1),
diff --git a/crates/horizon-client/src/mobs/witch.rs b/crates/horizon-client/src/mobs/witch.rs
index 0990ae01d..b0ec7866a 100644
--- a/crates/horizon-client/src/mobs/witch.rs
+++ b/crates/horizon-client/src/mobs/witch.rs
@@ -193,6 +193,11 @@ fn witch_attack(m: &mut Mob, who: Who, _power: f32, cx: &mut Cx) {
         }
         Who::Player => false,
     };
+    // `target.hasEffect`: a target that already has the effect gets the next one.
+    let has = |effect: &str| match who {
+        Who::Player => cx.w.player.as_ref().is_some_and(|p| p.has_effect(effect)),
+        Who::Mob(id) => cx.w.seen(id).is_some_and(|s| s.has_effect(effect)),
+    };
     let (effect, ticks, amplifier) = if heals {
         m.ai.target = None;
         if health <= 4.0 {
@@ -200,11 +205,11 @@ fn witch_attack(m: &mut Mob, who: Who, _power: f32, cx: &mut Cx) {
         } else {
             ("minecraft:regeneration", 900, 0)
         }
-    } else if dist >= 8.0 {
+    } else if dist >= 8.0 && !has("slowness") {
         ("minecraft:slowness", 1800, 0)
-    } else if health >= 8.0 {
+    } else if health >= 8.0 && !has("poison") {
         ("minecraft:poison", 900, 0)
-    } else if dist <= 3.0 && m.random.next_float() < 0.25 {
+    } else if dist <= 3.0 && !has("weakness") && m.random.next_float() < 0.25 {
         ("minecraft:weakness", 1800, 0)
     } else {
         ("minecraft:instant_damage", 1, 0)
@@ -236,6 +241,15 @@ fn witch_attack(m: &mut Mob, who: Who, _power: f32, cx: &mut Cx) {
         pitch,
     ));
 }
+/// The movement speed of a witch with `SPEED_MODIFIER_DRINKING` (-0.25,
+/// `ADD_VALUE`) while it drinks: it stands still for the 32 ticks.
+pub fn speed(m: &Mob, base: f64) -> f64 {
+    if m.species() == Species::Witch && m.extra.flag {
+        (base - 0.25).max(0.0)
+    } else {
+        base
+    }
+}
 /// Witch.aiStep before `super.aiStep()`: the healing cooldown, then drink
 /// water breathing, fire resistance, healing or swiftness.
 pub fn ai_step(m: &mut Mob, cx_events: &mut Vec<MobEvent>, target_far: bool) {

From 13e946a89c329411dab3ba3f1256cc34a384a14d Mon Sep 17 00:00:00 2001
From: Alexander Krylov <sashakryllov58@gmail.com>
Date: Mon, 26 Oct 2026 16:20:17 +0300
Subject: [PATCH 044/475] HUD: the hotbar draws its stacks without cloning them

`draw_item` and `draw_item_decorations` only read the game, so they take
`&self`; the hotbar loop can then hand them `self.inventory[slot].as_ref()`
and `self.offhand.as_ref()` instead of cloning the stack once per slot per
frame.

Co-Authored-By: Hermes Agent (Nous Research) <noreply@nousresearch.com>
---
 crates/horizon-client/src/game.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index d148f8bd7..d34755b07 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4833,7 +4833,7 @@ impl Game<'_> {
             self.capture(true);
         }
     }
-    fn draw_item(&mut self, batch: &mut HudBatch, stack: &ItemStack, x: f32, y: f32) {
+    fn draw_item(&self, batch: &mut HudBatch, stack: &ItemStack, x: f32, y: f32) {
         // `GuiGraphics.renderItem`: the resolved item model (tints, foil and
         // special renderers included), then the decorations.
         self.draw_item_model(batch, stack, x, y);
@@ -4923,7 +4923,7 @@ impl Game<'_> {
     /// `GuiGraphicsExtractor.itemDecorations`: the count (or `count_text`)
     /// and damage bar.
     fn draw_item_decorations(
-        &mut self,
+        &self,
         batch: &mut HudBatch,
         stack: &ItemStack,
         x: f32,
@@ -5050,12 +5050,12 @@ impl Game<'_> {
                 for d in &draws {
                     if let hud_layout::GuiDraw::Item { slot, x, y, .. } = *d {
                         let stack = if slot == 40 {
-                            self.offhand.clone()
+                            self.offhand.as_ref()
                         } else {
-                            self.inventory[slot as usize].clone()
+                            self.inventory[slot as usize].as_ref()
                         };
                         if let Some(stack) = stack {
-                            self.draw_item(&mut batch, &stack, x as f32, y as f32);
+                            self.draw_item(&mut batch, stack, x as f32, y as f32);
                         }
                     }
                 }

From 3353f1b6e4cbe9e8e4ff69957252286c87e8a89a Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:24:16 +0100
Subject: [PATCH 045/475] Elytra: hurt on wall hits, stop on climbables and
 levitation, Unbreaking wear, real gravity

Gliding into a wall now hurts like LivingEntity.handleFallFlyingCollisions
(fly_into_wall, big or small fall sound). A glide no longer starts on a
climbable or under Levitation, ends there, and a climbable (not vines) ends a
glide in progress. The glide's elytra wear goes through Unbreaking, and the
glide uses the effective gravity instead of 0.08.
---
 crates/horizon-client/src/game.rs   | 16 ++++---
 crates/horizon-client/src/motion.rs | 70 ++++++++++++++++++++++++++---
 2 files changed, 74 insertions(+), 12 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 5760ffbe7..37ea98ba5 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4326,12 +4326,6 @@ impl Game<'_> {
         let events = std::mem::take(&mut player.events);
         let spin_hit = player.spin_hit.take();
         let glider_wear = std::mem::take(&mut player.glider_wear);
-        if glider_wear > 0
-            && !self.creative
-            && let Some(elytra) = self.armor[1].as_mut()
-        {
-            elytra.damage += glider_wear;
-        }
         let feet = [player.position.x, player.position.y, player.position.z];
         let player_velocity = [player.velocity.x, player.velocity.y, player.velocity.z];
         self.previous_eye = self.eye;
@@ -4342,6 +4336,16 @@ impl Game<'_> {
         };
         self.eye += (camera_eye.unwrap_or(eye_height) - self.eye) * 0.5;
         let crouching = player.pose == horizon_client::pose::Pose::Crouching;
+        // `ItemStack.hurtAndBreak` for the glide: Unbreaking can save the wear.
+        if glider_wear > 0
+            && !self.creative
+            && let Some(stack) = self.armor[1].clone()
+        {
+            let loss = self.durability_loss(&stack, glider_wear);
+            if let Some(elytra) = self.armor[1].as_mut() {
+                elytra.damage += loss;
+            }
+        }
         self.tick_avatar(before, riding);
         self.end_spin_attack(spin_hit);
         self.record_combat(&events);
diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index 0bce8927c..29e9d3e06 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -50,6 +50,8 @@ pub struct MotionResources {
     pub attributes: Arc<Catalog>,
     pub blocks: BoundMovementProperties,
     pub climbable: BTreeSet<String>,
+    /// `BlockTags.CAN_GLIDE_THROUGH`: climbable blocks a gliding player passes.
+    pub glide_through: BTreeSet<String>,
     pub fall_reset: BTreeSet<String>,
     pub landing: BlockLandingRegistry,
     pub health: crate::health::HealthResources,
@@ -108,6 +110,7 @@ impl MotionResources {
                 suppresses_bounce: tag("minecraft:suppresses_bounce")?,
             })?,
             climbable: tag("minecraft:climbable")?,
+            glide_through: tag("minecraft:can_glide_through")?,
             fall_reset: tag("minecraft:fall_damage_resetting")?,
         })
     }
@@ -765,6 +768,10 @@ impl MotionWorld<'_, '_, '_> {
             .state(self.block(p))
             .ok_or("missing scene state")?
             .name;
+        // A gliding player passes through vines (`CAN_GLIDE_THROUGH`).
+        if self.player.fall_flying && self.resources.glide_through.contains(name) {
+            return Ok(false);
+        }
         let climbable = self.resources.climbable.contains(name);
         if climbable {
             self.player.last_climbable = Some(p);
@@ -834,9 +841,17 @@ impl MotionWorld<'_, '_, '_> {
         let can_glide = self.player.glider
             && !self.player.ground.on_ground
             && !self.player.flying
+            && self.player.status.levitation.is_none()
             && !self.player.fluids.was_touching_water
             && !self.player.is_in_lava();
-        if jumping && !toggled && !was_jumping && !self.player.fall_flying && can_glide {
+        // LocalPlayer.aiStep: `!onClimbable()` before tryToStartFallFlying.
+        if jumping
+            && !toggled
+            && !was_jumping
+            && !self.climbable()?
+            && !self.player.fall_flying
+            && can_glide
+        {
             self.player.fall_flying = true;
         }
         // LivingEntity.tick fallFlyTicks, then updateFallFlying.
@@ -848,8 +863,11 @@ impl MotionWorld<'_, '_, '_> {
                 self.player.fall_distance = 1.0;
             }
             self.player.fall_fly_ticks += 1;
-            // canGlide alone: water and lava don't end a glide.
-            let still = self.player.glider && !self.player.ground.on_ground && !self.player.flying;
+            // canGlide alone: water and lava don't end a glide, levitation does.
+            let still = self.player.glider
+                && !self.player.ground.on_ground
+                && !self.player.flying
+                && self.player.status.levitation.is_none();
             if !still {
                 self.player.glide_ending = true;
             } else if (self.player.fall_fly_ticks + 1) % 10 == 0
@@ -1021,7 +1039,14 @@ impl MotionWorld<'_, '_, '_> {
         {
             horizon_world::living_fluid::travel_in_fluid(self, input)?;
         } else if self.player.fall_flying {
-            self.travel_fall_flying()?;
+            // LivingEntity.travelFallFlying: on a climbable the glide ends and
+            // the player moves like in the air.
+            if self.climbable()? {
+                self.travel_in_air(input)?;
+                self.player.fall_flying = false;
+            } else {
+                self.travel_fall_flying()?;
+            }
         } else {
             self.travel_in_air(input)?;
         }
@@ -1528,7 +1553,7 @@ impl MotionWorld<'_, '_, '_> {
         let lean = pitch;
         let look_h = (look.x * look.x + look.z * look.z).sqrt();
         let move_h = (v.x * v.x + v.z * v.z).sqrt();
-        let gravity = 0.08;
+        let gravity = living_motion::effective_gravity(self)?;
         let lift = f64::from(lean.cos()).powi(2);
         let mut m = Vec3::new(v.x, v.y + gravity * (-1.0 + lift * 0.75), v.z);
         if m.y < 0.0 && look_h > 0.0 {
@@ -1556,7 +1581,40 @@ impl MotionWorld<'_, '_, '_> {
         }
         self.player.velocity = Vec3::new(m.x * 0.99, m.y * 0.98, m.z * 0.99);
         let movement = self.player.velocity;
-        self.move_self(movement)
+        self.move_self(movement)?;
+        // LivingEntity.handleFallFlyingCollisions: only the server hurts.
+        if !self.player.client_side && self.player.collision.horizontal {
+            let new_h = {
+                let v = self.player.velocity;
+                (v.x * v.x + v.z * v.z).sqrt()
+            };
+            let dmg = ((move_h - new_h) * 10.0 - 3.0) as f32;
+            if dmg > 0.0 {
+                // getFallDamageSound((int) dmg)
+                let sound = if dmg as i32 > 4 {
+                    crate::landing::SceneSound::BigFall
+                } else {
+                    crate::landing::SceneSound::SmallFall
+                };
+                self.player
+                    .events
+                    .push(MotionEvent::Fall(crate::landing::FallEvent::Sound {
+                        sound,
+                        position: None,
+                        volume: 1.0,
+                        pitch: 1.0,
+                    }));
+                let id = self
+                    .resources
+                    .health
+                    .damage
+                    .id("minecraft:fly_into_wall")
+                    .ok_or("missing fly_into_wall damage type")?;
+                let rules = self.scene.health_rules;
+                self.player.hurt(&self.resources.health, rules, id, dmg)?;
+            }
+        }
+        Ok(())
     }
     /// `LocalPlayer.move`: the move, then `updateAutoJump` with the float
     /// horizontal displacement.

From af6b375626c3eadacb66981a4ea1f346e506112d Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:25:55 +0100
Subject: [PATCH 046/475] Guardians: damage scales with Hard and elders, squid
 and axolotls must be beyond 3 blocks

---
 crates/horizon-client/src/mobs/goals.rs    | 11 +++++++++++
 crates/horizon-client/src/mobs/guardian.rs |  9 ++++++---
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs
index 7f73e32c4..d873a2820 100644
--- a/crates/horizon-client/src/mobs/goals.rs
+++ b/crates/horizon-client/src/mobs/goals.rs
@@ -1210,6 +1210,9 @@ pub struct NearestTarget {
     pub interval: i32,
     /// Extra condition on the attacker, checked after the random interval.
     pub when: Option<fn(&Mob, &MobWorld) -> bool>,
+    /// Mobs closer than this squared distance are not picked
+    /// (`GuardianAttackSelector`: `distanceToSqr > 9`).
+    pub beyond_sqr: Option<f64>,
     /// A condition checked before anything else, by subclasses overriding
     /// `canUse` (SpiderTargetGoal: only in the dark).
     pub gate: Option<fn(&Mob, &MobWorld) -> bool>,
@@ -1242,6 +1245,7 @@ impl NearestTarget {
             must_reach: false,
             interval: reduced(10),
             when: None,
+            beyond_sqr: None,
             gate: None,
             label: None,
             found: None,
@@ -1274,6 +1278,10 @@ impl NearestTarget {
         self.when = Some(f);
         self
     }
+    pub fn beyond(mut self, distance_sqr: f64) -> Self {
+        self.beyond_sqr = Some(distance_sqr);
+        self
+    }
     pub fn gate(mut self, f: fn(&Mob, &MobWorld) -> bool) -> Self {
         self.gate = Some(f);
         self
@@ -1361,6 +1369,9 @@ impl Goal for NearestTarget {
                     if m.distance_sqr(cpos) > range * range {
                         continue;
                     }
+                    if self.beyond_sqr.is_some_and(|d| m.distance_sqr(cpos) <= d) {
+                        continue;
+                    }
                     if !m.sees(cx.w, Who::Mob(cid)) {
                         continue;
                     }
diff --git a/crates/horizon-client/src/mobs/guardian.rs b/crates/horizon-client/src/mobs/guardian.rs
index d6219794d..4cbce22d9 100644
--- a/crates/horizon-client/src/mobs/guardian.rs
+++ b/crates/horizon-client/src/mobs/guardian.rs
@@ -61,7 +61,8 @@ pub fn register(m: &mut Mob) {
         NearestTarget::species(
             &[Species::Squid, Species::GlowSquid, Species::Axolotl],
             true,
-        ),
+        )
+        .beyond(9.0),
     );
 }
 /// `GuardianAttackGoal`.
@@ -120,9 +121,11 @@ impl Goal for GuardianAttack {
                 1.0,
             ));
         } else if self.attack_time >= attack_duration(m) {
-            // Indirect magic (1, +2 for the elder; NORMAL difficulty), then
+            // Indirect magic (1, +2 on Hard, +2 for the elder), then
             // doHurtTarget.
-            let magic = if is_elder(m) { 3.0 } else { 1.0 };
+            let magic = 1.0
+                + if cx.w.difficulty.hard { 2.0 } else { 0.0 }
+                + if is_elder(m) { 2.0 } else { 0.0 };
             let from = [m.position.x, m.position.y, m.position.z];
             match who {
                 Who::Player => cx.events.push(MobEvent::DamagePlayer {

From 05fd9c3795ab85b63cc1ab0a700e7d63cbf09f4e Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:26:59 +0100
Subject: [PATCH 047/475] Chests with a block or a sitting cat on top no longer
 open

---
 crates/horizon-client/src/game.rs         |  4 ++
 crates/horizon-client/src/game/storage.rs | 49 +++++++++++++++++++++++
 2 files changed, 53 insertions(+)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 5760ffbe7..b21a3ccec 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -3005,6 +3005,10 @@ impl Game<'_> {
             .name
             .clone();
         let key = (pos[0], pos[1], pos[2]);
+        if self.chest_menu_blocked(key, &name) {
+            // The use still succeeds, but no menu, stat or piglin anger.
+            return;
+        }
         if &*name == "minecraft:lectern" {
             self.open_lectern(pos);
             return;
diff --git a/crates/horizon-client/src/game/storage.rs b/crates/horizon-client/src/game/storage.rs
index 1bcb6a524..e5cb0ab26 100644
--- a/crates/horizon-client/src/game/storage.rs
+++ b/crates/horizon-client/src/game/storage.rs
@@ -33,6 +33,55 @@ impl Game<'_> {
         self.container = Some(key);
         self.ender_open = Some(key);
     }
+    /// The block above `key` is a redstone conductor.
+    fn conductor_above(&self, key: (i32, i32, i32)) -> bool {
+        let above = self.world.block(key.0, key.1 + 1, key.2);
+        self.res.behaviours().facts(above).flags
+            & horizon_world::level::data::state_flags::CONDUCTOR
+            != 0
+    }
+    /// `ChestBlock.isChestBlockedAt`: a redstone conductor above the chest or
+    /// a cat sitting on it.
+    fn chest_blocked_at(&self, key: (i32, i32, i32)) -> bool {
+        if self.conductor_above(key) {
+            return true;
+        }
+        // isCatSittingOnChest: a cat whose box meets the block above.
+        let area = horizon_core::geometry::Aabb::new(
+            horizon_core::geometry::Vec3::new(
+                f64::from(key.0),
+                f64::from(key.1 + 1),
+                f64::from(key.2),
+            ),
+            horizon_core::geometry::Vec3::new(
+                f64::from(key.0 + 1),
+                f64::from(key.1 + 2),
+                f64::from(key.2 + 1),
+            ),
+        );
+        self.mobs.iter().any(|m| {
+            m.species() == horizon_client::mobs::Species::Cat
+                && m.alive()
+                && horizon_client::mobs::tame::cat_sitting(m)
+                && m.bounds().intersects(area)
+        })
+    }
+    /// `ChestBlock.getMenuProvider` (`combine(.., false)`) and
+    /// `EnderChestBlock.useWithoutItem`: a blocked chest, or a double chest
+    /// with either half blocked, opens no menu.
+    pub(super) fn chest_menu_blocked(&self, key: (i32, i32, i32), name: &str) -> bool {
+        match name {
+            "minecraft:chest" | "minecraft:trapped_chest" => {
+                self.chest_blocked_at(key)
+                    || self
+                        .chest_partner(key)
+                        .is_some_and(|(other, _)| self.chest_blocked_at(other))
+            }
+            // The ender chest only looks at the block above (no cat check).
+            "minecraft:ender_chest" => self.conductor_above(key),
+            _ => false,
+        }
+    }
     /// Closing it copies the items back and leaves no block-entity contents.
     pub(super) fn close_ender_chest(&mut self) {
         let Some(key) = self.ender_open.take() else {

From 0ba73d0a7e122b059ff862447722beb2460b07df Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:27:05 +0100
Subject: [PATCH 048/475] Match vanilla evoker, fangs and vex rules

Count vexes and look for blue sheep within a 16 block radius, spare only
illagers and their vexes with evoker fangs, and let vexes ignore raiders
(including ravagers) instead of other vexes.
---
 crates/horizon-client/src/game/fangs.rs   | 30 ++++++++++++++++-------
 crates/horizon-client/src/mobs/illager.rs | 10 +++++---
 crates/horizon-client/src/mobs/vex.rs     |  3 ++-
 3 files changed, 29 insertions(+), 14 deletions(-)

diff --git a/crates/horizon-client/src/game/fangs.rs b/crates/horizon-client/src/game/fangs.rs
index cdf2d17a5..aed692649 100644
--- a/crates/horizon-client/src/game/fangs.rs
+++ b/crates/horizon-client/src/game/fangs.rs
@@ -81,16 +81,28 @@ impl Game<'_> {
         };
         bite(self);
         self.each_guest_hit(bite);
+        // `AbstractIllager.considersEntityAsAlly`: with no teams, the illager
+        // tag is allied; `Evoker.considersEntityAsAlly` adds a vex whose
+        // owner is allied (itself or another illager). Teams are not modelled.
+        let illager = |s: Species| {
+            matches!(
+                s,
+                Species::Evoker | Species::Illusioner | Species::Pillager | Species::Vindicator
+            )
+        };
+        let illagers: Vec<u32> = self
+            .mobs
+            .iter()
+            .filter(|m| illager(m.species()))
+            .map(|m| m.id)
+            .collect();
+        // A missing owner hurts everyone (`currentOwner == null`).
+        let owner_known = illagers.contains(&f.owner);
         for m in &mut self.mobs {
-            let ally = matches!(
-                m.species(),
-                Species::Evoker
-                    | Species::Illusioner
-                    | Species::Vex
-                    | Species::Pillager
-                    | Species::Vindicator
-                    | Species::Witch
-            );
+            let ally = owner_known
+                && (illager(m.species())
+                    || m.species() == Species::Vex
+                        && illagers.contains(&(m.extra.counter2 as u32)));
             if m.id != f.owner && !ally && m.alive() && m.bounds().intersects(b) {
                 m.damage(
                     6.0,
diff --git a/crates/horizon-client/src/mobs/illager.rs b/crates/horizon-client/src/mobs/illager.rs
index 45ef076d3..a037e7c5f 100644
--- a/crates/horizon-client/src/mobs/illager.rs
+++ b/crates/horizon-client/src/mobs/illager.rs
@@ -179,8 +179,8 @@ impl Goal for UseSpell {
     fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
         let age = i64::from(m.age);
         if self.spell == Spell::Wololo {
-            // EvokerWololoSpellGoal.canUse: a blue sheep within 16 (4 up or
-            // down), no target, griefing on.
+            // EvokerWololoSpellGoal.canUse: a blue sheep within the box
+            // (16 sideways, 4 up or down) and `range(16)`, no target, griefing on.
             if m.ai.target.is_some() || m.extra.counter > 0 || age < self.next || !cx.w.mob_griefing
             {
                 return false;
@@ -196,6 +196,7 @@ impl Goal for UseSpell {
                             && (s.position.x - p.x).abs() <= 16.0
                             && (s.position.y - p.y).abs() <= 4.0
                             && (s.position.z - p.z).abs() <= 16.0
+                            && s.position.distance_squared(p) <= 16.0 * 16.0
                     })
                     .map(|s| s.id)
                     .collect();
@@ -210,7 +211,8 @@ impl Goal for UseSpell {
             return false;
         }
         if self.spell == Spell::Vexes {
-            // EvokerSummonSpellGoal: fewer vexes nearby than a roll of 1..8.
+            // EvokerSummonSpellGoal: fewer vexes within `range(16)` than a
+            // roll of 1..8.
             let p = m.position;
             let vexes =
                 cx.w.others
@@ -218,7 +220,7 @@ impl Goal for UseSpell {
                     .filter(|s| {
                         s.species == Species::Vex
                             && s.alive
-                            && s.position.distance_squared(p) <= 16.0 * 16.0 * 3.0
+                            && s.position.distance_squared(p) <= 16.0 * 16.0
                     })
                     .count() as i32;
             return m.random.next_int_bound(8).unwrap_or(0) + 1 > vexes;
diff --git a/crates/horizon-client/src/mobs/vex.rs b/crates/horizon-client/src/mobs/vex.rs
index de38f6da8..1301d1922 100644
--- a/crates/horizon-client/src/mobs/vex.rs
+++ b/crates/horizon-client/src/mobs/vex.rs
@@ -29,6 +29,7 @@ pub fn register(m: &mut Mob) {
     g.add(8, RandomMove);
     g.add(9, LookAtPlayer::new(3.0).probability(1.0));
     g.add(10, LookAtPlayer::mobs(8.0));
+    // `HurtByTargetGoal(this, Raider.class)`: raiders are ignored, vexes are not.
     let mut hurt = HurtByTarget::new().alert();
     hurt.ignore = vec![
         Species::Pillager,
@@ -36,7 +37,7 @@ pub fn register(m: &mut Mob) {
         Species::Evoker,
         Species::Illusioner,
         Species::Witch,
-        Species::Vex,
+        Species::Ravager,
     ];
     m.ai.targets.add(1, hurt);
     m.ai.targets.add(2, CopyOwnerTarget);

From 991406d0e0b8bfd8ac87e54372e1fd82b55b0e44 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:27:10 +0100
Subject: [PATCH 049/475] Turtle helmet: Water Breathing while the eyes are out
 of the water

---
 crates/horizon-client/src/game/music.rs   |  2 +-
 crates/horizon-client/src/game/potions.rs | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/music.rs b/crates/horizon-client/src/game/music.rs
index 6f8b5e7ae..fa5e71f7b 100644
--- a/crates/horizon-client/src/game/music.rs
+++ b/crates/horizon-client/src/game/music.rs
@@ -91,7 +91,7 @@ impl Game<'_> {
             })
     }
     /// `isEyeInFluid(WATER)`: the eye inside the water of its block column.
-    fn eye_in_water(&self, x: f64, eye_y: f64, z: f64) -> bool {
+    pub(super) fn eye_in_water(&self, x: f64, eye_y: f64, z: f64) -> bool {
         let (bx, by, bz) = (x.floor() as i32, eye_y.floor() as i32, z.floor() as i32);
         let f = self.res.facts().get(self.world.block(bx, by, bz));
         if f.fluid != Fluid::Water {
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index b28c2fb4d..e0fc963c1 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -390,8 +390,28 @@ impl Game<'_> {
         for action in actions {
             self.apply_effect_action(action);
         }
+        self.turtle_helmet_tick();
         self.apply_effect_status();
     }
+    /// `Player.tick` -> `turtleHelmetTick`: with a turtle helmet on the head
+    /// and the eyes out of the water, Water Breathing for 200 ticks (no
+    /// particles, an icon).
+    fn turtle_helmet_tick(&mut self) {
+        let Some(p) = self.player.as_ref() else {
+            return;
+        };
+        let eye_y = p.position.y + f64::from(p.dimensions.eye_height);
+        if !p.health.dead_or_dying()
+            && self.armor[0]
+                .as_ref()
+                .is_some_and(|s| &*s.item == "minecraft:turtle_helmet")
+            && !self.eye_in_water(p.position.x, eye_y, p.position.z)
+        {
+            let mut effect = EffectInstance::new("water_breathing", 200, 0);
+            effect.visible = false;
+            self.potions.effects.add(effect);
+        }
+    }
     /// A client's own effects (`LivingEntity.tickEffects` on the client,
     /// `MobEffectInstance.tickClient`): they count down, and the server
     /// removes them. Their modifiers and flags move the predicted player.

From 4aa7838d1ba0434d8f5de4b0b0267b2698dd08e4 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:27:48 +0100
Subject: [PATCH 050/475] Shulker bullets make open shulkers teleport and
 duplicate

An open shulker hit by a shulker bullet teleports and may leave a new
shulker of its colour behind, like Shulker.hitByShulkerBullet. Levitation
from the bullet now needs the hit to have hurt the player.
---
 crates/horizon-client/src/game/creatures.rs | 10 +++--
 crates/horizon-client/src/mobs/shulker.rs   | 41 ++++++++++++++++++++-
 2 files changed, 46 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..18b5cd9fd 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2364,12 +2364,14 @@ impl Game<'_> {
             // ShulkerBullet.onHitEntity: 4 damage, then levitation for 10 s.
             (ProjectileKind::ShulkerBullet { .. }, Hit::Entity { who, .. }) => match who {
                 Who::Player => {
-                    if !self.creative {
-                        self.mob_hits_player(
+                    // Only a hit that hurt (`wasHurt`) brings the levitation.
+                    if !self.creative
+                        && self.mob_hits_player(
                             4.0,
                             [p.previous.x, p.previous.y, p.previous.z],
                             "minecraft:mob_projectile",
-                        );
+                        )
+                    {
                         self.give_player_effect("minecraft:levitation", 200, 0);
                     }
                 }
@@ -2378,6 +2380,8 @@ impl Game<'_> {
                         && m.damage(4.0, source)
                     {
                         m.extra.levitation = 200;
+                        // Shulker.hurtServer: a shulker hit by a bullet.
+                        horizon_client::mobs::shulker::hit_by_bullet(m);
                     }
                 }
             },
diff --git a/crates/horizon-client/src/mobs/shulker.rs b/crates/horizon-client/src/mobs/shulker.rs
index 11ebdadb4..ccb33fd24 100644
--- a/crates/horizon-client/src/mobs/shulker.rs
+++ b/crates/horizon-client/src/mobs/shulker.rs
@@ -3,7 +3,7 @@
 //! their face is lost or when badly hurt, and shrugging off arrows while
 //! closed.
 use super::{
-    Damage, DamageKind, Mob, MobEvent, MobWorld, Who,
+    Damage, DamageKind, Mob, MobEvent, MobWorld, Species, Who,
     anim::{Poses, State},
     goals::{
         Cx, Goal, HurtByTarget, LOOK, LookAtPlayer, MOVE, NearestTarget, RandomLookAround,
@@ -164,12 +164,49 @@ pub fn after_hurt(m: &mut Mob) {
         m.extra.flag = true;
     }
 }
-/// The deferred teleport of `after_hurt`.
+/// `Shulker.hurtServer` after a shulker bullet's damage: unless the
+/// low-health teleport was drawn instead (`else if`), `hitByShulkerBullet`
+/// runs on the next tick.
+pub fn hit_by_bullet(m: &mut Mob) {
+    if m.species() == Species::Shulker && !m.extra.flag {
+        m.extra.flag2 = true;
+    }
+}
+/// The deferred teleport of `after_hurt` and `hitByShulkerBullet`.
 pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     if m.extra.flag {
         m.extra.flag = false;
         teleport(m, w, events);
     }
+    if m.extra.flag2 {
+        m.extra.flag2 = false;
+        hit_by_shulker_bullet(m, w, events);
+    }
+}
+/// `Shulker.hitByShulkerBullet`: an open shulker teleports, and leaves a
+/// new one of its colour behind unless shulkers crowd the place (one in
+/// five fewer chances for every other shulker within 8 blocks).
+fn hit_by_shulker_bullet(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
+    let old_position = m.position;
+    let old_box = m.bounds();
+    if m.extra.counter == 0 || !teleport(m, w, events) {
+        return;
+    }
+    let area = old_box.inflate(Vec3::new(8.0, 8.0, 8.0));
+    // The shulker itself stands within reach of its old box, so it counts.
+    let others = w
+        .others_near(area)
+        .filter(|s| {
+            s.alive && s.species == Species::Shulker && s.id != m.id && s.bounds.intersects(area)
+        })
+        .count();
+    let failure_chance = others as f32 / 5.0;
+    if m.random.next_float() < failure_chance {
+        return;
+    }
+    let mut baby = Mob::new(0, m.kind.clone(), old_position, 0.0);
+    baby.extra.color = m.extra.color;
+    events.push(MobEvent::Spawn(Box::new(baby)));
 }
 /// A ProjectileWorld over the mob world, for aiming a new bullet.
 struct Probe<'a, 'w> {

From 54fe73854e38f8bd16cee43f840ddd9d34ce40f1 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:28:06 +0100
Subject: [PATCH 051/475] Cactus destroys dropped items that touch it

---
 crates/horizon-client/src/entities.rs         |  9 ++++++
 crates/horizon-client/src/items.rs            | 30 +++++++++++++++++++
 .../horizon-client/src/motion/environment.rs  | 23 ++++++++++++++
 3 files changed, 62 insertions(+)

diff --git a/crates/horizon-client/src/entities.rs b/crates/horizon-client/src/entities.rs
index 6e8089e9d..a45b1af59 100644
--- a/crates/horizon-client/src/entities.rs
+++ b/crates/horizon-client/src/entities.rs
@@ -95,6 +95,15 @@ impl ItemEntity {
                 self.health -= fire_damage as i32;
             }
         }
+        // CactusBlock.entityInside: `entity.hurt(cactus, 1.0)`. An item has no
+        // hurt cooldown, so it loses 1 health every tick it touches a cactus
+        // (5 health: gone in 5 ticks). Fire resistance does not help;
+        // `ItemStack.canBeHurtBy` only skips it for a damage_resistant stack.
+        if crate::motion::environment::cactus_contact(world, registry, self.bounds())
+            && !items.resists_cactus(&self.stack)
+        {
+            self.health -= 1;
+        }
         ItemEnvironmentTick {
             alive: self.health > 0,
             lava_hurt,
diff --git a/crates/horizon-client/src/items.rs b/crates/horizon-client/src/items.rs
index 8ac450bcb..c425e2026 100644
--- a/crates/horizon-client/src/items.rs
+++ b/crates/horizon-client/src/items.rs
@@ -392,6 +392,36 @@ impl Items {
         self.get(&stack.item).is_some_and(|i| i.fire_resistant)
     }
 
+    /// `ItemStack.canBeHurtBy` for the cactus damage type: a `damage_resistant`
+    /// component naming `minecraft:cactus`, or a damage type tag that holds it.
+    /// (`#minecraft:is_fire`, as on netherite gear, does not.)
+    pub fn resists_cactus(&self, stack: &ItemStack) -> bool {
+        const CACTUS_TAGS: [&str; 5] = [
+            "#minecraft:bypasses_shield",
+            "#minecraft:no_knockback",
+            "#minecraft:panic_environmental_causes",
+            "#minecraft:panic_causes",
+            "#minecraft:sulfur_cube_with_block_immune_to",
+        ];
+        let Some((_, v)) = stack.data().and_then(|data| {
+            data.other
+                .iter()
+                .find(|(key, _)| key == "minecraft:damage_resistant")
+        }) else {
+            return false;
+        };
+        match v.get("types") {
+            Some(horizon_world::nbt::Tag::String(id)) => id
+                .to_string()
+                .is_ok_and(|id| id == "minecraft:cactus" || CACTUS_TAGS.contains(&id.as_str())),
+            Some(horizon_world::nbt::Tag::List(ids)) => ids.iter().any(|t| {
+                matches!(t, horizon_world::nbt::Tag::String(id)
+                    if id.to_string().is_ok_and(|id| id == "minecraft:cactus"))
+            }),
+            _ => false,
+        }
+    }
+
     pub fn load(root: &Path, registry: &BlockRegistry, facts: &BlockFacts) -> Result<Self> {
         let mut block_for_item: HashMap<&str, BlockStateId> = HashMap::new();
         for (i, s) in facts.states.iter().enumerate() {
diff --git a/crates/horizon-client/src/motion/environment.rs b/crates/horizon-client/src/motion/environment.rs
index fc3c63c77..5e9bdfec8 100644
--- a/crates/horizon-client/src/motion/environment.rs
+++ b/crates/horizon-client/src/motion/environment.rs
@@ -161,6 +161,29 @@ pub(crate) fn fire_contact(
     }
     damage
 }
+/// `CactusBlock.entityInside`: the box (deflated by `1.0E-5`, as in
+/// `Entity.checkInsideBlocks`) touches a cactus; its inside shape is the
+/// whole block.
+pub(crate) fn cactus_contact(
+    world: &World,
+    registry: &horizon_world::registry::BlockRegistry,
+    bounds: Aabb,
+) -> bool {
+    let b = bounds.deflate(Vec3::new(1e-5, 1e-5, 1e-5));
+    for x in b.min_position().x.floor() as i32..=b.max_position().x.floor() as i32 {
+        for y in b.min_position().y.floor() as i32..=b.max_position().y.floor() as i32 {
+            for z in b.min_position().z.floor() as i32..=b.max_position().z.floor() as i32 {
+                if registry
+                    .state(world.block(x, y, z))
+                    .is_some_and(|s| s.name == "minecraft:cactus")
+                {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}
 impl LivingFluidWorld for MotionWorld<'_, '_, '_> {
     fn in_water(&mut self) -> Result<bool> {
         Ok(self.player.fluids.was_touching_water)

From bcdf769f8d0790007201277219708f0e8bacefd3 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:28:20 +0100
Subject: [PATCH 052/475] Illagers do not attack baby villagers

AbstractIllager.canAttack refuses a baby villager or wandering trader.
Skip them when an illager picks a nearest target and drop them from an
illager's current target.
---
 crates/horizon-client/src/mobs/goals.rs | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs
index 7f73e32c4..931569b7d 100644
--- a/crates/horizon-client/src/mobs/goals.rs
+++ b/crates/horizon-client/src/mobs/goals.rs
@@ -1284,9 +1284,25 @@ impl NearestTarget {
         self
     }
 }
+/// `AbstractIllager.canAttack`: a baby `AbstractVillager` is never attacked.
+fn illager_spares(attacker: Species, target: &Seen) -> bool {
+    matches!(
+        attacker,
+        Species::Pillager | Species::Vindicator | Species::Evoker | Species::Illusioner
+    ) && target.baby
+        && matches!(target.species, Species::Villager | Species::WanderingTrader)
+}
 /// TargetGoal.canContinueToUse
 pub fn target_continue(st: &mut TargetState, must_see: bool, m: &mut Mob, cx: &mut Cx) -> bool {
     let Some(who) = m.ai.target else { return false };
+    if let Who::Mob(id) = who
+        && cx
+            .w
+            .seen(id)
+            .is_some_and(|s| illager_spares(m.species(), s))
+    {
+        return false;
+    }
     let Some(t) = cx.w.target_info(who) else {
         return false;
     };
@@ -1345,10 +1361,12 @@ impl Goal for NearestTarget {
             prey => {
                 let pos = Vec3::new(m.position.x, m.eye_y(), m.position.z);
                 let id = m.id;
+                let attacker = m.species();
                 let candidates: Vec<(u32, Vec3)> =
                     cx.w.nearby(pos, range, move |s| {
                         s.id != id
                             && !s.playing_dead
+                            && !illager_spares(attacker, s)
                             && match prey {
                                 Prey::Species(list) => list.contains(&s.species),
                                 Prey::Filter(f) => f(s),

From 6875c44bbe4974ec6d807808536001301bc0043f Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:28:40 +0100
Subject: [PATCH 053/475] Piglins accept only gold ingots by hand, keep other
 loved items, pick up more

Right-clicking a piglin with any loved item used to consume it and the piglin threw it back. Now only piglin currency (gold ingots) is accepted from the hand, and anything else a piglin admires is worn if it can be or stored in its inventory, which saves, and drops when it dies. Piglins also pick up gold nuggets when they have room, food when they have not eaten lately, and gear that fits an empty slot.
---
 crates/horizon-client/src/entity_nbt.rs   |  23 +++
 crates/horizon-client/src/game/piglins.rs | 221 ++++++++++++++++++----
 crates/horizon-client/src/mobs.rs         |   2 +
 crates/horizon-client/src/mobs/drops.rs   |   8 +
 crates/horizon-client/src/mobs/piglin.rs  |   6 +
 5 files changed, 227 insertions(+), 33 deletions(-)

diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 00576ea02..ab6e2a328 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -265,6 +265,19 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
                 Tag::Byte(i8::from(m.extra.flag2)),
             );
             map.insert("TimeInOverworld".into(), Tag::Int(m.extra.counter2));
+            if id == "minecraft:piglin" {
+                // InventoryCarrier.writeInventoryToTag.
+                map.insert(
+                    "Inventory".into(),
+                    Tag::List(
+                        m.extra
+                            .inventory
+                            .iter()
+                            .map(crate::save::item_to_nbt)
+                            .collect(),
+                    ),
+                );
+            }
         }
         "minecraft:horse"
         | "minecraft:donkey"
@@ -706,6 +719,16 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     ) {
         m.extra.flag2 = flag(tag, "IsImmuneToZombification");
         m.extra.counter2 = number(tag.get("TimeInOverworld")).unwrap_or(0) as i32;
+        if m.species() == crate::mobs::Species::Piglin
+            && let Some(Tag::List(items)) = tag.get("Inventory")
+        {
+            // InventoryCarrier.readInventoryFromTag (eight slots).
+            m.extra.inventory = items
+                .iter()
+                .filter_map(crate::save::item_from_nbt)
+                .take(8)
+                .collect();
+        }
     }
     if matches!(
         m.species(),
diff --git a/crates/horizon-client/src/game/piglins.rs b/crates/horizon-client/src/game/piglins.rs
index bcf9e6ab5..337efe8a6 100644
--- a/crates/horizon-client/src/game/piglins.rs
+++ b/crates/horizon-client/src/game/piglins.rs
@@ -4,18 +4,168 @@
 use super::Game;
 use horizon_client::{
     items::ItemStack,
-    mobs::{Species, Who, piglin::ADMIRE},
+    mobs::{
+        Mob, Species, Who,
+        finalize::{SLOT_NAMES, set_drop_chance, set_item, stored_drop_chance},
+        piglin::{ADMIRE, ATE_RECENTLY},
+    },
 };
 use horizon_core::{geometry::Vec3, random::RandomSource};
 
 impl Game<'_> {
-    fn piglin_loved(&self, item: &str) -> bool {
+    fn item_in_tag(&self, tag: &str, item: &str) -> bool {
         self.res
             .items()
             .item_tags
-            .get("minecraft:piglin_loved")
+            .get(tag)
             .is_some_and(|t| t.contains(item))
     }
+    fn piglin_loved(&self, item: &str) -> bool {
+        self.item_in_tag("minecraft:piglin_loved", item)
+    }
+    /// `PiglinAi.isLovedItem` or a preferred weapon (`Piglin.canReplaceCurrentItem`).
+    fn piglin_wanted(&self, item: &str) -> bool {
+        self.piglin_loved(item) || self.item_in_tag("minecraft:piglin_preferred_weapons", item)
+    }
+    /// The `SLOT_NAMES` index `getEquipmentSlotForItem` picks: armour goes
+    /// to its slot, anything else to the main hand.
+    fn piglin_slot(&self, item: &str) -> usize {
+        let slot = match self
+            .res
+            .items()
+            .get(item)
+            .and_then(|i| i.equip_slot.as_deref())
+        {
+            Some(s @ ("head" | "chest" | "legs" | "feet")) => s,
+            _ => "mainhand",
+        };
+        SLOT_NAMES.iter().position(|n| *n == slot).unwrap_or(0)
+    }
+    /// `Piglin.canReplaceCurrentItem`: an empty slot takes anything, a wanted
+    /// item replaces an unwanted one and never the other way round. Vanilla's
+    /// armour and weapon comparison for two equal-interest items is left out
+    /// (the piglin keeps what it has).
+    fn piglin_can_replace(&self, m: &Mob, item: &str, slot: usize) -> bool {
+        let Some(current) = horizon_client::mobs::finalize::item(m, slot) else {
+            return true;
+        };
+        self.piglin_wanted(item) && !self.piglin_wanted(&current)
+    }
+    /// `SimpleContainer.canAddItem` on the piglin's eight slots.
+    fn piglin_can_add(&self, m: &Mob, stack: &ItemStack) -> bool {
+        m.extra.inventory.len() < 8
+            || m.extra.inventory.iter().any(|s| {
+                s.same_item_same_components(stack) && s.count < self.piglin_max_stack(&s.item)
+            })
+    }
+    fn piglin_max_stack(&self, item: &str) -> u32 {
+        self.res.items().get(item).map_or(64, |i| i.max_stack)
+    }
+    /// `PiglinAi.wantsToPickup` (an adult that is not hurt-shy), without
+    /// the baby rule, which babies skip entirely here.
+    fn piglin_wants(&self, m: &Mob, stack: &ItemStack) -> bool {
+        let item = &*stack.item;
+        if self.item_in_tag("minecraft:piglin_repellents", item) {
+            return false;
+        }
+        let holds_loved = m
+            .extra
+            .off_hand
+            .as_deref()
+            .is_some_and(|o| self.piglin_loved(o));
+        if item == "minecraft:gold_ingot" {
+            return !holds_loved;
+        }
+        let space = self.piglin_can_add(m, stack);
+        if item == "minecraft:gold_nugget" {
+            space
+        } else if self.item_in_tag("minecraft:piglin_food", item) {
+            m.extra.ints[0] <= 0 && space
+        } else if !self.piglin_loved(item) {
+            self.piglin_can_replace(m, item, self.piglin_slot(item))
+        } else {
+            !holds_loved && space
+        }
+    }
+    /// `Mob.equipItemIfPossible` for a piglin: put it in its slot when that
+    /// slot takes it (an armour piece that cannot replace what is worn goes
+    /// to an empty main hand), dropping what it replaces by drop chance.
+    fn piglin_equip(&mut self, index: usize, item: &str) -> bool {
+        let mut slot = self.piglin_slot(item);
+        let m = &self.mobs[index];
+        let mut replace = self.piglin_can_replace(m, item, slot);
+        if slot > 1 && !replace {
+            slot = 0;
+            replace = m.extra.main_hand.is_none();
+        }
+        if !replace {
+            return false;
+        }
+        let m = &mut self.mobs[index];
+        let old = horizon_client::mobs::finalize::item(m, slot);
+        let chance = stored_drop_chance(m, slot);
+        let drop_old = old.is_some() && (m.random.next_float() - 0.1).max(0.0) < chance;
+        set_item(m, slot, item);
+        // setItemSlotAndDropWhenKilled, then persistenceRequired.
+        set_drop_chance(m, slot, 2.0);
+        m.persistent = true;
+        let at = [m.position.x, m.position.y, m.position.z];
+        if let (true, Some(old)) = (drop_old, old) {
+            self.spawn_item(
+                ItemStack::new(&old, 1),
+                at,
+                super::dispenser::new_item_motion(),
+                10,
+            );
+        }
+        true
+    }
+    /// `PiglinAi.putInInventory`: what does not fit is thrown at a random
+    /// spot nearby.
+    fn piglin_stash(&mut self, index: usize, mut stack: ItemStack) {
+        let max = self.piglin_max_stack(&stack.item);
+        let m = &mut self.mobs[index];
+        for s in &mut m.extra.inventory {
+            if stack.count > 0 && s.same_item_same_components(&stack) && s.count < max {
+                let n = (max - s.count).min(stack.count);
+                s.count += n;
+                stack.count -= n;
+            }
+        }
+        while stack.count > 0 && m.extra.inventory.len() < 8 {
+            let n = stack.count.min(max);
+            m.extra.inventory.push(ItemStack {
+                count: n,
+                ..stack.clone()
+            });
+            stack.count -= n;
+        }
+        if stack.count == 0 {
+            return;
+        }
+        let from = [m.position.x, m.position.y + 1.3, m.position.z];
+        let r = &mut self.world.random;
+        let to = [
+            from[0] + f64::from(r.next_float() * 8.0 - 4.0),
+            from[1],
+            from[2] + f64::from(r.next_float() * 8.0 - 4.0),
+        ];
+        self.piglin_throw(from, to, stack);
+    }
+    /// `PiglinAi.stopHoldingOffHandItem` for something that is not
+    /// bartering currency: wear it if it can, else keep it in the inventory.
+    fn piglin_keep(&mut self, index: usize, stack: ItemStack) {
+        if !self.piglin_equip(index, &stack.item) {
+            self.piglin_stash(index, stack);
+        }
+    }
+    /// `BehaviorUtils.throwItem`: toss a stack from a point toward another.
+    fn piglin_throw(&mut self, from: [f64; 3], to: [f64; 3], stack: ItemStack) {
+        let d = [to[0] - from[0], to[1] - from[1], to[2] - from[2]];
+        let len = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt().max(1e-6);
+        let v = [d[0] / len * 0.3, d[1] / len * 0.3 + 0.1, d[2] / len * 0.3];
+        self.spawn_item(stack, from, v, 40);
+    }
     /// `PiglinAi.isWearingSafeArmor`.
     pub(super) fn wearing_gold(&self) -> bool {
         let tag = self
@@ -28,15 +178,13 @@ impl Game<'_> {
             .flatten()
             .any(|s| tag.is_some_and(|t| t.contains(&*s.item)))
     }
-    /// Piglins notice gold on the ground within 9 blocks, walk to it and
-    /// take it (`GoToWantedItem`, `Piglin.pickUpItem`).
+    /// Piglins notice wanted items on the ground within 9 blocks (`PiglinAi.wantsToPickup`:
+    /// gold and other loved items, nuggets, food, gear), walk to them and
+    /// take them (`GoToWantedItem`, `Piglin.pickUpItem`).
     pub(super) fn piglin_pickups(&mut self) {
         if !self.ui.rules.bool("mob_griefing") {
             return;
         }
-        // Whether each item is piglin-loved, kept until an item is added or
-        // removed (added ones are pushed at the end under a new id).
-        let mut loved: (Option<(usize, Option<u32>)>, Vec<bool>) = (None, Vec::new());
         for i in 0..self.mobs.len() {
             let m = &self.mobs[i];
             if m.species() != Species::Piglin
@@ -44,27 +192,17 @@ impl Game<'_> {
                 || m.is_baby()
                 || m.extra.using_item > 0
                 || m.extra.egg_time > 0
-                || m.extra.off_hand.is_some()
             {
                 continue;
             }
             let pos = m.position;
-            let key = (self.dropped.len(), self.dropped.last().map(|e| e.id));
-            if loved.0 != Some(key) {
-                loved.0 = Some(key);
-                loved.1 = self
-                    .dropped
-                    .iter()
-                    .map(|e| self.piglin_loved(&e.stack.item))
-                    .collect();
-            }
             let best = self
                 .dropped
                 .iter()
                 .enumerate()
-                .filter(|&(j, _)| loved.1[j])
                 .map(|(j, e)| (j, e.position.distance_squared(pos)))
                 .filter(|(_, d)| *d <= 81.0)
+                .filter(|&(j, _)| self.piglin_wants(m, &self.dropped[j].stack))
                 .min_by(|a, b| a.1.total_cmp(&b.1));
             let Some((j, _)) = best else {
                 self.mobs[i].extra.point = None;
@@ -79,24 +217,38 @@ impl Game<'_> {
                 continue;
             }
             // Nuggets come whole, anything else one at a time.
-            let item = e.stack.item.clone();
             let (taken_item, id) = (e.clone(), self.mobs[i].id);
+            let item = e.stack.item.clone();
             self.add_pickup(
                 super::pickups::Taken::Item(Box::new(taken_item)),
                 super::pickups::Collector::Mob(id),
             );
-            let taken = if &*item == "minecraft:gold_nugget" {
-                self.dropped.remove(j).stack.count
+            let stack = if &*item == "minecraft:gold_nugget" {
+                self.dropped.remove(j).stack
             } else {
                 let e = &mut self.dropped[j];
                 e.stack.count -= 1;
+                let one = ItemStack {
+                    count: 1,
+                    ..e.stack.clone()
+                };
                 if e.stack.count == 0 {
                     self.dropped.remove(j);
                 }
-                1
+                one
             };
-            let _ = taken;
-            self.start_admiring(i, item);
+            if self.piglin_loved(&item) {
+                self.start_admiring(i, item);
+            } else if self.item_in_tag("minecraft:piglin_food", &item)
+                && self.mobs[i].extra.ints[0] <= 0
+            {
+                // PiglinAi.eat: the food is gone and it will not eat for a while.
+                self.mobs[i].extra.ints[0] = ATE_RECENTLY;
+                self.mobs[i].nav_stop();
+            } else {
+                self.mobs[i].nav_stop();
+                self.piglin_keep(i, stack);
+            }
         }
     }
     fn start_admiring(&mut self, index: usize, item: std::sync::Arc<str>) {
@@ -109,14 +261,15 @@ impl Game<'_> {
         self.audio
             .play("minecraft:entity.piglin.admiring_item", Some(at), 1.0, 1.0);
     }
-    /// `PiglinAi.mobInteract`: hand a piglin something it loves.
+    /// `PiglinAi.mobInteract`: hand a piglin a gold ingot (only piglin
+    /// currency is accepted from the hand; other loved items are passed over).
     pub(super) fn give_piglin(&mut self, index: usize, item: &str) -> bool {
         let m = &self.mobs[index];
         if m.species() != Species::Piglin
             || m.is_baby()
             || m.extra.using_item > 0
             || m.extra.egg_time > 0
-            || !self.piglin_loved(item)
+            || item != "minecraft:gold_ingot"
         {
             return false;
         }
@@ -124,7 +277,8 @@ impl Game<'_> {
         true
     }
     /// `PiglinAi.stopHoldingOffHandItem` after admiring: gold ingots buy a
-    /// roll of the bartering table, thrown toward the player.
+    /// roll of the bartering table, thrown toward the player; any other loved
+    /// item it picked up is kept (worn if it can be, else stored).
     pub(super) fn finish_admiring(&mut self, mob: u32) {
         let Some(i) = self.mobs.iter().position(|m| m.id == mob) else {
             return;
@@ -132,9 +286,13 @@ impl Game<'_> {
         let Some(item) = self.mobs[i].extra.off_hand.take() else {
             return;
         };
+        if &*item != "minecraft:gold_ingot" {
+            self.piglin_keep(i, ItemStack::new(&item, 1));
+            return;
+        }
         let m = &self.mobs[i];
         let from = [m.position.x, m.position.y + 1.3, m.position.z];
-        let items = if &*item == "minecraft:gold_ingot" && !m.is_baby() {
+        let items = if !m.is_baby() {
             self.res.items().loot_table(
                 "minecraft:gameplay/piglin_bartering",
                 false,
@@ -176,10 +334,7 @@ impl Game<'_> {
                     from[2] + f64::from(r.next_float() * 8.0 - 4.0),
                 ]
             });
-            let d = [to[0] - from[0], to[1] - from[1], to[2] - from[2]];
-            let len = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt().max(1e-6);
-            let v = [d[0] / len * 0.3, d[1] / len * 0.3 + 0.1, d[2] / len * 0.3];
-            self.spawn_item(stack, from, v, 40);
+            self.piglin_throw(from, to, stack);
         }
     }
     /// `PiglinAi.angerNearbyPiglins`.
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..f9b4f226f 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -665,6 +665,8 @@ pub struct Extra {
     pub chested: bool,
     /// The chest contents of a donkey or mule (15 slots).
     pub items: Vec<Option<crate::items::ItemStack>>,
+    /// `Piglin.inventory` (`SimpleContainer(8)`): what it picked up and kept.
+    pub inventory: Vec<crate::items::ItemStack>,
     pub tame: bool,
     pub sitting: bool,
     /// The owner's UUID (tamed animals).
diff --git a/crates/horizon-client/src/mobs/drops.rs b/crates/horizon-client/src/mobs/drops.rs
index e5ccfd283..0dbae7db9 100644
--- a/crates/horizon-client/src/mobs/drops.rs
+++ b/crates/horizon-client/src/mobs/drops.rs
@@ -455,6 +455,14 @@ pub fn die(m: &mut Mob, d: &Death, sequences: &mut RandomSequences) -> (Vec<Drop
             out.push(Drop::Item(loot_stack("minecraft:nether_star", 1)));
         }
     }
+    // Piglin.dropCustomDeathLoot: everything in its inventory.
+    if s == Species::Piglin {
+        for stack in m.extra.inventory.drain(..) {
+            let mut item = loot_stack(&stack.item, stack.count as i32);
+            item.damage = stack.damage as i32;
+            out.push(Drop::Item(item));
+        }
+    }
     // dropEquipment: AbstractHorse's inventory, then a chested horse's chest.
     if equine::is_equine(s) {
         for stack in m.extra.items.iter().flatten() {
diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs
index 410364097..dc32fb138 100644
--- a/crates/horizon-client/src/mobs/piglin.rs
+++ b/crates/horizon-client/src/mobs/piglin.rs
@@ -15,6 +15,9 @@ use std::f32::consts::PI;
 
 /// `PiglinAi.ADMIRE_DURATION`.
 pub const ADMIRE: i32 = 119;
+/// `PiglinAi.eat`: the `ATE_RECENTLY` memory lasts 200 ticks (kept in
+/// `extra.ints[0]` of a piglin).
+pub const ATE_RECENTLY: i32 = 200;
 /// `AbstractPiglin.CONVERSION_TIME` (and the hoglin's).
 const CONVERSION: i32 = 300;
 
@@ -177,6 +180,9 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
             m.ai.target = None;
         }
     }
+    if m.species() == Species::Piglin && m.extra.ints[0] > 0 {
+        m.extra.ints[0] -= 1;
+    }
     // Admiring disabled after being hit by a player.
     if m.extra.egg_time > 0 {
         m.extra.egg_time -= 1;

From 551a9ee9c53382ed998b38cb1d390e3b57cea959 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:30:29 +0100
Subject: [PATCH 054/475] Make lightning strike the closest lightning rod

---
 crates/horizon-client/src/game/lightning.rs | 64 ++++++++++++++++++++-
 1 file changed, 62 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs
index 916bd2a0a..3ffe8daf5 100644
--- a/crates/horizon-client/src/game/lightning.rs
+++ b/crates/horizon-client/src/game/lightning.rs
@@ -74,14 +74,74 @@ impl Game<'_> {
             self.spawn_bolt(at, trap);
         }
     }
-    /// `findLightningTargetAround`: a living entity under open sky in the
-    /// column (3 blocks around), else the top of the column.
+    /// `ServerLevel.findLightningRod`: `PoiManager.findClosest` over the
+    /// lightning rod points of interest within 128 blocks of `center` whose
+    /// block is the top (`WORLD_SURFACE`) of its column; the strike lands one
+    /// above it. Horizon keeps no point-of-interest index, so this scans the
+    /// loaded chunks the way `/locate poi` does.
+    fn find_lightning_rod(&self, center: [i32; 3]) -> Option<[i32; 3]> {
+        const RANGE: i32 = 128;
+        let facts = self.res.facts();
+        let mut is_rod: std::collections::HashMap<u32, bool> = std::collections::HashMap::new();
+        let mut best: Option<(i64, [i32; 3])> = None;
+        let (cx0, cz0) = ((center[0] - RANGE) >> 4, (center[2] - RANGE) >> 4);
+        let (cx1, cz1) = ((center[0] + RANGE) >> 4, (center[2] + RANGE) >> 4);
+        for cx in cx0..=cx1 {
+            for cz in cz0..=cz1 {
+                let Some(chunk) = self.world.chunks.get(&(cx, cz)) else {
+                    continue;
+                };
+                for (i, section) in chunk.sections.iter().enumerate() {
+                    let mut rod = |state: u32| {
+                        *is_rod.entry(state).or_insert_with(|| {
+                            facts
+                                .get(horizon_world::registry::BlockStateId(state))
+                                .name
+                                .ends_with("lightning_rod")
+                        })
+                    };
+                    if !section.blocks.maybe_has(&mut rod) {
+                        continue;
+                    }
+                    let base_y = horizon_client::chunk::MIN_Y + 16 * i as i32;
+                    for j in 0..4096 {
+                        if !rod(section.get(j)) {
+                            continue;
+                        }
+                        let p = [
+                            cx * 16 + (j & 15) as i32,
+                            base_y + (j >> 8) as i32,
+                            cz * 16 + ((j >> 4) & 15) as i32,
+                        ];
+                        let d = [p[0] - center[0], p[1] - center[1], p[2] - center[2]]
+                            .map(|d| i64::from(d) * i64::from(d))
+                            .iter()
+                            .sum::<i64>();
+                        if d > i64::from(RANGE * RANGE) || best.is_some_and(|(b, _)| d >= b) {
+                            continue;
+                        }
+                        let surface = self.world.world_surface(p[0], p[2], |s| facts.is_air(s));
+                        if p[1] == surface - 1 {
+                            best = Some((d, p));
+                        }
+                    }
+                }
+            }
+        }
+        best.map(|(_, p)| [p[0], p[1] + 1, p[2]])
+    }
+    /// `findLightningTargetAround`: the closest lightning rod, else a living
+    /// entity under open sky in the column (3 blocks around), else the top of
+    /// the column.
     fn lightning_target(&mut self, x: i32, z: i32) -> Option<[i32; 3]> {
         if !self.world.loaded(x, z) {
             return None;
         }
         let top =
             self.with_level(|b, level, _| b.motion_blocking_top(level, BlockPos::new(x, 0, z)));
+        if let Some(rod) = self.find_lightning_rod([x, top.y, z]) {
+            return Some(rod);
+        }
         let sees_sky = |g: &Self, p: [i32; 3]| g.world.light(p[0], p[1], p[2]) >> 4 == 15;
         let mut candidates: Vec<[i32; 3]> = self
             .mobs

From fcfd425b94a719f80417b210bb671ed70db96aeb Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:30:32 +0100
Subject: [PATCH 055/475] Give the conduit its power and its attack

A conduit with enough prismarine around it now gives conduit power to
players in water or rain in range, hurts an enemy in water or rain when
it has 42 frame blocks, and plays its activate, deactivate and ambient
sounds, as ConduitBlockEntity.serverTick does. Its target also feeds the
client's attack particles.
---
 .../horizon-client/src/block_entity_anim.rs   |  61 ++++++
 .../src/game/block_entity_anims.rs            | 205 +++++++++++++++++-
 crates/horizon-client/src/game/levels.rs      |   1 +
 3 files changed, 265 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/block_entity_anim.rs b/crates/horizon-client/src/block_entity_anim.rs
index d91748e73..53884e5ec 100644
--- a/crates/horizon-client/src/block_entity_anim.rs
+++ b/crates/horizon-client/src/block_entity_anim.rs
@@ -648,6 +648,61 @@ impl Conduit {
     }
 }
 
+/// What `ConduitBlockEntity.serverTick`'s 40-tick check decided.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct ConduitCheck {
+    /// The shape changed: `CONDUIT_ACTIVATE` (true) or `CONDUIT_DEACTIVATE`.
+    pub toggled: Option<bool>,
+    /// The frame blocks counted, while the conduit is active: `applyEffects`
+    /// and `updateAndAttackTarget` follow (the attack needs 42 or more).
+    pub frames: Option<usize>,
+}
+
+/// `ConduitBlockEntity` (server side): what `serverTick` keeps between ticks.
+#[derive(Clone, Debug, Default)]
+pub struct ConduitServer {
+    shape: Conduit,
+    /// `destroyTarget`: the mob id of the enemy being struck.
+    pub target: Option<u32>,
+    next_ambient_sound: i64,
+}
+
+impl ConduitServer {
+    /// The `gameTime % 40` part of `serverTick`: the shape is checked again.
+    pub fn check(
+        &mut self,
+        pos: [i32; 3],
+        game_time: i64,
+        is_water: impl Fn([i32; 3]) -> bool,
+        is_frame: impl Fn([i32; 3]) -> bool,
+    ) -> Option<ConduitCheck> {
+        if game_time % 40 != 0 {
+            return None;
+        }
+        let active = self.shape.update_shape(pos, &is_water, &is_frame);
+        let toggled = (active != self.shape.is_active).then_some(active);
+        self.shape.is_active = active;
+        Some(ConduitCheck {
+            toggled,
+            frames: active.then_some(self.shape.effect_blocks.len()),
+        })
+    }
+    /// The sounds of an active conduit at the end of `serverTick`: whether
+    /// `CONDUIT_AMBIENT` (every 80 ticks) and `CONDUIT_AMBIENT_SHORT` (every
+    /// 60 to 99 ticks) play.
+    pub fn ambient(&mut self, game_time: i64, random: &mut impl RandomSource) -> (bool, bool) {
+        if !self.shape.is_active {
+            return (false, false);
+        }
+        let short = game_time > self.next_ambient_sound;
+        if short {
+            self.next_ambient_sound =
+                game_time + 60 + i64::from(random.next_int_bound(40).unwrap_or(0));
+        }
+        (game_time % 80 == 0, short)
+    }
+}
+
 /// `SkullBlockEntity` animation (client ticker of dragon and piglin heads).
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub struct Skull {
@@ -832,6 +887,8 @@ pub struct BlockEntityAnims {
     pub gateways: FxHashMap<[i32; 3], EndGateway>,
     /// The integrated server's copies of the gateways (`portalTick`).
     pub gateway_servers: FxHashMap<[i32; 3], EndGateway>,
+    /// The integrated server's copies of the conduits (`serverTick`).
+    pub conduit_servers: FxHashMap<[i32; 3], ConduitServer>,
     /// The client level's random (conduit particles).
     pub random: LegacyRandom,
     /// [`Ticker`] by block state id (see [`BlockEntityAnims::classify`]).
@@ -854,6 +911,7 @@ impl Default for BlockEntityAnims {
             pots: FxHashMap::default(),
             gateways: FxHashMap::default(),
             gateway_servers: FxHashMap::default(),
+            conduit_servers: FxHashMap::default(),
             random: LegacyRandom::new(0x6c6576656c),
             kinds: Vec::new(),
             present: Vec::new(),
@@ -892,6 +950,8 @@ impl BlockEntityAnims {
         self.bells.retain(|p, _| is(p, |t| *t == Ticker::Bell));
         self.conduits
             .retain(|p, _| is(p, |t| *t == Ticker::Conduit));
+        self.conduit_servers
+            .retain(|p, _| is(p, |t| *t == Ticker::Conduit));
         self.skulls
             .retain(|p, _| is(p, |t| matches!(t, Ticker::Skull { .. })));
         self.pots.retain(|p, _| is(p, |t| *t == Ticker::Pot));
@@ -909,6 +969,7 @@ impl BlockEntityAnims {
         self.pots.retain(|p, _| keep(*p));
         self.gateways.retain(|p, _| keep(*p));
         self.gateway_servers.retain(|p, _| keep(*p));
+        self.conduit_servers.retain(|p, _| keep(*p));
     }
     /// `getOpenNess(partial)` of the chest or ender chest at `pos`.
     pub fn lid(&self, pos: [i32; 3], partial: f32) -> f32 {
diff --git a/crates/horizon-client/src/game/block_entity_anims.rs b/crates/horizon-client/src/game/block_entity_anims.rs
index 3d452596e..daec3523a 100644
--- a/crates/horizon-client/src/game/block_entity_anims.rs
+++ b/crates/horizon-client/src/game/block_entity_anims.rs
@@ -5,10 +5,14 @@
 //! [`Game::block_anim`] and [`Game::chest_lid`].
 use super::Game;
 use horizon_client::{
-    block_entity_anim::{BellEntity, EndGateway, Shulker, ShulkerStatus, Ticker},
+    block_entity_anim::{
+        BellEntity, ConduitServer, ConduitTarget, EndGateway, Shulker, ShulkerStatus, Ticker,
+    },
     block_entity_render::BlockAnim,
     collisions::{SceneCollisions, no_collision_empty},
     containers::BlockEntity,
+    effects::EffectInstance,
+    mobs::{Damage, DamageKind},
     particles::{ParticleOptions, ParticleType},
     save::number,
     skins,
@@ -16,6 +20,7 @@ use horizon_client::{
 use horizon_core::{
     geometry::{Aabb, Vec3},
     position::BlockPos,
+    random::RandomSource,
 };
 use horizon_world::nbt::Tag;
 
@@ -337,6 +342,12 @@ impl Game<'_> {
                     }
                 }
                 Ticker::Conduit => {
+                    // A server runs the effects and the attack; a client of
+                    // one only animates what it is sent.
+                    if self.remote.is_none() {
+                        self.tick_conduit_server(pos);
+                    }
+                    let target = self.conduit_target(pos);
                     let world = &self.world;
                     let facts = self.res.facts();
                     let registry = self.pack.assets.registry;
@@ -356,7 +367,7 @@ impl Game<'_> {
                         time,
                         is_water,
                         is_frame,
-                        None,
+                        target,
                         self.particles.random(),
                     );
                     let nautilus = ParticleOptions::simple(ParticleType::Nautilus);
@@ -383,6 +394,196 @@ impl Game<'_> {
         }
         self.be_anims.present = positions;
     }
+    /// `ConduitBlockEntity.serverTick` of the conduit at `pos`, in a chunk
+    /// that ticks blocks: the shape check every 40 ticks with its sounds, the
+    /// power for players in range, the hurt for an enemy, then the ambient
+    /// sounds.
+    fn tick_conduit_server(&mut self, pos: [i32; 3]) {
+        if !self.tickets.levels().block_ticking_at(pos[0], pos[2])
+            || !self.border.contains(f64::from(pos[0]), f64::from(pos[2]))
+        {
+            return;
+        }
+        let time = self.world.game_time;
+        let mut conduit = self
+            .be_anims
+            .conduit_servers
+            .remove(&pos)
+            .unwrap_or_default();
+        let check = {
+            let world = &self.world;
+            let facts = self.res.facts();
+            let registry = self.pack.assets.registry;
+            let frames = self
+                .res
+                .items()
+                .block_tags
+                .get("minecraft:conduit_effect_block");
+            // Level.isWaterAt: the fluid at the position is water.
+            let is_water = |p: [i32; 3]| {
+                facts.get(world.block(p[0], p[1], p[2])).fluid
+                    == horizon_client::blocks::Fluid::Water
+            };
+            let is_frame = |p: [i32; 3]| {
+                registry
+                    .state(world.block(p[0], p[1], p[2]))
+                    .is_some_and(|s| frames.is_some_and(|f| f.contains(&s.name)))
+            };
+            conduit.check(pos, time, is_water, is_frame)
+        };
+        let centre = [
+            f64::from(pos[0]) + 0.5,
+            f64::from(pos[1]) + 0.5,
+            f64::from(pos[2]) + 0.5,
+        ];
+        if let Some(check) = check {
+            if let Some(active) = check.toggled {
+                let sound = if active {
+                    "minecraft:block.conduit.activate"
+                } else {
+                    "minecraft:block.conduit.deactivate"
+                };
+                self.audio.play(sound, Some(centre), 1.0, 1.0);
+            }
+            if let Some(frames) = check.frames {
+                self.conduit_apply_effects(pos, frames);
+                self.conduit_attack(&mut conduit, pos, frames >= 42);
+            }
+        }
+        let (ambient, short) = conduit.ambient(time, &mut self.world.random);
+        if ambient {
+            self.audio
+                .play("minecraft:block.conduit.ambient", Some(centre), 1.0, 1.0);
+        }
+        if short {
+            self.audio.play(
+                "minecraft:block.conduit.ambient_short",
+                Some(centre),
+                1.0,
+                1.0,
+            );
+        }
+        self.be_anims.conduit_servers.insert(pos, conduit);
+    }
+    /// `ConduitBlockEntity.applyEffects`: conduit power for every player
+    /// in water or rain within `frames / 7 * 16` blocks.
+    fn conduit_apply_effects(&mut self, pos: [i32; 3], frames: usize) {
+        let range = (frames / 7 * 16) as i64;
+        self.for_each_player(|g| {
+            let Some(p) = g.player.as_ref().filter(|p| !p.health.dead_or_dying()) else {
+                return;
+            };
+            if g.spectator() {
+                return;
+            }
+            let at = p.position;
+            let in_water = p.fluids.was_touching_water;
+            let top = at.y + f64::from(p.dimensions.height);
+            // BlockPos.closerThan: the squared distance under range squared.
+            let d = [at.x, at.y, at.z]
+                .map(|v| v.floor() as i64)
+                .iter()
+                .zip(pos)
+                .map(|(a, b)| (a - i64::from(b)).pow(2))
+                .sum::<i64>();
+            if d >= range * range || !(in_water || g.in_rain(at, top)) {
+                return;
+            }
+            let power = EffectInstance {
+                ambient: true,
+                ..EffectInstance::new("conduit_power", 260, 0)
+            };
+            g.potions.effects.add(power);
+        });
+    }
+    /// `Entity.isInRain`: rain at the block position or at the top of the box.
+    fn in_rain(&mut self, at: Vec3, top: f64) -> bool {
+        let p = BlockPos::new(
+            at.x.floor() as i32,
+            at.y.floor() as i32,
+            at.z.floor() as i32,
+        );
+        let up = BlockPos::new(p.x, top.floor() as i32, p.z);
+        self.with_level(|b, level, _| b.is_raining_at(level, p) || b.is_raining_at(level, up))
+    }
+    /// `ConduitBlockEntity.updateAndAttackTarget`: while the conduit hunts
+    /// (42 frame blocks) its target stays until it dies or leaves the 8
+    /// blocks, else a random enemy in water or rain is chosen; the target
+    /// takes 4 magic damage.
+    fn conduit_attack(&mut self, conduit: &mut ConduitServer, pos: [i32; 3], hunting: bool) {
+        conduit.target = match conduit.target {
+            _ if !hunting => None,
+            None => self.conduit_new_target(pos),
+            Some(id) => self
+                .mobs
+                .iter()
+                .find(|m| m.id == id && !m.removed)
+                .filter(|m| {
+                    let at = [m.position.x, m.position.y, m.position.z].map(|v| v.floor() as i64);
+                    m.alive()
+                        && at
+                            .iter()
+                            .zip(pos)
+                            .map(|(a, b)| (a - i64::from(b)).pow(2))
+                            .sum::<i64>()
+                            < 64
+                })
+                .map(|m| m.id),
+        };
+        let Some(m) = conduit
+            .target
+            .and_then(|id| self.mobs.iter_mut().find(|m| m.id == id))
+        else {
+            return;
+        };
+        let at = [m.position.x, m.position.y, m.position.z];
+        m.damage(4.0, Damage::of(DamageKind::Magic));
+        self.audio
+            .play("minecraft:block.conduit.attack.target", Some(at), 1.0, 1.0);
+    }
+    /// `ConduitBlockEntity.selectNewTarget`: one of the enemies in water or
+    /// rain whose box meets the conduit's block inflated by 8.
+    fn conduit_new_target(&mut self, pos: [i32; 3]) -> Option<u32> {
+        let [x, y, z] = pos.map(f64::from);
+        let area = Aabb::new(
+            Vec3::new(x - 8.0, y - 8.0, z - 8.0),
+            Vec3::new(x + 9.0, y + 9.0, z + 9.0),
+        );
+        let near: Vec<(u32, bool, Vec3, f64)> = self
+            .mobs
+            .iter()
+            .filter(|m| m.hostile() && !m.removed && m.bounds().intersects(area))
+            .map(|m| {
+                let top = m.position.y + f64::from(m.height());
+                (m.id, m.fluids.in_water, m.position, top)
+            })
+            .collect();
+        let candidates: Vec<u32> = near
+            .into_iter()
+            .filter(|&(_, in_water, at, top)| in_water || self.in_rain(at, top))
+            .map(|(id, ..)| id)
+            .collect();
+        if candidates.is_empty() {
+            return None;
+        }
+        let pick = self
+            .world
+            .random
+            .next_int_bound(candidates.len() as i32)
+            .unwrap_or(0);
+        Some(candidates[pick as usize])
+    }
+    /// The conduit's `destroyTarget` as the client draws it.
+    fn conduit_target(&self, pos: [i32; 3]) -> Option<ConduitTarget> {
+        let id = self.be_anims.conduit_servers.get(&pos)?.target?;
+        let m = self.mobs.iter().find(|m| m.id == id && !m.removed)?;
+        Some(ConduitTarget {
+            position: [m.position.x, m.position.y, m.position.z],
+            eye_y: m.eye_y(),
+            width: m.width(),
+            height: m.height(),
+        })
+    }
     /// `TheEndGatewayBlockEntity.portalTick` (the server ticker) of the
     /// gateways a server keeps a copy of, in block-ticking chunks
     /// (`Level.tickBlockEntities`): the cooldown an entry started runs out,
diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs
index bfc739cee..fae1387b5 100644
--- a/crates/horizon-client/src/game/levels.rs
+++ b/crates/horizon-client/src/game/levels.rs
@@ -222,6 +222,7 @@ impl Game<'_> {
         swap(&mut a.pots, &mut b.pots);
         swap(&mut a.gateways, &mut b.gateways);
         swap(&mut a.gateway_servers, &mut b.gateway_servers);
+        swap(&mut a.conduit_servers, &mut b.conduit_servers);
         self.raiding.swap_level(&mut p.raiding);
         self.sculk.swap_level(&mut p.sculk);
         self.creaking.swap_level(&mut p.creaking);

From 8bfa7a5b7ba893b6faa899d5d9a5b72f2ae7c060 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:31:03 +0100
Subject: [PATCH 056/475] Loot: suspicious stew keeps the effect
 set_stew_effect rolled

The function drew an effect and a duration but dropped them. The stack
now carries the effect and it is stored in suspicious_stew_effects.
---
 .../probe/entity_death_loot_fixture.rs        |  1 +
 crates/horizon-client/src/game/creatures.rs   |  1 +
 crates/horizon-client/src/mobs/drops.rs       |  1 +
 crates/horizon-client/src/structure_blocks.rs |  8 ++++++++
 crates/horizon-world/src/loot.rs              | 20 ++++++++++++++++++-
 5 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/examples/probe/entity_death_loot_fixture.rs b/crates/horizon-client/examples/probe/entity_death_loot_fixture.rs
index 86ef275d9..3f47ba787 100644
--- a/crates/horizon-client/examples/probe/entity_death_loot_fixture.rs
+++ b/crates/horizon-client/examples/probe/entity_death_loot_fixture.rs
@@ -23,6 +23,7 @@ fn stack(spec: &str) -> LootStack {
         map: false,
         exploration: None,
         ominous_amplifier: None,
+        stew_effects: Vec::new(),
     };
     for e in parts {
         let (name, level) = e.rsplit_once(':').unwrap_or((e, "1"));
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..6abd646fd 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -3297,6 +3297,7 @@ fn to_loot(stack: &ItemStack) -> horizon_world::loot::LootStack {
         map: false,
         exploration: None,
         ominous_amplifier: None,
+        stew_effects: Vec::new(),
     }
 }
 /// A generated loot stack as a Horizon item stack.
diff --git a/crates/horizon-client/src/mobs/drops.rs b/crates/horizon-client/src/mobs/drops.rs
index e5ccfd283..c7b1c77e1 100644
--- a/crates/horizon-client/src/mobs/drops.rs
+++ b/crates/horizon-client/src/mobs/drops.rs
@@ -304,6 +304,7 @@ fn loot_stack(item: &str, count: i32) -> LootStack {
         map: false,
         exploration: None,
         ominous_amplifier: None,
+        stew_effects: Vec::new(),
     }
 }
 /// `Mob.dropChances.byEquipment(slot)`: the recorded chance, or the one the
diff --git a/crates/horizon-client/src/structure_blocks.rs b/crates/horizon-client/src/structure_blocks.rs
index 9503294e0..0ff675572 100644
--- a/crates/horizon-client/src/structure_blocks.rs
+++ b/crates/horizon-client/src/structure_blocks.rs
@@ -63,6 +63,12 @@ pub fn loot_item_with_components(s: &horizon_world::loot::LootStack) -> ItemStac
     if let Some(level) = s.ominous_amplifier.filter(|l| *l > 0) {
         item.data_mut().ominous_amplifier = Some(level.clamp(0, 4) as u8);
     }
+    // set_stew_effect's `suspicious_stew_effects`.
+    for (effect, duration) in &s.stew_effects {
+        item.data_mut()
+            .stew_effects
+            .push((Arc::from(effect.as_str()), *duration));
+    }
     item
 }
 
@@ -243,6 +249,7 @@ mod tests {
                 map: false,
                 exploration: None,
                 ominous_amplifier: None,
+                stew_effects: Vec::new(),
             };
         // An End city chest's enchant_with_levels roll.
         let boots = loot_item_with_components(&stack(
@@ -286,6 +293,7 @@ mod tests {
                 "zoom": 1
             })))),
             ominous_amplifier: None,
+            stew_effects: Vec::new(),
         };
         let mut item = loot_item(&stack);
         assert!(has_pending_map(&item));
diff --git a/crates/horizon-world/src/loot.rs b/crates/horizon-world/src/loot.rs
index 96ca5bdee..f98afa21f 100644
--- a/crates/horizon-world/src/loot.rs
+++ b/crates/horizon-world/src/loot.rs
@@ -31,6 +31,9 @@ pub struct LootStack {
     pub exploration: Option<Box<ExplorationMap>>,
     /// Set by set_ominous_bottle_amplifier.
     pub ominous_amplifier: Option<i32>,
+    /// Added by set_stew_effect (the `suspicious_stew_effects` component):
+    /// (effect id, duration in ticks).
+    pub stew_effects: Vec<(String, i32)>,
 }
 /// `ExplorationMapFunction`'s settings.
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -74,6 +77,7 @@ impl LootStack {
             map: false,
             exploration: None,
             ominous_amplifier: None,
+            stew_effects: Vec::new(),
         }
     }
     pub fn is_empty(&self) -> bool {
@@ -678,6 +682,13 @@ impl LootData {
     }
 }
 
+/// `MobEffect.isInstantaneous`.
+fn is_instantaneous(effect: &str) -> bool {
+    matches!(
+        effect,
+        "minecraft:saturation" | "minecraft:instant_health" | "minecraft:instant_damage"
+    )
+}
 /// The level of one enchantment on a stack (its `enchantments` component).
 fn item_level(stack: &LootStack, enchantment: &str) -> i32 {
     stack
@@ -1134,7 +1145,14 @@ impl<R: RandomSource> Context<'_, R> {
                         .random
                         .next_int_bound(effects.len() as i32)
                         .unwrap_or(0) as usize;
-                    self.int(&effects[pick]["duration"]);
+                    let effect = effects[pick]["type"].as_str().unwrap_or("");
+                    let mut duration = self.int(&effects[pick]["duration"]);
+                    // Seconds, unless the effect is instantaneous.
+                    if !is_instantaneous(effect) {
+                        duration *= 20;
+                    }
+                    // SuspiciousStewEffects.withEffectAdded
+                    stack.stew_effects.push((effect.to_owned(), duration));
                 }
             }
             "minecraft:set_ominous_bottle_amplifier" => {

From 3e788469756ab71a5208394bbc0f4c888c290fb4 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:31:28 +0100
Subject: [PATCH 057/475] Soul Speed: speed, no soul sand slowdown, boots wear,
 soul particles

The enchantment's location_changed effects now run for the player: the
movement_speed and movement_efficiency modifiers turn on over soul sand and
soul soil and stay on while airborne, the boots wear with a 4% chance per
block change, and walking on those blocks spawns soul particles and the
soul escape sound.
---
 crates/horizon-client/src/game.rs             |   1 +
 .../src/game/enchant_effects.rs               | 157 +++++++++++++++++-
 crates/horizon-client/src/motion.rs           |  37 +++++
 3 files changed, 192 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 5760ffbe7..515a69cc8 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4342,6 +4342,7 @@ impl Game<'_> {
         };
         self.eye += (camera_eye.unwrap_or(eye_height) - self.eye) * 0.5;
         let crouching = player.pose == horizon_client::pose::Pose::Crouching;
+        self.tick_soul_speed();
         self.tick_avatar(before, riding);
         self.end_spin_attack(spin_hit);
         self.record_combat(&events);
diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs
index aa9f75e06..6550ba9d5 100644
--- a/crates/horizon-client/src/game/enchant_effects.rs
+++ b/crates/horizon-client/src/game/enchant_effects.rs
@@ -3,10 +3,15 @@
 //! unbreaking (`minecraft:item_damage`), sharpness/smite/bane and power
 //! (`minecraft:damage`), knockback, fire aspect, infinity (`minecraft:ammo_use`),
 //! thorns (`minecraft:post_attack`), mending (`minecraft:repair_with_xp`) and
-//! the armor attribute effects (respiration, depth strider, ...).
+//! the armor attribute effects (respiration, depth strider, ...) and Soul
+//! Speed's `location_changed` and `tick` effects.
 use super::Game;
-use horizon_client::{enchant::EffectContext, items::ItemStack};
-use horizon_core::random::RandomSource;
+use horizon_client::{
+    enchant::{EffectContext, Enchantments, level_value},
+    items::ItemStack,
+    particles::{ParticleOptions, ParticleType},
+};
+use horizon_core::{position::BlockPos, random::RandomSource};
 
 /// Where Mending found a damaged item (`EnchantedItemInUse.inSlot`).
 #[derive(Clone, Copy)]
@@ -460,6 +465,127 @@ impl Game<'_> {
         }
         ignite
     }
+    /// Soul Speed (`data/minecraft/enchantment/soul_speed.json`), the parts of
+    /// `Enchantment.runLocationChangedEffects` and `tick` that file uses. The
+    /// `location_changed` effects run when the player enters a new block, lands,
+    /// or its boots change:
+    /// - the speed and movement efficiency modifiers turn on over a soul speed
+    ///   block (not flying, not riding) and stay on while airborne, then off
+    ///   (`enchantment_active_check`);
+    /// - the boots lose 1 durability with a 4% chance when on such a block.
+    ///
+    /// Every fifth tick the player walking on one also gets soul particles and
+    /// sometimes a sound. A remote server applies and syncs all of this itself.
+    pub(super) fn tick_soul_speed(&mut self) {
+        const ID: &str = "minecraft:soul_speed";
+        let Some(player) = self.player.as_mut() else {
+            return;
+        };
+        if player.client_side {
+            return;
+        }
+        let level = self.armor[3]
+            .as_ref()
+            .map_or(0, |s| s.enchantment_level(ID));
+        let position = player.position;
+        let (on_ground, flying) = (player.ground.on_ground, player.flying);
+        let moved = position.subtract(player.old_position);
+        let (tick, width) = (player.health.tick_count, player.dimensions.width);
+        let fx = &mut player.location_effects;
+        let on_soul = fx.on_soul_speed_block;
+        let block = BlockPos::containing(position);
+        let changed_block = fx.block.replace(block) != Some(block);
+        let landed = std::mem::take(&mut fx.landed);
+        // Changed boots: `stopLocationBasedEffects`, then the effects run again.
+        let equipped = std::mem::replace(&mut fx.boots_level, level) != level;
+        let was_active = fx.applied_level;
+        let mut active = was_active > 0 && !equipped;
+        let mut wear = false;
+        if level > 0 && (changed_block || landed || equipped) {
+            let riding = self.riding.is_some();
+            let wanted = !riding && !flying && (on_soul || (active && !on_ground));
+            active = wanted;
+            wear = on_ground && on_soul && self.world.random.next_float() < 0.04;
+        }
+        fx.applied_level = if active { level } else { 0 };
+        // `Entity.getKnownMovement` horizontal speed of at least 1.0E-5.
+        let walking = moved.x * moved.x + moved.z * moved.z >= 1.0e-10;
+        let tick_effects = level > 0 && !flying && on_ground && walking && on_soul && tick % 5 == 0;
+        // The attribute effects were applied to the player before: swap them.
+        if was_active > 0 && (!active || equipped) {
+            for (attribute, id, _, op) in
+                soul_speed_modifiers(&self.res.stations().enchantments, was_active)
+            {
+                let _ = player.set_modifier(&attribute, &id, 0.0, &op, false);
+            }
+        }
+        if active && (was_active == 0 || equipped) {
+            for (attribute, id, amount, op) in
+                soul_speed_modifiers(&self.res.stations().enchantments, level)
+            {
+                let _ = player.set_modifier(&attribute, &id, amount, &op, true);
+            }
+        }
+        if wear && !self.creative {
+            self.wear_boots(1);
+        }
+        if tick_effects {
+            // `spawn_particles`: in the bounding box, 0.1 above the feet, thrown
+            // back against the movement (-0.2) and up (0.1).
+            let r = &mut self.world.random;
+            let x = position.x + (r.next_double() - 0.5) * f64::from(width);
+            let z = position.z + (r.next_double() - 0.5) * f64::from(width);
+            self.particles.send_particles(
+                &ParticleOptions::simple(ParticleType::Soul),
+                [x, position.y + 0.1, z],
+                [moved.x * -0.2, 0.1, moved.z * -0.2],
+                1.0,
+                0,
+            );
+            // `play_sound`: 35% chance, volume 0.6, pitch 0.6 to 1.0.
+            if r.next_float() < 0.35 {
+                let pitch = r.next_float() * 0.4 + 0.6;
+                self.audio.play(
+                    "minecraft:particle.soul_escape",
+                    Some([position.x, position.y, position.z]),
+                    0.6,
+                    pitch,
+                );
+            }
+        }
+    }
+    /// `ItemStack.hurtAndBreak` on the worn boots (`change_item_damage`):
+    /// Unbreaking applies, and they break when worn out.
+    fn wear_boots(&mut self, amount: u32) {
+        let Some(stack) = self.armor[3].clone() else {
+            return;
+        };
+        let loss = self.durability_loss(&stack, amount);
+        let max = self
+            .res
+            .items()
+            .get(&stack.item)
+            .map_or(0, |info| info.max_damage);
+        if max == 0 {
+            return;
+        }
+        let Some(boots) = self.armor[3].as_mut() else {
+            return;
+        };
+        boots.damage += loss;
+        if boots.damage >= max {
+            self.armor[3] = None;
+            if let Some(eye) = self.eye_position() {
+                self.audio.play(
+                    "minecraft:entity.item.break",
+                    Some(eye),
+                    0.8,
+                    0.8 + self.world.random.next_float() * 0.4,
+                );
+            }
+            self.apply_equipment();
+        }
+    }
     /// Enchantment attribute modifiers of worn armor (respiration, depth strider...).
     /// Each piece's modifier id ends with its slot (`EnchantmentAttributeEffect.idForSlot`),
     /// so the same enchantment on two pieces stacks instead of replacing itself.
@@ -483,3 +609,28 @@ impl Game<'_> {
         self.potions.enchant_modifiers = wanted;
     }
 }
+
+/// Soul Speed's `attribute` effects at `level` (attribute, id, amount, operation),
+/// the id taking the boots slot like `EnchantmentAttributeEffect.idForSlot`.
+fn soul_speed_modifiers(
+    enchantments: &Enchantments,
+    level: u32,
+) -> Vec<(String, String, f64, String)> {
+    let Some(e) = enchantments.get("minecraft:soul_speed") else {
+        return Vec::new();
+    };
+    e.effects["minecraft:location_changed"][0]["effect"]["effects"]
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter(|a| a["type"] == "minecraft:attribute")
+        .map(|a| {
+            (
+                a["attribute"].as_str().unwrap_or("").to_owned(),
+                format!("{}/feet", a["id"].as_str().unwrap_or("")),
+                f64::from(level_value(&a["amount"], level)),
+                a["operation"].as_str().unwrap_or("add_value").to_owned(),
+            )
+        })
+        .collect()
+}
diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index 0bce8927c..156fc2549 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -50,6 +50,8 @@ pub struct MotionResources {
     pub attributes: Arc<Catalog>,
     pub blocks: BoundMovementProperties,
     pub climbable: BTreeSet<String>,
+    /// `BlockTags.SOUL_SPEED_BLOCKS`: what Soul Speed's effects look for.
+    pub soul_speed_blocks: BTreeSet<String>,
     pub fall_reset: BTreeSet<String>,
     pub landing: BlockLandingRegistry,
     pub health: crate::health::HealthResources,
@@ -108,11 +110,29 @@ impl MotionResources {
                 suppresses_bounce: tag("minecraft:suppresses_bounce")?,
             })?,
             climbable: tag("minecraft:climbable")?,
+            soul_speed_blocks: tag("minecraft:soul_speed_blocks")?,
             fall_reset: tag("minecraft:fall_damage_resetting")?,
         })
     }
 }
 
+/// What the `location_changed` enchantment effects (Soul Speed) need to know
+/// between ticks.
+#[derive(Clone, Debug, Default)]
+pub struct LocationEffects {
+    /// `MovementAffectedByPredicate`: the block under the player
+    /// (`getBlockPosBelowThatAffectsMyMovement`) is in `#minecraft:soul_speed_blocks`.
+    pub on_soul_speed_block: bool,
+    /// `LivingEntity.lastPos`: the block the player was in last tick.
+    pub block: Option<BlockPos>,
+    /// A landing ran `onChangedBlock` (`LivingEntity.checkFallDamage`).
+    pub landed: bool,
+    /// The Soul Speed level of the boots seen last tick (0: none).
+    pub boots_level: u32,
+    /// The Soul Speed level whose attribute modifiers are on the player (0: none).
+    pub applied_level: u32,
+}
+
 /// Ordered requests and phase records for world/audio/network consumers. Landing
 /// hurt dispatch updates stored health synchronously before these are drained.
 #[derive(Clone, Copy, Debug)]
@@ -255,6 +275,8 @@ pub struct PlayerMotion {
     pub glide_ending: bool,
     /// Glider durability to take this tick (updateFallFlying).
     pub glider_wear: u32,
+    /// Soul Speed's `location_changed` bookkeeping.
+    pub location_effects: LocationEffects,
     /// `LivingEntity.autoSpinAttackTicks` and `autoSpinAttackDmg`: Riptide's
     /// spin. The damage stays until the game has dealt the hit.
     pub auto_spin_attack_ticks: i32,
@@ -443,6 +465,7 @@ impl PlayerMotion {
             fall_fly_ticks: 0,
             glide_ending: false,
             glider_wear: 0,
+            location_effects: LocationEffects::default(),
             auto_spin_attack_ticks: 0,
             auto_spin_attack_dmg: 0.0,
             spin_targets: Vec::new(),
@@ -984,6 +1007,7 @@ impl MotionWorld<'_, '_, '_> {
             )
         });
         self.player.try_add_frost(on_air)?;
+        self.player.location_effects.on_soul_speed_block = self.on_soul_speed_block()?;
         if self.player.health.tick_count % 40 == 0
             && self.player.is_fully_frozen()
             && self.player.can_freeze()
@@ -996,6 +1020,15 @@ impl MotionWorld<'_, '_, '_> {
         }
         Ok(())
     }
+    /// `MovementAffectedByPredicate` for `#minecraft:soul_speed_blocks`.
+    fn on_soul_speed_block(&mut self) -> Result<bool> {
+        let on = self.support(movement_support::MOVEMENT_SUPPORT_OFFSET)?;
+        Ok(self
+            .assets
+            .registry
+            .state(self.block(on))
+            .is_some_and(|s| self.resources.soul_speed_blocks.contains(&s.name)))
+    }
     /// Player.travel: swim steering, then LivingEntity.travel (fluids first,
     /// then gliding, then air), keeping 0.6 of the vertical speed while flying.
     fn player_travel(&mut self, input: Vec3) -> Result<()> {
@@ -1834,6 +1867,10 @@ impl EntityMoveWorld for MotionWorld<'_, '_, '_> {
         if self.player.status.slow_falling || self.player.status.levitation.is_some() {
             self.player.fall_distance = 0.0;
         }
+        // LivingEntity.checkFallDamage: a landing runs onChangedBlock.
+        if grounded && self.player.fall_distance > 0.0 {
+            self.player.location_effects.landed = true;
+        }
         if self.player.spawn_extra_particles_on_fall && grounded && self.player.fall_distance > 0.0
         {
             self.player.events.push(MotionEvent::SmashLanding {

From fd0cb002962ed5d1ae9488b913a4329f850532e1 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:31:58 +0100
Subject: [PATCH 058/475] Axolotls dry out on land, squid squirt ink when a
 living entity hurts them

---
 .../src/game/commands/world_cmds.rs           |  1 +
 crates/horizon-client/src/game/creatures.rs   |  1 +
 crates/horizon-client/src/mobs.rs             | 15 +++++-
 crates/horizon-client/src/mobs/ai.rs          | 32 +++++++++++-
 crates/horizon-client/src/mobs/aquatic.rs     | 52 +++++++++++++++++++
 crates/horizon-client/src/mobs/axolotl.rs     |  2 +
 6 files changed, 101 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs
index 30f019997..eac6f125f 100644
--- a/crates/horizon-client/src/game/commands/world_cmds.rs
+++ b/crates/horizon-client/src/game/commands/world_cmds.rs
@@ -108,6 +108,7 @@ impl Game<'_> {
             "in_fire" | "campfire" | "hot_floor" => DamageKind::InFire,
             "lava" => DamageKind::Lava,
             "drown" => DamageKind::Drown,
+            "dry_out" => DamageKind::DryOut,
             "magic" | "indirect_magic" | "dragon_breath" => DamageKind::Magic,
             "sting" => DamageKind::Sting,
             "cactus" | "sweet_berry_bush" => DamageKind::Cactus,
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..b784b4c98 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -3272,6 +3272,7 @@ pub(super) fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool)
         K::InFire => "minecraft:in_fire",
         K::Lava => "minecraft:lava",
         K::Drown => "minecraft:drown",
+        K::DryOut => "minecraft:dry_out",
         K::Magic => "minecraft:magic",
         K::Sting => "minecraft:sting",
         K::Cactus => "minecraft:cactus",
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..de9c7dfac 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -515,6 +515,8 @@ pub enum DamageKind {
     InFire,
     Lava,
     Drown,
+    /// `dry_out`: an axolotl out of water for too long.
+    DryOut,
     Magic,
     Sting,
     Cactus,
@@ -573,7 +575,11 @@ impl Damage {
     pub fn causes_panic(&self) -> bool {
         !matches!(
             self.kind,
-            DamageKind::Fall | DamageKind::Drown | DamageKind::Generic | DamageKind::InWall
+            DamageKind::Fall
+                | DamageKind::Drown
+                | DamageKind::DryOut
+                | DamageKind::Generic
+                | DamageKind::InWall
         )
     }
     /// DamageTypeTags.BYPASSES_ARMOR
@@ -606,6 +612,7 @@ impl Damage {
                 | DamageKind::InFire
                 | DamageKind::Lava
                 | DamageKind::Drown
+                | DamageKind::DryOut
                 | DamageKind::Magic
                 | DamageKind::Cactus
                 | DamageKind::Generic
@@ -1789,6 +1796,12 @@ impl Mob {
                 }
             }
         }
+        // Squid.hurtServer: a squid hurt after a living entity hit it squirts ink.
+        if matches!(self.species(), Species::Squid | Species::GlowSquid)
+            && self.ai.last_hurt_by.is_some()
+        {
+            aquatic::spawn_ink(self);
+        }
         true
     }
     /// LivingEntity.knockback(power, xd, zd) towards the negative direction.
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 8335cb745..403f63101 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -441,6 +441,34 @@ pub fn tick_swing(m: &mut Mob) {
     }
     m.anim.attack_anim = m.ai.swing_time as f32 / 6.0;
 }
+/// `LivingEntity.baseTick` refills a breather's air by 4, then
+/// `Axolotl.handleAirSupply` (unless the mob has no AI): water or rain fills
+/// it, anywhere else it runs down from the pre-tick value, and at -20 the
+/// axolotl dries out.
+fn axolotl_air_supply(m: &mut Mob, w: &MobWorld) {
+    let before = m.air;
+    m.air = (m.air + 4).min(super::axolotl::MAX_AIR);
+    if m.no_ai {
+        return;
+    }
+    // Entity.isInRain: rain at the block, or at the top of the box.
+    let (x, y, z) = (
+        m.position.x.floor() as i32,
+        m.position.y.floor() as i32,
+        m.position.z.floor() as i32,
+    );
+    let top = (m.position.y + f64::from(m.height())).floor() as i32;
+    let in_rain = w.raining && (w.can_see_sky(x, y, z) || w.can_see_sky(x, top, z));
+    if m.fluids.in_water || in_rain {
+        m.air = super::axolotl::MAX_AIR;
+    } else {
+        m.air = before - 1;
+        if m.air <= -20 {
+            m.air = 0;
+            m.damage(2.0, Damage::of(DamageKind::DryOut));
+        }
+    }
+}
 /// Entity.baseTick + LivingEntity.baseTick + Mob.baseTick.
 fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     m.was_eye_in_water = m.fluids.eye_in_water;
@@ -500,7 +528,9 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
             m.damage(1.0, Damage::of(DamageKind::InWall));
         }
         // Air supply and drowning (WaterAnimal.handleAirSupply for aquatic mobs).
-        if m.kind.flags.needs_water {
+        if m.species() == Species::Axolotl {
+            axolotl_air_supply(m, w);
+        } else if m.kind.flags.needs_water {
             if !m.fluids.in_water {
                 m.air -= 1;
                 if m.air == -20 {
diff --git a/crates/horizon-client/src/mobs/aquatic.rs b/crates/horizon-client/src/mobs/aquatic.rs
index dc80c6ea4..9603d5e58 100644
--- a/crates/horizon-client/src/mobs/aquatic.rs
+++ b/crates/horizon-client/src/mobs/aquatic.rs
@@ -24,6 +24,57 @@ const Z_BODY_ROT: usize = 3;
 const TENTACLE_SPEED: usize = 4;
 const ROTATE_SPEED: usize = 5;
 
+/// `Squid.spawnInk`: the squirt sound and 30 ink particles shot from under
+/// the squid, turned by its body rotation.
+pub fn spawn_ink(m: &mut Mob) {
+    let sound = if m.species() == Species::GlowSquid {
+        "entity.glow_squid.squirt"
+    } else {
+        "entity.squid.squirt"
+    };
+    let kind = if m.species() == Species::GlowSquid {
+        "glow_squid_ink"
+    } else {
+        "squid_ink"
+    };
+    if !m.silent {
+        let pitch = m.voice_pitch();
+        let at = [m.position.x, m.position.y, m.position.z];
+        m.outbox.push(MobEvent::Sound(
+            sound,
+            at,
+            super::ai::sound_volume(m),
+            pitch,
+        ));
+    }
+    // rotateVector: xRot(xBodyRotO), then yRot(-yBodyRotO).
+    let to_radians = (std::f64::consts::PI / 180.0) as f32;
+    let (x_rot, y_rot) = (
+        m.anim.vo[X_BODY_ROT] * to_radians,
+        -m.previous_body_yaw * to_radians,
+    );
+    let rotate = |v: Vec3| v.rotate_x(x_rot).rotate_y(y_rot);
+    let pos = rotate(Vec3::new(0.0, -1.0, 0.0)).add_vector(m.position);
+    let offset_scale: f32 = if m.is_baby() { 0.1 } else { 0.3 };
+    for _ in 0..30 {
+        let x = f64::from(m.random.next_float()) * 0.6 - 0.3;
+        let z = f64::from(m.random.next_float()) * 0.6 - 0.3;
+        let dir = rotate(Vec3::new(x, -1.0, z));
+        let d = dir.scale(f64::from(offset_scale + m.random.next_float() * 2.0));
+        // ServerLevel.sendParticles with a count of 0 and speed 0.1: one
+        // particle moving at the float offset times the float speed.
+        let speed = f64::from(0.1f32);
+        m.outbox.push(MobEvent::ParticleAt {
+            kind,
+            at: [pos.x, pos.y + 0.5, pos.z],
+            velocity: [
+                speed * f64::from(d.x as f32),
+                speed * f64::from(d.y as f32),
+                speed * f64::from(d.z as f32),
+            ],
+        });
+    }
+}
 pub fn register(m: &mut Mob) {
     use Species as S;
     match m.species() {
@@ -36,6 +87,7 @@ pub fn register(m: &mut Mob) {
             m.anim.v[TENTACLE_SPEED] = speed;
         }
         S::Axolotl => {
+            m.air = super::axolotl::MAX_AIR;
             // Native controller scaling is essential: the base speed attribute is 1.0.
             m.ai.mov.kind = MoveKind::SmoothSwimming {
                 max_turn_x: 85.0,
diff --git a/crates/horizon-client/src/mobs/axolotl.rs b/crates/horizon-client/src/mobs/axolotl.rs
index 55f15717c..2815418e3 100644
--- a/crates/horizon-client/src/mobs/axolotl.rs
+++ b/crates/horizon-client/src/mobs/axolotl.rs
@@ -3,6 +3,8 @@ use super::{Mob, MobEvent, MobWorld, Species, Who, animal_brain, keyframes::Anim
 use horizon_core::random::RandomSource;
 pub const PLAY_DEAD_TICKS: i32 = 200;
 pub const HUNTING_COOLDOWN: i64 = 2400;
+/// `Axolotl.getMaxAirSupply`.
+pub const MAX_AIR: i32 = 6000;
 
 /// AxolotlAttackablesSensor: always-hostile targets bypass the hunting cooldown.
 pub fn prey_eligible(

From f24ca405a8a4c13a41a857264ad790ffe8afe9a7 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:33:25 +0100
Subject: [PATCH 059/475] Piglins walk away from soul fire, soul torches, soul
 lanterns and lit soul campfires

Piglins now sense the nearest block from the piglin repellents tag within 8 blocks sideways and 4 up or down (a soul campfire only while lit). When one is closer than 8 blocks and the piglin is idle with nowhere to go, it walks away from it.
---
 crates/horizon-client/src/mobs.rs        |  3 +
 crates/horizon-client/src/mobs/piglin.rs | 71 +++++++++++++++++++++++-
 crates/horizon-client/src/mobs/world.rs  | 29 ++++++++++
 3 files changed, 102 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..bf42bc587 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -709,6 +709,9 @@ pub struct Extra {
     /// A copper golem's `openedChestPos`.
     pub opened_chest: Option<[i32; 3]>,
     pub point: Option<[f64; 3]>,
+    /// `NEAREST_REPELLENT`: the nearest repelling block a hoglin or piglin
+    /// sensed, looked up every 20 ticks.
+    pub repellent: Option<[i32; 3]>,
     pub vector: [f64; 3],
     /// Active status effects: (effect id, ticks left, amplifier).
     pub effects: Vec<(&'static str, i32, i32)>,
diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs
index 410364097..2c92ecd0a 100644
--- a/crates/horizon-client/src/mobs/piglin.rs
+++ b/crates/horizon-client/src/mobs/piglin.rs
@@ -9,7 +9,7 @@ use super::{
         NearestTarget, Prey, RandomLookAround, Stroll, goal_clone,
     },
 };
-use horizon_core::geometry::trig::Mth;
+use horizon_core::geometry::{Vec3, trig::Mth};
 use horizon_core::random::RandomSource;
 use std::f32::consts::PI;
 
@@ -45,6 +45,7 @@ pub fn register_piglin(m: &mut Mob) {
         g.add(3, super::illager::crossbow_goal(1.0, 8.0));
     }
     g.add(3, MeleeAttack::new(1.0, true));
+    g.add(4, PiglinAvoidRepellent);
     g.add(4, GoToWantedItem);
     g.add(5, Stroll::avoiding_water(0.6));
     g.add(6, LookAtPlayer::new(8.0));
@@ -129,6 +130,54 @@ impl Goal for BabyPanic {
         self.0.stop(m, cx)
     }
 }
+/// `PiglinAi.avoidRepellent`: `SetWalkTargetAwayFrom.pos(NEAREST_REPELLENT, 1.0, 8, false)`
+/// of the idle activity. Closer than 8 blocks to a repellent and not walking
+/// anywhere, walk away from it.
+#[derive(Clone, Debug)]
+struct PiglinAvoidRepellent;
+impl Goal for PiglinAvoidRepellent {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        MOVE
+    }
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        let Some(r) = m.extra.repellent else {
+            return false;
+        };
+        // The idle activity: not fighting or admiring, and no walk target yet.
+        if m.ai.target.is_some() || m.extra.using_item > 0 || !m.ai.nav.is_done() {
+            return false;
+        }
+        // Vec3.atBottomCenterOf.
+        let avoid = [
+            f64::from(r[0]) + 0.5,
+            f64::from(r[1]),
+            f64::from(r[2]) + 0.5,
+        ];
+        if m.distance_sqr(Vec3::new(avoid[0], avoid[1], avoid[2])) >= 64.0 {
+            return false;
+        }
+        for _ in 0..10 {
+            if let Some(p) = m.land_random_pos_away(cx.w, 16, 7, avoid) {
+                let at = [
+                    p[0].floor() as i32,
+                    p[1].floor() as i32,
+                    p[2].floor() as i32,
+                ];
+                m.ai.pending_path = m.create_path_to(cx.w, at, 0);
+                return m.ai.pending_path.is_some();
+            }
+        }
+        false
+    }
+    fn can_continue(&mut self, m: &mut Mob, _: &mut Cx) -> bool {
+        !m.ai.nav.is_done()
+    }
+    fn start(&mut self, m: &mut Mob, _: &mut Cx) {
+        let path = m.ai.pending_path.take();
+        m.nav_move_to_path(path, 1.0);
+    }
+}
 /// Admiring a gold item held in the off hand: stand and look at it.
 #[derive(Clone, Debug)]
 struct Admire;
@@ -219,6 +268,26 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     } else {
         m.extra.counter2 = 0;
     }
+    // PiglinSpecificSensor (every 20 ticks): the nearest repelling block.
+    if m.species() == Species::Piglin && m.alive() && m.age.wrapping_add(m.id) % 20 == 0 {
+        m.extra.repellent = find_repellent(m, w);
+    }
+}
+/// `PiglinSpecificSensor.findNearestRepellent`: the nearest `#piglin_repellents`
+/// block within 8 blocks sideways and 4 up or down; a soul campfire only
+/// counts while lit.
+fn find_repellent(m: &Mob, w: &MobWorld) -> Option<[i32; 3]> {
+    let tag = w.block_tags.get("minecraft:piglin_repellents")?;
+    let at = [
+        m.position.x.floor() as i32,
+        m.position.y.floor() as i32,
+        m.position.z.floor() as i32,
+    ];
+    w.nearest_block(at, 8, 4, |p, name| {
+        tag.contains(name)
+            && (name != "minecraft:soul_campfire"
+                || w.prop(p[0], p[1], p[2], "lit") == Some("true"))
+    })
 }
 /// `HoglinBase.hurtAndThrowTarget`.
 pub fn hoglin_hurt_target(m: &mut Mob, who: Who, cx: &mut Cx) {
diff --git a/crates/horizon-client/src/mobs/world.rs b/crates/horizon-client/src/mobs/world.rs
index 7836a49ef..aa665decc 100644
--- a/crates/horizon-client/src/mobs/world.rs
+++ b/crates/horizon-client/src/mobs/world.rs
@@ -65,6 +65,35 @@ impl MobWorld<'_> {
     pub fn has_tag(&self, tag: &str, block: &str) -> bool {
         self.block_tags.get(tag).is_some_and(|s| s.contains(block))
     }
+    /// `findBlocksInBoxByManhattanDistance(at, range_xz, range_y).filterState(..).findFirst()`:
+    /// the first block `matches` accepts (given its position and name), going
+    /// out from `at` by Manhattan distance as `BlockPos.withinBoxByManhattanDistance` does.
+    pub fn nearest_block(
+        &self,
+        at: [i32; 3],
+        range_xz: i32,
+        range_y: i32,
+        matches: impl Fn([i32; 3], &str) -> bool,
+    ) -> Option<[i32; 3]> {
+        // Visiting order: distance, then x, then y, then +z before -z.
+        let mut best: Option<((i32, i32, i32, bool), [i32; 3])> = None;
+        for dx in -range_xz..=range_xz {
+            for dy in -range_y..=range_y {
+                for dz in -range_xz..=range_xz {
+                    let key = (dx.abs() + dy.abs() + dz.abs(), dx, dy, dz < 0);
+                    if best.is_some_and(|(k, _)| k <= key) {
+                        continue;
+                    }
+                    let p = [at[0] + dx, at[1] + dy, at[2] + dz];
+                    let state = self.world.block(p[0], p[1], p[2]);
+                    if !self.facts.is_air(state) && matches(p, &self.facts.get(state).name) {
+                        best = Some((key, p));
+                    }
+                }
+            }
+        }
+        best.map(|(_, p)| p)
+    }
     /// Level.clip with COLLIDER shapes (optionally stopping at any fluid): true on a miss.
     pub fn clear_between(&self, from: Vec3, to: Vec3, fluids_block: bool) -> bool {
         let mut scene = SceneCollisions {

From ee19d2c00cb0eb34cb33e2803c4208edd3bd35c2 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:33:48 +0100
Subject: [PATCH 060/475] Experience orbs: wider pickup area, merging, and lava
 bounce

---
 crates/horizon-client/src/entities.rs      | 66 ++++++++++++++++++---
 crates/horizon-client/src/entity_nbt.rs    | 20 ++++---
 crates/horizon-client/src/game.rs          | 68 ++++++++++++++++++----
 crates/horizon-client/src/game/commands.rs |  2 +
 crates/horizon-client/src/game/pickups.rs  |  2 +
 crates/horizon-client/src/game/remote.rs   |  2 +
 crates/horizon-client/src/game/spill.rs    | 12 ++--
 7 files changed, 139 insertions(+), 33 deletions(-)

diff --git a/crates/horizon-client/src/entities.rs b/crates/horizon-client/src/entities.rs
index 6e8089e9d..7454fc863 100644
--- a/crates/horizon-client/src/entities.rs
+++ b/crates/horizon-client/src/entities.rs
@@ -385,8 +385,29 @@ pub struct ExperienceOrb {
     pub value: u32,
     pub age: u32,
     pub on_ground: bool,
+    /// `ExperienceOrb.count`: orbs merged into this one; each pickup gives
+    /// `value` once and takes one off.
+    pub count: u32,
+    /// `Entity.tickCount`, which paces `ExperienceOrb.scanForMerges`.
+    pub ticks: u32,
 }
 impl ExperienceOrb {
+    pub fn bounds(&self) -> Aabb {
+        let h = 0.25;
+        Aabb::new(
+            Vec3::new(self.position.x - h, self.position.y, self.position.z - h),
+            Vec3::new(
+                self.position.x + h,
+                self.position.y + 0.5,
+                self.position.z + h,
+            ),
+        )
+    }
+    /// `ExperienceOrb.canMerge(orb, id, value)` for an orb that is not removed:
+    /// the same value and ids a multiple of 40 apart.
+    pub fn can_merge(&self, id: u32, value: u32) -> bool {
+        self.value == value && (self.id as i32).wrapping_sub(id as i32) % 40 == 0
+    }
     /// ExperienceOrb.getExperienceValue: the largest orb size not above `value`.
     pub fn split(value: u32) -> u32 {
         [2477, 1237, 617, 307, 149, 73, 37, 17, 7, 3, 1]
@@ -416,7 +437,9 @@ impl ExperienceOrb {
         facts: &BlockFacts,
         collision: &BlockCollisionRegistry<'_>,
         player: Option<[f64; 3]>,
+        next_float: &mut dyn FnMut() -> f32,
     ) -> bool {
+        self.ticks += 1;
         self.previous = self.position;
         let block = world.block(
             self.position.x.floor() as i32,
@@ -432,6 +455,14 @@ impl ExperienceOrb {
         } else {
             self.velocity.y -= 0.03;
         }
+        if facts.get(block).fluid == Fluid::Lava {
+            // ExperienceOrb.tick: lava throws the orb back out.
+            self.velocity = Vec3::new(
+                f64::from((next_float() - next_float()) * 0.2),
+                f64::from(0.2f32),
+                f64::from((next_float() - next_float()) * 0.2),
+            );
+        }
         if let Some(p) = player {
             let d = [
                 (p[0] - self.position.x) / 8.0,
@@ -449,15 +480,7 @@ impl ExperienceOrb {
                 );
             }
         }
-        let h = 0.25;
-        let bounds = Aabb::new(
-            Vec3::new(self.position.x - h, self.position.y, self.position.z - h),
-            Vec3::new(
-                self.position.x + h,
-                self.position.y + 0.5,
-                self.position.z + h,
-            ),
-        );
+        let bounds = self.bounds();
         let mut scene = SceneCollisions {
             world,
             binding: collision,
@@ -494,6 +517,31 @@ impl ExperienceOrb {
         self.age < 6000
     }
 }
+/// `ExperienceOrb.scanForMerges`, run by each orb on `tickCount % 20 == 1`:
+/// it absorbs the orbs that `canMerge` within 0.5 blocks of its box,
+/// adding their counts and keeping the smaller age.
+pub fn merge_orbs(orbs: &mut Vec<ExperienceOrb>) {
+    let mut removed = vec![false; orbs.len()];
+    for i in 0..orbs.len() {
+        if removed[i] || orbs[i].ticks % 20 != 1 {
+            continue;
+        }
+        let area = orbs[i].bounds().inflate(Vec3::new(0.5, 0.5, 0.5));
+        for j in 0..orbs.len() {
+            if j != i
+                && !removed[j]
+                && orbs[j].can_merge(orbs[i].id, orbs[i].value)
+                && orbs[j].bounds().intersects(area)
+            {
+                orbs[i].count += orbs[j].count;
+                orbs[i].age = orbs[i].age.min(orbs[j].age);
+                removed[j] = true;
+            }
+        }
+    }
+    let mut removed = removed.into_iter();
+    orbs.retain(|_| !removed.next().unwrap_or(false));
+}
 /// Player experience (Player.giveExperiencePoints / getXpNeededForNextLevel).
 #[derive(Clone, Copy, Debug, Default)]
 pub struct Experience {
diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 00576ea02..930ab568b 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -1043,18 +1043,18 @@ pub fn orb_to_nbt(o: &ExperienceOrb, uuid: [i32; 4]) -> Tag {
         ("Health", Tag::Short(5)),
         ("Age", Tag::Short(o.age.min(i16::MAX as u32) as i16)),
         ("Value", Tag::Short(o.value.min(i16::MAX as u32) as i16)),
-        ("Count", Tag::Int(1)),
+        ("Count", Tag::Int(o.count.min(i32::MAX as u32) as i32)),
     ] {
         put(&mut tag, key, value);
     }
     tag
 }
-/// One Horizon orb per counted orb (vanilla merges orbs of equal value).
+/// One orb with its merged `Count`.
 pub fn orbs_from_nbt(tag: &Tag) -> Vec<ExperienceOrb> {
     let Some(position) = position(tag) else {
         return Vec::new();
     };
-    let count = number(tag.get("Count")).unwrap_or(1).clamp(1, 64) as usize;
+    let count = number(tag.get("Count")).unwrap_or(1).max(1) as u32;
     let orb = ExperienceOrb {
         id: 0,
         position,
@@ -1063,8 +1063,10 @@ pub fn orbs_from_nbt(tag: &Tag) -> Vec<ExperienceOrb> {
         value: number(tag.get("Value")).unwrap_or(1).max(1) as u32,
         age: number(tag.get("Age")).unwrap_or(0).max(0) as u32,
         on_ground: flag(tag, "OnGround"),
+        count,
+        ticks: 0,
     };
-    vec![orb; count]
+    vec![orb]
 }
 
 /// `Projectile` + `AbstractArrow.addAdditionalSaveData` of a live arrow;
@@ -1840,7 +1842,7 @@ mod tests {
         assert_eq!(number(tag.get("Health")), Some(5));
     }
     #[test]
-    fn orbs_expand_their_count() {
+    fn orbs_keep_their_count() {
         let o = ExperienceOrb {
             id: 0,
             position: Vec3::new(1.0, 2.0, 3.0),
@@ -1849,12 +1851,14 @@ mod tests {
             value: 7,
             age: 3,
             on_ground: false,
+            count: 3,
+            ticks: 0,
         };
-        let mut tag = orb_to_nbt(&o, [0; 4]);
-        put(&mut tag, "Count", Tag::Int(3));
+        let tag = orb_to_nbt(&o, [0; 4]);
         let back = orbs_from_nbt(&tag);
-        assert_eq!(back.len(), 3);
+        assert_eq!(back.len(), 1);
         assert_eq!(back[0].value, 7);
+        assert_eq!(back[0].count, 3);
     }
 }
 
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 5760ffbe7..715b3a5f1 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -8905,8 +8905,29 @@ impl Game<'_> {
         while value > 0 {
             let v = ExperienceOrb::split(value);
             value -= v;
-            let _merge_id = self.world.random.next_int_bound(40);
-            self.add_orb(at, v);
+            let merge_id = self.world.random.next_int_bound(40).unwrap_or(0);
+            self.award_orb(at, v, merge_id);
+        }
+    }
+    /// `ExperienceOrb.tryMergeToExisting`: an orb of the same value within a
+    /// 1 block box of `at`, whose id is a multiple of 40 from `merge_id`, takes
+    /// the new one as one more in its count (and restarts its age); otherwise
+    /// a fresh orb spawns.
+    fn award_orb(&mut self, at: [f64; 3], value: u32, merge_id: i32) {
+        let centre = Vec3::new(at[0], at[1], at[2]);
+        let half = Vec3::new(0.5, 0.5, 0.5);
+        let area = Aabb::new(centre.subtract(half), centre.add_vector(half));
+        // A server's orbs are its own; a LAN or server guest only shows them.
+        let target = self.remote.is_none().then(|| {
+            self.orbs
+                .iter_mut()
+                .find(|o| o.can_merge(merge_id as u32, value) && o.bounds().intersects(area))
+        });
+        if let Some(Some(orb)) = target {
+            orb.count += 1;
+            orb.age = 0;
+        } else {
+            self.add_orb(at, value);
         }
     }
     /// `new ExperienceOrb(level, pos, Vec3.ZERO, value)`: yaw and motion from
@@ -8928,6 +8949,8 @@ impl Game<'_> {
             value,
             age: 0,
             on_ground: false,
+            count: 1,
+            ticks: 0,
         });
     }
     fn can_place_used_fire(&mut self, target: [i32; 3]) -> bool {
@@ -9004,18 +9027,31 @@ impl Game<'_> {
                     }),
             );
         }
+        // Player.aiStep: the pickup area is the box inflated by (1, 0.5, 1).
         let bounds = player.map(|p| {
             let w = f64::from(p.dimensions.width) / 2.0;
             (
-                [p.position.x - w, p.position.y, p.position.z - w],
                 [
-                    p.position.x + w,
-                    p.position.y + f64::from(p.dimensions.height),
-                    p.position.z + w,
+                    p.position.x - w - 1.0,
+                    p.position.y - 0.5,
+                    p.position.z - w - 1.0,
+                ],
+                [
+                    p.position.x + w + 1.0,
+                    p.position.y + f64::from(p.dimensions.height) + 0.5,
+                    p.position.z + w + 1.0,
                 ],
             )
         });
         let mut orbs = std::mem::take(&mut self.orbs);
+        // An orb has no random of its own here: lava draws from one made on
+        // first use, apart from the level stream.
+        let mut lava_random = None;
+        let mut next_float = || {
+            lava_random
+                .get_or_insert_with(dispenser::entity_random)
+                .next_float()
+        };
         orbs.retain_mut(|o| {
             let distance = |feet: &[f64; 3]| -> f64 {
                 (feet[0] - o.position.x).powi(2)
@@ -9027,12 +9063,22 @@ impl Game<'_> {
                 .filter(|(feet, _)| distance(feet) < 64.0)
                 .min_by(|a, b| distance(&a.0).total_cmp(&distance(&b.0)))
                 .map(|(_, target)| *target);
-            o.tick(&self.world, self.res.facts(), self.collision, target)
+            o.tick(
+                &self.world,
+                self.res.facts(),
+                self.collision,
+                target,
+                &mut next_float,
+            )
         });
+        // ExperienceOrb.scanForMerges runs on the server only.
+        if self.remote.is_none() {
+            horizon_client::entities::merge_orbs(&mut orbs);
+        }
         let mut gained = 0;
         let mut taken = Vec::new();
         if let Some((min, max)) = bounds {
-            orbs.retain(|o| {
+            orbs.retain_mut(|o| {
                 let touching = o.position.x + 0.25 > min[0]
                     && o.position.x - 0.25 < max[0]
                     && o.position.y + 0.5 > min[1]
@@ -9040,11 +9086,13 @@ impl Game<'_> {
                     && o.position.z + 0.25 > min[2]
                     && o.position.z - 0.25 < max[2];
                 if touching && self.xp_delay == 0 {
-                    // ExperienceOrb.playerTouch: one orb every 2 ticks.
+                    // ExperienceOrb.playerTouch: one orb every 2 ticks; a
+                    // merged orb gives its value once per count.
                     self.xp_delay = 2;
                     gained += o.value;
                     taken.push(o.clone());
-                    return false;
+                    o.count -= 1;
+                    return o.count > 0;
                 }
                 true
             });
diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs
index f3afdcab6..57501b8fe 100644
--- a/crates/horizon-client/src/game/commands.rs
+++ b/crates/horizon-client/src/game/commands.rs
@@ -1682,6 +1682,8 @@ impl Game<'_> {
                         value: 0,
                         age: 0,
                         on_ground: false,
+                        count: 1,
+                        ticks: 0,
                     });
                     name = Text::translate("entity.minecraft.experience_orb", &[]);
                 }
diff --git a/crates/horizon-client/src/game/pickups.rs b/crates/horizon-client/src/game/pickups.rs
index 1e19bcfc3..040a6f01b 100644
--- a/crates/horizon-client/src/game/pickups.rs
+++ b/crates/horizon-client/src/game/pickups.rs
@@ -155,6 +155,8 @@ mod tests {
             value: 1,
             age: 0,
             on_ground: false,
+            count: 1,
+            ticks: 0,
         }))
     }
 
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 38f4ebbad..3293b0690 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -1269,6 +1269,8 @@ impl Game<'_> {
                 value: 1,
                 age: 0,
                 on_ground: false,
+                count: 1,
+                ticks: 0,
             });
         }
         if let Some(t) = mob_type {
diff --git a/crates/horizon-client/src/game/spill.rs b/crates/horizon-client/src/game/spill.rs
index b7283c57b..cc54d127c 100644
--- a/crates/horizon-client/src/game/spill.rs
+++ b/crates/horizon-client/src/game/spill.rs
@@ -171,8 +171,8 @@ pub(super) struct Spawn {
 pub(super) struct Spill {
     pub(super) spawns: Vec<Spawn>,
     /// Experience orbs (`ExperienceOrb.award`): where and how much, each
-    /// having drawn its merge id from the level random.
-    pub(super) orbs: Vec<([f64; 3], u32)>,
+    /// and the merge id it drew from the level random.
+    pub(super) orbs: Vec<([f64; 3], u32, i32)>,
     /// Block entities the behaviour removed, for the game's own follow-ups
     /// (open screens, playing songs).
     pub(super) removed: Vec<([i32; 3], BlockEntity)>,
@@ -342,8 +342,8 @@ impl GameLevel<'_> {
         while amount > 0 {
             let value = removal::orb_value(amount);
             amount -= value;
-            let _merge_id = self.world.random.next_int_bound(40);
-            self.spill.orbs.push((at, value));
+            let merge_id = self.world.random.next_int_bound(40).unwrap_or(0);
+            self.spill.orbs.push((at, value, merge_id));
         }
     }
     /// `BlockEntity.preRemoveSideEffects` and `removeBlockEntity` for the block
@@ -579,8 +579,8 @@ impl Game<'_> {
             let motion = s.motion.unwrap_or_else(new_item_motion);
             self.spawn_item(s.stack, s.pos, motion, s.delay);
         }
-        for (at, value) in spill.orbs {
-            self.add_orb(at, value);
+        for (at, value, merge_id) in spill.orbs {
+            self.award_orb(at, value, merge_id);
         }
         for (pos, entity) in spill.removed {
             let key = (pos[0], pos[1], pos[2]);

From c7bacfb2933ace0c7394feceb8947d36f2e37e18 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:35:50 +0100
Subject: [PATCH 061/475] Water buckets pick up fish and tadpoles, keeping
 their data

---
 crates/horizon-client/src/entity_nbt.rs     | 93 +++++++++++++++++++--
 crates/horizon-client/src/game/creatures.rs | 37 ++++++--
 2 files changed, 117 insertions(+), 13 deletions(-)

diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 00576ea02..bdf89195d 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -1919,12 +1919,39 @@ fn restore_axolotl_memories(m: &mut Mob, tag: &Tag) {
     }
 }
 const AXOLOTL_VARIANTS: [&str; 5] = ["lucy", "wild", "gold", "cyan", "blue"];
+/// `Salmon.Variant` names, by id.
+const SALMON_SIZES: [&str; 3] = ["small", "medium", "large"];
+/// `TropicalFish.Pattern` names in enum order: the six small patterns, then
+/// the six large ones (the order of `extra.variant`).
+const TROPICAL_PATTERNS: [&str; 12] = [
+    "kob",
+    "sunstreak",
+    "snooper",
+    "dasher",
+    "brinely",
+    "spotty",
+    "flopper",
+    "stripey",
+    "glitter",
+    "blockfish",
+    "betty",
+    "clayfish",
+];
+/// `Bucketable.saveDefaultDataToBucketTag`, with the age an axolotl and a
+/// tadpole add (`saveToBucketTag`).
 pub fn bucket_data(m: &Mob) -> Tag {
-    let mut data = Tag::compound([
-        ("Age", Tag::Int(m.extra.age)),
-        ("AgeLocked", Tag::Byte(i8::from(m.extra.age_locked))),
-        ("Health", Tag::Float(m.health.to_bits())),
-    ]);
+    let mut data = Tag::compound([("Health", Tag::Float(m.health.to_bits()))]);
+    if matches!(
+        m.species(),
+        crate::mobs::Species::Axolotl | crate::mobs::Species::Tadpole
+    ) {
+        put(&mut data, "Age", Tag::Int(m.extra.age));
+        put(
+            &mut data,
+            "AgeLocked",
+            Tag::Byte(i8::from(m.extra.age_locked)),
+        );
+    }
     for (key, on) in [
         ("NoAI", m.no_ai),
         ("Silent", m.silent),
@@ -1954,6 +1981,29 @@ pub fn bucket_components(m: &Mob) -> crate::item_data::StackData {
             .unwrap_or(&"lucy");
         data.set_other("minecraft:axolotl/variant", Some(string(variant)));
     }
+    // Salmon.saveToBucketTag: the size.
+    if m.species() == crate::mobs::Species::Salmon {
+        let size = SALMON_SIZES
+            .get(usize::from(m.extra.variant))
+            .unwrap_or(&"medium");
+        data.set_other("minecraft:salmon/size", Some(string(size)));
+    }
+    // TropicalFish.saveToBucketTag: the pattern and both colours.
+    if m.species() == crate::mobs::Species::TropicalFish {
+        let dye = |i: u8| crate::mobs::render::DYE_NAMES[usize::from(i) & 15];
+        let pattern = TROPICAL_PATTERNS
+            .get(usize::from(m.extra.variant))
+            .unwrap_or(&"kob");
+        data.set_other("minecraft:tropical_fish/pattern", Some(string(pattern)));
+        data.set_other(
+            "minecraft:tropical_fish/base_color",
+            Some(string(dye(m.extra.variant2))),
+        );
+        data.set_other(
+            "minecraft:tropical_fish/pattern_color",
+            Some(string(dye(m.extra.variant3))),
+        );
+    }
     data
 }
 pub fn load_bucket_data(m: &mut Mob, stack: &crate::items::ItemStack) {
@@ -2004,6 +2054,39 @@ pub fn load_bucket_data(m: &mut Mob, stack: &crate::items::ItemStack) {
     {
         m.extra.variant = id as u8;
     }
+    // Salmon.applyImplicitComponents: the size.
+    if m.species() == crate::mobs::Species::Salmon
+        && let Some(name) = text(components.other("minecraft:salmon/size"))
+        && let Some(id) = SALMON_SIZES
+            .iter()
+            .position(|&v| v == name.trim_start_matches("minecraft:"))
+    {
+        m.extra.variant = id as u8;
+    }
+    // TropicalFish.applyImplicitComponent: the pattern and both colours.
+    if m.species() == crate::mobs::Species::TropicalFish {
+        let name = |key| text(components.other(key));
+        let dye = |key| {
+            name(key).and_then(|n| {
+                crate::mobs::render::DYE_NAMES
+                    .iter()
+                    .position(|&v| v == n.trim_start_matches("minecraft:"))
+            })
+        };
+        if let Some(id) = name("minecraft:tropical_fish/pattern").and_then(|n| {
+            TROPICAL_PATTERNS
+                .iter()
+                .position(|&v| v == n.trim_start_matches("minecraft:"))
+        }) {
+            m.extra.variant = id as u8;
+        }
+        if let Some(id) = dye("minecraft:tropical_fish/base_color") {
+            m.extra.variant2 = id as u8;
+        }
+        if let Some(id) = dye("minecraft:tropical_fish/pattern_color") {
+            m.extra.variant3 = id as u8;
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..05e83432d 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2459,21 +2459,22 @@ impl Game<'_> {
             .as_ref()
             .map(|h| h.item.to_string())
             .unwrap_or_default();
+        // Bucketable.bucketMobPickup: a water bucket scoops up a fish, a
+        // tadpole or an axolotl, with the data its bucket carries.
         if item == "minecraft:water_bucket"
-            && self.mobs[index].species() == Species::Axolotl
             && self.mobs[index].alive()
+            && let Some((bucket, sound)) = bucketable(self.mobs[index].species())
         {
-            let mut filled = ItemStack::new("minecraft:axolotl_bucket", 1);
+            let mut filled = ItemStack::new(bucket, 1);
             filled.extra = Some(Box::new(horizon_client::entity_nbt::bucket_components(
                 &self.mobs[index],
             )));
-            self.audio.play(
-                "minecraft:item.bucket.fill_axolotl",
-                Some(self.mobs[index].center()),
-                1.0,
-                1.0,
-            );
+            self.audio
+                .play(sound, Some(self.mobs[index].center()), 1.0, 1.0);
             self.trigger_item("minecraft:filled_bucket", &filled);
+            // Leashable.dropLeash, then discard.
+            let id = self.mobs[index].id;
+            self.break_leash(id, true, false);
             self.mobs[index].removed = true;
             if self.creative {
                 if let Some(rest) = self.give(filled) {
@@ -3253,6 +3254,26 @@ impl Game<'_> {
         }
     }
 }
+/// `Bucketable.getBucketItemStack` and `getPickupSound` of a mob that a water
+/// bucket picks up.
+fn bucketable(species: Species) -> Option<(&'static str, &'static str)> {
+    let fish = "minecraft:item.bucket.fill_fish";
+    Some(match species {
+        Species::Cod => ("minecraft:cod_bucket", fish),
+        Species::Salmon => ("minecraft:salmon_bucket", fish),
+        Species::Pufferfish => ("minecraft:pufferfish_bucket", fish),
+        Species::TropicalFish => ("minecraft:tropical_fish_bucket", fish),
+        Species::Tadpole => (
+            "minecraft:tadpole_bucket",
+            "minecraft:item.bucket.fill_tadpole",
+        ),
+        Species::Axolotl => (
+            "minecraft:axolotl_bucket",
+            "minecraft:item.bucket.fill_axolotl",
+        ),
+        _ => return None,
+    })
+}
 /// Mob.getBaseExperienceReward
 /// The damage type id of a Horizon damage kind.
 pub(super) fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool) -> &'static str {

From 628ff01a44d74c43c2e0a2db4afbec532f4fab95 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:35:52 +0100
Subject: [PATCH 062/475] Only zombies that break doors and raiding vindicators
 get through doors

Mobs no longer open or break doors on their own except villagers and copper
golems. Zombies that rolled canBreakDoors break doors on hard, and
vindicators break doors on normal and hard and open them during a raid, as
BreakDoorGoal, VindicatorBreakDoorGoal and RaiderOpenDoorGoal do. A zombie's
CanBreakDoors value is now saved and loaded.
---
 crates/horizon-client/src/entity_nbt.rs     |  12 +-
 crates/horizon-client/src/game.rs           |  10 +-
 crates/horizon-client/src/game/creatures.rs |  15 ++
 crates/horizon-client/src/game/raids.rs     |   2 +
 crates/horizon-client/src/mobs.rs           |  19 ++
 crates/horizon-client/src/mobs/ai.rs        |   1 +
 crates/horizon-client/src/mobs/doors.rs     | 252 ++++++++++++++++++++
 crates/horizon-client/src/mobs/finalize.rs  |   5 +-
 crates/horizon-client/src/mobs/illager.rs   |   9 +
 crates/horizon-client/src/mobs/raider.rs    |   3 +
 crates/horizon-client/src/mobs/spawning.rs  |   5 +
 crates/horizon-client/src/mobs/undead.rs    |   4 +
 12 files changed, 333 insertions(+), 4 deletions(-)
 create mode 100644 crates/horizon-client/src/mobs/doors.rs

diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 00576ea02..ba0a62489 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -482,7 +482,6 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         "minecraft:zombie" => {
             map.insert("IsBaby".into(), Tag::Byte(i8::from(m.is_baby())));
             for (key, value) in [
-                ("CanBreakDoors", Tag::Byte(0)),
                 ("DrownedConversionTime", Tag::Int(-1)),
                 ("InWaterTime", Tag::Int(-1)),
             ] {
@@ -507,6 +506,13 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         }
         _ => {}
     }
+    // Zombie.addAdditionalSaveData: CanBreakDoors.
+    if crate::mobs::doors::is_zombie(m.species()) {
+        map.insert(
+            "CanBreakDoors".into(),
+            Tag::Byte(i8::from(m.extra.can_break_doors)),
+        );
+    }
     crate::mobs::raider::write_nbt(m, map);
     crate::mobs::riders::write_nbt(m, map);
     // LivingEntity equipment: what the mob holds now.
@@ -925,6 +931,10 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     if !crate::mobs::finalize::ageable(m.species()) && flag(tag, "IsBaby") {
         crate::mobs::finalize::set_baby(&mut m, true);
     }
+    // Zombie.readAdditionalSaveData: setCanBreakDoors.
+    if crate::mobs::doors::is_zombie(m.species()) {
+        crate::mobs::doors::set_can_break_doors(&mut m, flag(tag, "CanBreakDoors"));
+    }
     crate::mobs::raider::read_nbt(&mut m, tag);
     crate::mobs::riders::read_nbt(&mut m, tag);
     // A mob saved mid-death finishes dying; one saved dead is dropped.
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 5760ffbe7..a3400f252 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2817,6 +2817,9 @@ impl Game<'_> {
                         1501 => Some(("minecraft:block.lava.extinguish", 0.5)),
                         1009 => Some(("minecraft:block.fire.extinguish", 0.5)),
                         1502 => Some(("minecraft:block.redstone_torch.burnout", 0.5)),
+                        // LevelEvent.SOUND_ZOMBIE_WOODEN_DOOR (attack, break).
+                        1019 => Some(("minecraft:entity.zombie.attack_wooden_door", 2.0)),
+                        1021 => Some(("minecraft:entity.zombie.break_wooden_door", 2.0)),
                         1030 => Some(("minecraft:block.anvil.use", 1.0)),
                         1029 => Some(("minecraft:block.anvil.destroy", 1.0)),
                         1031 => Some(("minecraft:block.anvil.land", 0.3)),
@@ -2836,9 +2839,14 @@ impl Game<'_> {
                             1029 | 1030 | 1042 | 1043 | 1044 => {
                                 self.world.random.next_float() * 0.1 + 0.9
                             }
+                            1019 | 1021 => {
+                                (self.world.random.next_float() - self.world.random.next_float())
+                                    * 0.2
+                                    + 1.0
+                            }
                             _ => 1.0,
                         };
-                        if matches!(id, 1029 | 1030) {
+                        if matches!(id, 1019 | 1021 | 1029 | 1030) {
                             // Clients play the anvil sound from its level event;
                             // capturing it also sends a duplicate sound packet.
                             self.audio.play_unshared(name, c, volume, pitch);
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..4613ad5f7 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1043,6 +1043,21 @@ impl Game<'_> {
                     self.with_level(|b, level, ticks| b.set_door_open(level, ticks, pos, open));
                     self.process_level_events()?;
                 }
+                MobEvent::BreakDoor { pos } => {
+                    // BreakDoorGoal.tick: removeBlock, then level events 1021
+                    // and 2001 with the state that is there now.
+                    let air = self.world.air;
+                    let at = BlockPos::new(pos[0], pos[1], pos[2]);
+                    self.with_level(|b, level, ticks| b.set_block(level, ticks, at, air, 3));
+                    self.process_level_events()?;
+                    self.level_event_at(1021, pos, 0);
+                    let left = self.world.block(pos[0], pos[1], pos[2]);
+                    self.level_event_at(2001, pos, left.0 as i32);
+                }
+                MobEvent::DestroyProgress { mob, pos, progress } => {
+                    self.destroy_block_progress(mob as i32, pos, progress);
+                }
+                MobEvent::LevelEvent { id, pos, data } => self.level_event_at(id, pos, data),
                 MobEvent::SetBlockName { pos, name, effect } => {
                     if effect {
                         let old = self.world.block(pos[0], pos[1], pos[2]);
diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs
index bedca5708..743f02f44 100644
--- a/crates/horizon-client/src/game/raids.rs
+++ b/crates/horizon-client/src/game/raids.rs
@@ -796,6 +796,8 @@ impl Game<'_> {
             let s = m.extra.raider.get_or_insert_with(Box::default);
             s.rider = has_rider;
             s.in_village = in_village;
+            // Vindicator.customServerAiStep: `ServerLevel.isRaided`.
+            s.raided = species == Species::Vindicator && raids.nearby(block).is_some();
             if s.raid_id.is_some_and(|id| raids.get(id).is_none()) {
                 s.raid_id = None;
                 s.ticks_outside_raid = 0;
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..1d7f337e1 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -25,6 +25,7 @@ pub mod creaking;
 pub mod creaking_heart;
 pub mod cube;
 pub mod data;
+pub mod doors;
 pub mod drops;
 pub mod enderman;
 pub mod equine;
@@ -1001,6 +1002,24 @@ pub enum MobEvent {
         pos: [i32; 3],
         open: bool,
     },
+    /// `BreakDoorGoal.tick` at its end: the door is removed (`removeBlock`),
+    /// then level events 1021 and 2001 with the state that is left there.
+    BreakDoor {
+        pos: [i32; 3],
+    },
+    /// `Level.destroyBlockProgress` for a mob's crack on a block (`-1`
+    /// clears it).
+    DestroyProgress {
+        mob: u32,
+        pos: [i32; 3],
+        progress: i32,
+    },
+    /// `Level.levelEvent`: the game plays and sends the event.
+    LevelEvent {
+        id: i32,
+        pos: [i32; 3],
+        data: i32,
+    },
     /// Destroy a block, dropping nothing (sheep eating grass becomes dirt via SetBlock).
     BreakBlock {
         pos: [i32; 3],
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 8335cb745..d5eb76202 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -944,6 +944,7 @@ fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) {
         | Species::Parched
         | Species::WitherSkeleton
         | Species::ZombifiedPiglin => undead::custom_server_ai_step(m, cx),
+        Species::Vindicator => super::illager::vindicator_server_ai_step(m),
         Species::Enderman => super::enderman::custom_server_ai_step(m, cx),
         Species::Blaze => super::nether::blaze_server_ai_step(m, cx),
         Species::ElderGuardian => super::guardian::elder_server_ai_step(m, cx),
diff --git a/crates/horizon-client/src/mobs/doors.rs b/crates/horizon-client/src/mobs/doors.rs
new file mode 100644
index 000000000..a55ab9863
--- /dev/null
+++ b/crates/horizon-client/src/mobs/doors.rs
@@ -0,0 +1,252 @@
+//! Doors a mob gets through on its own: `DoorInteractGoal` with its two
+//! users, `BreakDoorGoal` (zombies that can break doors, vindicators in a
+//! raid) and `OpenDoorGoal` (`AbstractIllager.RaiderOpenDoorGoal`).
+use super::{
+    Mob, MobEvent, MobWorld, Species,
+    goals::{Cx, Goal, MOVE, goal_clone, reduced},
+    nav::NavKind,
+    raider,
+};
+use horizon_core::{geometry::Vec3, random::RandomSource};
+
+/// `DefaultDoorBreakTime`: `BreakDoorGoal.getDoorBreakTime` is
+/// `max(240, doorBreakTime)`, and the vindicator's 6 is below it.
+const DOOR_BREAK_TIME: i32 = 240;
+
+/// `GoalUtils.hasGroundPathNavigation`: ground, wall-climbing and
+/// amphibious navigations walk.
+pub fn can_navigate_ground(m: &Mob) -> bool {
+    matches!(
+        m.ai.nav.kind,
+        NavKind::Ground | NavKind::WallClimber | NavKind::Amphibious
+    )
+}
+/// `Zombie.setCanBreakDoors`: only a mob that walks can break doors, and
+/// then its navigation opens them.
+pub fn set_can_break_doors(m: &mut Mob, can_break: bool) {
+    let can_break = can_break && can_navigate_ground(m);
+    m.extra.can_break_doors = can_break;
+    m.ai.nav.can_open_doors = can_break;
+}
+/// The species that extend `Zombie` (`CanBreakDoors` is theirs to save).
+pub fn is_zombie(s: Species) -> bool {
+    matches!(
+        s,
+        Species::Zombie
+            | Species::Husk
+            | Species::Drowned
+            | Species::ZombieVillager
+            | Species::ZombifiedPiglin
+    )
+}
+/// `DoorBlock.isWoodenDoor`: a door a hand opens, which is any but iron.
+fn wooden_door(w: &MobWorld, p: [i32; 3]) -> bool {
+    let name = w.block_name(p[0], p[1], p[2]);
+    name.ends_with("_door") && name != "minecraft:iron_door"
+}
+/// `DoorInteractGoal`'s door: where it is and whether one is there.
+#[derive(Clone, Debug, Default)]
+struct Interact {
+    door: [i32; 3],
+    has_door: bool,
+}
+impl Interact {
+    /// `DoorInteractGoal.canUse`: the mob bumped into something and a
+    /// wooden door is on its path within 1.5 blocks, or at its own head.
+    fn can_use(&mut self, m: &Mob, w: &MobWorld) -> bool {
+        if !can_navigate_ground(m) || !m.horizontal_collision {
+            return false;
+        }
+        let Some(path) = m.ai.nav.path.as_ref().filter(|p| !p.is_done()) else {
+            return false;
+        };
+        for node in path
+            .nodes
+            .iter()
+            .take((path.next + 2).min(path.nodes.len()))
+        {
+            self.door = [node.x, node.y + 1, node.z];
+            let dx = m.position.x - f64::from(node.x);
+            let dz = m.position.z - f64::from(node.z);
+            if dx * dx + dz * dz <= 2.25 {
+                self.has_door = wooden_door(w, self.door);
+                if self.has_door {
+                    return true;
+                }
+            }
+        }
+        let at = m.position;
+        self.door = [
+            at.x.floor() as i32,
+            at.y.floor() as i32 + 1,
+            at.z.floor() as i32,
+        ];
+        self.has_door = wooden_door(w, self.door);
+        self.has_door
+    }
+    /// `DoorInteractGoal.isOpen`: the door is still there and open.
+    fn is_open(&mut self, w: &MobWorld) -> bool {
+        if !self.has_door {
+            return false;
+        }
+        let d = self.door;
+        if !w.block_name(d[0], d[1], d[2]).ends_with("_door") {
+            self.has_door = false;
+            return false;
+        }
+        w.prop(d[0], d[1], d[2], "open") == Some("true")
+    }
+    /// `DoorInteractGoal.setOpen`.
+    fn set_open(&self, cx: &mut Cx, open: bool) {
+        let d = self.door;
+        if self.has_door && cx.w.block_name(d[0], d[1], d[2]).ends_with("_door") {
+            cx.events.push(MobEvent::SetDoorOpen { pos: d, open });
+        }
+    }
+}
+/// `BlockPos.closerToCenterThan`.
+fn closer_to_center(p: [i32; 3], at: Vec3, distance: f64) -> bool {
+    Vec3::new(
+        f64::from(p[0]) + 0.5,
+        f64::from(p[1]) + 0.5,
+        f64::from(p[2]) + 0.5,
+    )
+    .distance_squared(at)
+        < distance * distance
+}
+
+/// `BreakDoorGoal`: crack the door in the way for 240 ticks, then remove it.
+/// A zombie does it on hard only; `Vindicator.VindicatorBreakDoorGoal` on
+/// normal and hard, in a raid, and holds the mob's movement.
+#[derive(Clone, Debug)]
+pub struct BreakDoor {
+    interact: Interact,
+    vindicator: bool,
+    break_time: i32,
+    last_break_progress: i32,
+}
+impl BreakDoor {
+    /// `Zombie.breakDoorGoal`, added when the zombie can break doors.
+    pub fn zombie() -> Self {
+        Self::new(false)
+    }
+    /// `Vindicator.VindicatorBreakDoorGoal`.
+    pub fn vindicator() -> Self {
+        Self::new(true)
+    }
+    fn new(vindicator: bool) -> Self {
+        Self {
+            interact: Interact::default(),
+            vindicator,
+            break_time: 0,
+            last_break_progress: -1,
+        }
+    }
+    /// `DOOR_BREAKING_PREDICATE`.
+    fn valid_difficulty(&self, w: &MobWorld) -> bool {
+        if self.vindicator {
+            w.difficulty.normal || w.difficulty.hard
+        } else {
+            w.difficulty.hard
+        }
+    }
+    /// `BreakDoorGoal.canUse` after `DoorInteractGoal.canUse`.
+    fn can_break(&mut self, m: &Mob, w: &MobWorld) -> bool {
+        self.interact.can_use(m, w)
+            && w.mob_griefing
+            && self.valid_difficulty(w)
+            && !self.interact.is_open(w)
+    }
+}
+impl Goal for BreakDoor {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        if self.vindicator { MOVE } else { 0 }
+    }
+    fn every_tick(&self) -> bool {
+        true
+    }
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        if self.vindicator {
+            return raider::has_active_raid(m)
+                && m.random.next_int_bound(reduced(10)).unwrap_or(1) == 0
+                && self.can_break(m, cx.w);
+        }
+        m.extra.can_break_doors && self.can_break(m, cx.w)
+    }
+    fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        (!self.vindicator || raider::has_active_raid(m))
+            && self.break_time <= DOOR_BREAK_TIME
+            && !self.interact.is_open(cx.w)
+            && closer_to_center(self.interact.door, m.position, 2.0)
+            && self.valid_difficulty(cx.w)
+    }
+    fn start(&mut self, m: &mut Mob, _cx: &mut Cx) {
+        self.break_time = 0;
+        if self.vindicator {
+            m.ai.no_action_time = 0;
+        }
+    }
+    fn stop(&mut self, m: &mut Mob, cx: &mut Cx) {
+        cx.events.push(MobEvent::DestroyProgress {
+            mob: m.id,
+            pos: self.interact.door,
+            progress: -1,
+        });
+    }
+    fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
+        let door = self.interact.door;
+        if m.random.next_int_bound(20).unwrap_or(1) == 0 {
+            cx.events.push(MobEvent::LevelEvent {
+                id: 1019,
+                pos: door,
+                data: 0,
+            });
+            if !m.ai.swinging {
+                m.swing();
+            }
+        }
+        self.break_time += 1;
+        let progress = (self.break_time as f32 / DOOR_BREAK_TIME as f32 * 10.0) as i32;
+        if progress != self.last_break_progress {
+            cx.events.push(MobEvent::DestroyProgress {
+                mob: m.id,
+                pos: door,
+                progress,
+            });
+            self.last_break_progress = progress;
+        }
+        if self.break_time == DOOR_BREAK_TIME && self.valid_difficulty(cx.w) {
+            cx.events.push(MobEvent::BreakDoor { pos: door });
+        }
+    }
+}
+
+/// `AbstractIllager.RaiderOpenDoorGoal` (`OpenDoorGoal` that does not wait
+/// to close): open the door in the way during a raid. It never continues, so
+/// it closes the door again as soon as it stops.
+#[derive(Clone, Debug, Default)]
+pub struct RaiderOpenDoor {
+    interact: Interact,
+}
+impl Goal for RaiderOpenDoor {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        0
+    }
+    fn every_tick(&self) -> bool {
+        true
+    }
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        self.interact.can_use(m, cx.w) && raider::has_active_raid(m)
+    }
+    fn can_continue(&mut self, _m: &mut Mob, _cx: &mut Cx) -> bool {
+        false
+    }
+    fn start(&mut self, _m: &mut Mob, cx: &mut Cx) {
+        self.interact.set_open(cx, true);
+    }
+    fn stop(&mut self, _m: &mut Mob, cx: &mut Cx) {
+        self.interact.set_open(cx, false);
+    }
+}
diff --git a/crates/horizon-client/src/mobs/finalize.rs b/crates/horizon-client/src/mobs/finalize.rs
index 4eeed885b..4e58e9475 100644
--- a/crates/horizon-client/src/mobs/finalize.rs
+++ b/crates/horizon-client/src/mobs/finalize.rs
@@ -1144,7 +1144,8 @@ impl<L: FinalizeLevel + ?Sized, R: RandomSource> Ctx<'_, L, R> {
                     }
                 }
             }
-            m.extra.can_break_doors = self.float() < special * 0.1;
+            let can_break_doors = self.float() < special * 0.1;
+            super::doors::set_can_break_doors(m, can_break_doors);
             if reason != Reason::Conversion {
                 self.populate(m);
                 self.enchant(m);
@@ -1205,7 +1206,7 @@ impl<L: FinalizeLevel + ?Sized, R: RandomSource> Ctx<'_, L, R> {
             ) {
                 m.health = max_health(m);
             }
-            m.extra.can_break_doors = true;
+            super::doors::set_can_break_doors(m, true);
         }
     }
     fn husk(&mut self, m: &mut Mob, g: Option<Group>, reason: Reason) -> Option<Group> {
diff --git a/crates/horizon-client/src/mobs/illager.rs b/crates/horizon-client/src/mobs/illager.rs
index 45ef076d3..641a474f6 100644
--- a/crates/horizon-client/src/mobs/illager.rs
+++ b/crates/horizon-client/src/mobs/illager.rs
@@ -72,6 +72,8 @@ pub fn register_vindicator(m: &mut Mob) {
     let g = &mut m.ai.goals;
     g.add(0, Float);
     g.add(1, avoid_creaking(1.0, 1.2));
+    g.add(2, super::doors::BreakDoor::vindicator());
+    g.add(3, super::doors::RaiderOpenDoor::default());
     g.add(4, super::raider::HoldGroundAttack::new(10.0));
     g.add(5, MeleeAttack::new(1.0, false));
     g.add(8, Stroll::new(0.6));
@@ -86,6 +88,13 @@ pub fn register_vindicator(m: &mut Mob) {
             .when(|m, _| m.custom_name.as_deref() == Some("Johnny")),
     );
 }
+/// `Vindicator.customServerAiStep`: its navigation opens doors while a raid
+/// is at its position.
+pub fn vindicator_server_ai_step(m: &mut Mob) {
+    if super::doors::can_navigate_ground(m) {
+        m.ai.nav.can_open_doors = super::raider::state(m).is_some_and(|s| s.raided);
+    }
+}
 // Evoker state: `counter` spellCastingTickCount, `variant2` the spell
 // being cast (0 none, 1 vexes, 2 fangs, 3 wololo), `counter2` the wololo
 // sheep's id.
diff --git a/crates/horizon-client/src/mobs/raider.rs b/crates/horizon-client/src/mobs/raider.rs
index 6c3ab9b64..d2ed62374 100644
--- a/crates/horizon-client/src/mobs/raider.rs
+++ b/crates/horizon-client/src/mobs/raider.rs
@@ -30,6 +30,9 @@ pub struct State {
     pub celebrating: bool,
     /// The raid is active (`hasActiveRaid`); set by the game every tick.
     pub active_raid: bool,
+    /// A raid is active within 96 blocks (`ServerLevel.isRaided`); set by
+    /// the game every tick for vindicators.
+    pub raided: bool,
     /// The raid is won or lost (`Raid.isOver`), lost (`isLoss`).
     pub raid_over: bool,
     pub raid_loss: bool,
diff --git a/crates/horizon-client/src/mobs/spawning.rs b/crates/horizon-client/src/mobs/spawning.rs
index 93e3fe119..f4e55e7d0 100644
--- a/crates/horizon-client/src/mobs/spawning.rs
+++ b/crates/horizon-client/src/mobs/spawning.rs
@@ -35,6 +35,8 @@ pub fn placement_ok(species: Species, w: &MobWorld, x: i32, y: i32, z: i32) -> b
 #[derive(Clone, Copy, Debug)]
 pub struct LocalDifficulty {
     pub effective: f32,
+    /// The world difficulty is normal.
+    pub normal: bool,
     /// The world difficulty is hard.
     pub hard: bool,
 }
@@ -45,9 +47,11 @@ impl LocalDifficulty {
     /// the overworld clock, the chunk's inhabited time and the moon.
     pub fn new(base: u8, total: i64, inhabited: i64, moon: f32) -> Self {
         let hard = base == 3;
+        let normal = base == 2;
         if base == 0 {
             return Self {
                 effective: 0.0,
+                normal,
                 hard,
             };
         }
@@ -60,6 +64,7 @@ impl LocalDifficulty {
         }
         Self {
             effective: f32::from(base) * (0.75 + global + local),
+            normal,
             hard,
         }
     }
diff --git a/crates/horizon-client/src/mobs/undead.rs b/crates/horizon-client/src/mobs/undead.rs
index e77a37641..b96ad2091 100644
--- a/crates/horizon-client/src/mobs/undead.rs
+++ b/crates/horizon-client/src/mobs/undead.rs
@@ -2,6 +2,7 @@
 //! stray, bogged, wither skeleton): goals, bow attacks, water conversion.
 use super::{
     Mob, MobEvent, Species, Who,
+    doors::BreakDoor,
     goals::{
         Avoid, AvoidEntity, Cx, FleeSun, Goal, HurtByTarget, LOOK, LookAtPlayer, MOVE, MeleeAttack,
         NearestTarget, RandomLookAround, RestrictSun, Stroll, goal_clone,
@@ -15,6 +16,7 @@ pub fn register(m: &mut Mob) {
     match m.species() {
         S::Zombie | S::Husk | S::ZombieVillager => {
             let g = &mut m.ai.goals;
+            g.add(1, BreakDoor::zombie());
             g.add(4, AttackTurtleEgg::default());
             g.add(8, LookAtPlayer::new(8.0));
             g.add(8, RandomLookAround::default());
@@ -42,6 +44,7 @@ pub fn register(m: &mut Mob) {
         S::ZombifiedPiglin => {
             // ZombifiedPiglin.addBehaviourGoals: neutral until provoked.
             let g = &mut m.ai.goals;
+            g.add(1, BreakDoor::zombie());
             g.add(8, LookAtPlayer::new(8.0));
             g.add(8, RandomLookAround::default());
             g.add(2, MeleeAttack::new(1.0, false).zombie());
@@ -58,6 +61,7 @@ pub fn register(m: &mut Mob) {
         S::Drowned => {
             // Zombie.registerGoals, then Drowned.addBehaviourGoals.
             let g = &mut m.ai.goals;
+            g.add(1, BreakDoor::zombie());
             g.add(4, AttackTurtleEgg::default());
             g.add(8, LookAtPlayer::new(8.0));
             g.add(8, RandomLookAround::default());

From 4ae514d0ae464b255b3df073d7c9b7f97d452cc5 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:36:10 +0100
Subject: [PATCH 063/475] Throw leftover items from the eyes, and creative
 players keep their stack on an armor stand

---
 crates/horizon-client/src/game.rs             | 21 ++++++++++++-------
 .../horizon-client/src/game/armor_stands.rs   |  5 +++++
 crates/horizon-client/src/game/potions.rs     |  3 ++-
 crates/horizon-client/src/game/stations.rs    |  3 ++-
 4 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 5760ffbe7..a38525e22 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2222,11 +2222,13 @@ impl Game<'_> {
         // Player.drop: the drop statistics.
         self.stats.add("dropped", &thrown.item, thrown.count as i32);
         self.stats.custom("drop", 1);
-        self.throw_from_eyes(thrown, eye);
+        self.throw_from_eyes(thrown, eye, true);
     }
     /// `Player.createItemStackToDrop`: an item entity thrown from the eyes
-    /// along the view direction.
-    fn throw_from_eyes(&mut self, thrown: ItemStack, eye: [f64; 3]) {
+    /// along the view direction. `thrown_from_hand` (`drop(stack, true)`, the
+    /// drop key) names the player as the thrower; `drop(stack, false)`, for
+    /// what no longer fits in the inventory, does not.
+    fn throw_from_eyes(&mut self, thrown: ItemStack, eye: [f64; 3], thrown_from_hand: bool) {
         let (yaw, pitch) = (
             f64::from(self.yaw).to_radians(),
             f64::from(self.pitch).to_radians(),
@@ -2240,7 +2242,7 @@ impl Game<'_> {
             yaw.cos() * pitch.cos() * 0.3 + spread.sin() * strength,
         ];
         self.spawn_item(thrown, [eye[0], eye[1] - 0.3, eye[2]], v, 40);
-        if self.lan_acting.is_none() {
+        if thrown_from_hand && self.lan_acting.is_none() {
             let uuid = self.level.ensure_player_uuid();
             self.dropped.last_mut().unwrap().thrower = Some(uuid);
         }
@@ -4517,7 +4519,7 @@ impl Game<'_> {
                 && let Some(stack) = self.carried.take()
                 && let Some(eye) = self.eye_position()
             {
-                self.throw_from_eyes(stack, eye);
+                self.throw_from_eyes(stack, eye, false);
             }
         }
         self.tick_world(running)
@@ -5606,7 +5608,8 @@ impl Game<'_> {
             if let Some(rest) = self.give(stack)
                 && let Some(eye) = self.eye_position()
             {
-                self.spawn_item(rest, [eye[0], eye[1] - 0.3, eye[2]], [0.0, 0.1, 0.0], 40);
+                // AbstractContainerMenu.dropOrPlaceInInventory: `drop(stack, false)`.
+                self.throw_from_eyes(rest, eye, false);
             }
         }
         self.craft_size = 2;
@@ -8437,7 +8440,8 @@ impl Game<'_> {
             }
             fn drop_stack(&mut self, stack: ItemStack) {
                 if let Some(eye) = self.0.eye_position() {
-                    self.0.spawn_item(stack, eye, [0.0, 0.1, 0.0], 40);
+                    // ItemUtils.createFilledResult: `player.drop(stack, false)`.
+                    self.0.throw_from_eyes(stack, eye, false);
                 }
             }
         }
@@ -8755,7 +8759,8 @@ impl Game<'_> {
                 } else if let Some(rest) = self.give(filled)
                     && let Some(eye) = self.eye_position()
                 {
-                    self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40);
+                    // ItemUtils.createFilledResult: `player.drop(stack, false)`.
+                    self.throw_from_eyes(rest, eye, false);
                 }
             }
             return Ok(UseResult::Success { swing: true });
diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs
index f175af401..9a8c846c5 100644
--- a/crates/horizon-client/src/game/armor_stands.rs
+++ b/crates/horizon-client/src/game/armor_stands.rs
@@ -453,6 +453,11 @@ impl Game<'_> {
         }
         // ArmorStand.swapItem.
         match held {
+            // A player with infinite materials puts a copy of one on an empty
+            // slot and keeps the stack.
+            Some(h) if self.creative && current.is_none() => {
+                self.armor_stands[i].equipment[slot] = Some(ItemStack { count: 1, ..h });
+            }
             Some(h) if h.count > 1 => {
                 if current.is_some() {
                     return true;
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index b28c2fb4d..1631131ae 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -266,7 +266,8 @@ impl Game<'_> {
         } else if let Some(rest) = self.give(filled)
             && let Some(eye) = self.eye_position()
         {
-            self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40);
+            // `player.drop(stack, false)`.
+            self.throw_from_eyes(rest, eye, false);
         }
     }
     /// Drinking a potion while right-click is held; true when handled.
diff --git a/crates/horizon-client/src/game/stations.rs b/crates/horizon-client/src/game/stations.rs
index f7f05e1c4..f35691237 100644
--- a/crates/horizon-client/src/game/stations.rs
+++ b/crates/horizon-client/src/game/stations.rs
@@ -713,7 +713,8 @@ impl Game<'_> {
         if let Some(rest) = self.give(stack)
             && let Some(eye) = self.eye_position()
         {
-            self.spawn_item(rest, [eye[0], eye[1] - 0.3, eye[2]], [0.0, 0.1, 0.0], 40);
+            // Inventory.placeItemBackInInventory: `player.drop(stack, false)`.
+            self.throw_from_eyes(rest, eye, false);
         }
     }
     /// `Player.giveExperienceLevels`.

From bd59cdc25cc3da28287933f55aa0aaf0a5608cd0 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:39:16 +0100
Subject: [PATCH 064/475] Let turtles lay eggs that hatch into baby turtles

A bred turtle now carries an egg instead of the baby appearing at once.
She walks home, digs into sand for a while and lays a turtle egg there.
A hatching egg gives one baby turtle per egg with the egg as its home,
and a baby that grows up drops a scute.
---
 crates/horizon-client/src/entity_nbt.rs     |  14 ++
 crates/horizon-client/src/game.rs           |   5 +
 crates/horizon-client/src/game/creatures.rs |  63 +++++-
 crates/horizon-client/src/mobs.rs           |   7 +
 crates/horizon-client/src/mobs/ai.rs        |  11 ++
 crates/horizon-client/src/mobs/body_anim.rs |   4 +-
 crates/horizon-client/src/mobs/goals.rs     |   8 +
 crates/horizon-client/src/mobs/turtle.rs    | 209 ++++++++++++++++++++
 8 files changed, 318 insertions(+), 3 deletions(-)
 create mode 100644 crates/horizon-client/src/mobs/turtle.rs

diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 00576ea02..f7c843264 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -357,6 +357,12 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         "minecraft:bat" => {
             map.insert("BatFlags".into(), Tag::Byte(i8::from(m.extra.flag)));
         }
+        "minecraft:turtle" => {
+            map.insert("has_egg".into(), Tag::Byte(i8::from(m.extra.flag)));
+            if let Some(home) = m.extra.home {
+                map.insert("home_pos".into(), Tag::IntArray(home.to_vec()));
+            }
+        }
         "minecraft:creaking" => {
             // home_pos: the heart it is bound to.
             if let Some(home) = m.extra.home {
@@ -847,6 +853,14 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     {
         crate::mobs::creaking::set_transient(&mut m, [home[0], home[1], home[2]]);
     }
+    if m.species() == crate::mobs::Species::Turtle {
+        // Turtle.readAdditionalSaveData: `home_pos` (else where it stands) and `has_egg`.
+        m.extra.flag = flag(tag, "has_egg");
+        m.extra.home = match tag.get("home_pos") {
+            Some(Tag::IntArray(home)) if home.len() == 3 => Some([home[0], home[1], home[2]]),
+            _ => None,
+        };
+    }
     if m.species() == crate::mobs::Species::Wither {
         m.extra.counter = number(tag.get("Invul")).unwrap_or(0) as i32;
     }
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 5760ffbe7..f29a71f20 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2968,6 +2968,11 @@ impl Game<'_> {
                     kind: "hatch_sniffer",
                     ..
                 } => self.hatch_sniffer([pos.x, pos.y, pos.z]),
+                LevelEvent::BlockEvent {
+                    pos,
+                    state,
+                    kind: "hatch_turtles",
+                } => self.hatch_turtles([pos.x, pos.y, pos.z], state),
                 LevelEvent::BlockEvent {
                     pos,
                     kind: "portal_spawn",
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..03911ffda 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1185,6 +1185,10 @@ impl Game<'_> {
                     self.mob_vibration_particle(from, to, ticks)
                 }
                 MobEvent::DigParticles { at } => self.warden_dig_particles(at),
+                MobEvent::BlockBreakEffect { pos, block } => {
+                    let state = self.world.block(block[0], block[1], block[2]);
+                    self.destroy_particles(pos, state);
+                }
                 MobEvent::Darkness { at, radius } => self.apply_darkness(at, radius),
                 MobEvent::CreakingHurt {
                     home,
@@ -1222,6 +1226,11 @@ impl Game<'_> {
                     }
                 }
                 MobEvent::GiftLoot { table, at } => {
+                    // Turtle.ageBoundaryReached: only with mob loot on.
+                    if table == "minecraft:gameplay/turtle_grow" && !self.ui.rules.bool("mob_drops")
+                    {
+                        continue;
+                    }
                     let drops =
                         self.res
                             .items()
@@ -1234,6 +1243,39 @@ impl Game<'_> {
         }
         Ok(())
     }
+    /// `TurtleEggBlock.randomTick` at the last hatch stage: one baby turtle
+    /// per egg, a day from grown, with the egg as its home (the sound, the
+    /// crumbs and the block's removal came from the level).
+    pub(super) fn hatch_turtles(
+        &mut self,
+        pos: [i32; 3],
+        state: horizon_world::registry::BlockStateId,
+    ) {
+        let eggs = self
+            .pack
+            .assets
+            .registry
+            .state(state)
+            .and_then(|s| s.properties.get("eggs"))
+            .and_then(|v| v.parse::<i32>().ok())
+            .unwrap_or(1);
+        for i in 0..eggs {
+            let at = [
+                f64::from(pos[0]) + 0.3 + f64::from(i) * 0.2,
+                f64::from(pos[1]),
+                f64::from(pos[2]) + 0.3,
+            ];
+            if let Some(id) = self.spawn_mob("minecraft:turtle", at, true)
+                && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
+            {
+                m.extra.age = -24000;
+                m.extra.home = Some(pos);
+                m.yaw = 0.0;
+                m.body_yaw = 0.0;
+                m.head_yaw = 0.0;
+            }
+        }
+    }
     fn apply_setup(&mut self, id: u32, setup: &SpawnSetup) {
         let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) else {
             return;
@@ -1289,6 +1331,8 @@ impl Game<'_> {
                 .unwrap_or_else(|| parent.clone());
             let mut child = parent.clone();
             child.baby = true;
+            // TurtleBreedGoal.breed triggers it without a child.
+            let turtle = p.species() == Species::Turtle;
             if matches!(
                 (
                     p.species(),
@@ -1301,7 +1345,7 @@ impl Game<'_> {
             ) {
                 child.kind = "minecraft:mule".into();
             }
-            self.trigger_bred(&parent, &partner_view, Some(&child));
+            self.trigger_bred(&parent, &partner_view, (!turtle).then_some(&child));
         }
         if let Some(q) = self.mobs.iter_mut().find(|m| m.id == partner) {
             q.extra.age = 6000;
@@ -1313,6 +1357,15 @@ impl Game<'_> {
             self.lay_sniffer_egg(&p);
             return;
         }
+        // TurtleBreedGoal.breed: the goal gave the mother her egg; only the
+        // experience is left, and only with mob loot on.
+        if p.species() == Species::Turtle {
+            if self.ui.rules.bool("mob_drops") {
+                let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
+                self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+            }
+            return;
+        }
         let coin = self.world.random.next_int_bound(2).unwrap_or(0) == 0;
         let coin2 = self.world.random.next_int_bound(2).unwrap_or(0) == 0;
         // A horse and a donkey have a mule.
@@ -2542,6 +2595,7 @@ impl Game<'_> {
         let mut handled = true;
         let mut drops: Vec<(String, u32)> = Vec::new();
         let is_food = m.kind.food.contains(&item);
+        let baby_turtle = species == Species::Turtle && m.is_baby();
         match species {
             Species::Cow | Species::Mooshroom if item == "minecraft:bucket" && !m.is_baby() => {
                 give = Some("minecraft:milk_bucket");
@@ -2820,6 +2874,13 @@ impl Game<'_> {
         if !handled {
             return Ok(false);
         }
+        // Turtle.ageBoundaryReached: food that finishes a baby's growth.
+        if baby_turtle && !self.mobs[index].is_baby() {
+            self.handle_mob_events(vec![MobEvent::GiftLoot {
+                table: "minecraft:gameplay/turtle_grow",
+                at: feet,
+            }])?;
+        }
         self.swing_arm();
         if let Some(s) = sound {
             let pitch =
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..0a158333d 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -68,6 +68,7 @@ pub mod tame;
 pub mod trader;
 pub mod transport_items;
 pub mod trial_spawner;
+pub mod turtle;
 pub mod undead;
 pub mod vex;
 pub mod villager;
@@ -1151,6 +1152,12 @@ pub enum MobEvent {
     DigParticles {
         at: [f64; 3],
     },
+    /// `LevelEvent.PARTICLES_DESTROY_BLOCK` (2001) at `pos` for the block at
+    /// `block`: a turtle's digging.
+    BlockBreakEffect {
+        pos: [i32; 3],
+        block: [i32; 3],
+    },
     /// `Warden.applyDarknessAround`: darkness for survival players nearby.
     Darkness {
         at: [f64; 3],
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 8335cb745..f0d5db934 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -183,6 +183,9 @@ pub fn register(m: &mut Mob) {
             if m.species() == Species::Rabbit {
                 super::rabbit::register(m);
             }
+            if m.species() == Species::Turtle {
+                super::turtle::register(m);
+            }
         }
         Family::Inert => {}
         Family::Witch => super::witch::register(m),
@@ -712,6 +715,13 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &
             // setAge at the age boundary: refreshDimensions.
             if m.extra.age >= 0 {
                 m.fudge_position_after_size_change(w, bw, bh);
+                // Turtle.ageBoundaryReached: a grown turtle drops a scute.
+                if m.species() == Species::Turtle {
+                    events.push(MobEvent::GiftLoot {
+                        table: "minecraft:gameplay/turtle_grow",
+                        at: [m.position.x, m.position.y, m.position.z],
+                    });
+                }
             }
         } else if m.extra.age > 0 {
             m.extra.age -= 1;
@@ -999,6 +1009,7 @@ fn species_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         }
         Species::Nautilus | Species::ZombieNautilus => super::nautilus::ai_step(m, w, events),
         Species::Chicken => farm::chicken_ai_step(m, w, events),
+        Species::Turtle => super::turtle::ai_step(m, w, events),
         Species::Sheep if m.extra.anim_ticks > 0 => {
             m.extra.anim_ticks -= 1;
         }
diff --git a/crates/horizon-client/src/mobs/body_anim.rs b/crates/horizon-client/src/mobs/body_anim.rs
index 4411d347b..bbb44c5ab 100644
--- a/crates/horizon-client/src/mobs/body_anim.rs
+++ b/crates/horizon-client/src/mobs/body_anim.rs
@@ -969,8 +969,8 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool {
             s,
             &Turtle {
                 on_land: !m.fluids.in_water && m.on_ground,
-                laying_egg: false,
-                has_egg: false,
+                laying_egg: m.extra.flag2,
+                has_egg: m.extra.flag,
             },
         ),
         Species::Strider => strider(p, s, m.rider.is_some()),
diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs
index 7f73e32c4..7cb3011c9 100644
--- a/crates/horizon-client/src/mobs/goals.rs
+++ b/crates/horizon-client/src/mobs/goals.rs
@@ -1762,6 +1762,10 @@ impl Goal for Breed {
         if tamable && (!m.extra.tame || m.extra.sitting) {
             return false;
         }
+        // TurtleBreedGoal.canUse: not while carrying an egg.
+        if species == Species::Turtle && super::turtle::has_egg(m) {
+            return false;
+        }
         let id = m.id;
         // Horses and donkeys breed together (AbstractHorse.canParent: tame).
         // Sniffer.canMate: calm states only.
@@ -1832,6 +1836,10 @@ impl Goal for Breed {
             });
             m.extra.in_love = 0;
             m.extra.age = 6000;
+            // TurtleBreedGoal.breed: the mother carries an egg, not a baby.
+            if m.species() == Species::Turtle {
+                m.extra.flag = true;
+            }
             cx.events.push(MobEvent::Breed {
                 parent: m.id,
                 partner: p.id,
diff --git a/crates/horizon-client/src/mobs/turtle.rs b/crates/horizon-client/src/mobs/turtle.rs
new file mode 100644
index 000000000..0596adfdf
--- /dev/null
+++ b/crates/horizon-client/src/mobs/turtle.rs
@@ -0,0 +1,209 @@
+//! Turtles (`Turtle`): the egg a bred mother carries (`TurtleBreedGoal`), her
+//! walk home (`TurtleGoHomeGoal`) and the egg she digs into the sand
+//! (`TurtleLayEggGoal`). `extra.flag` is `hasEgg`, `extra.flag2` `isLayingEgg`,
+//! `extra.counter` `layEggCounter` and `extra.home` `homePos`.
+use super::{
+    Mob, MobEvent, MobWorld,
+    goals::{Breed, Cx, Goal, JUMP, MOVE, MoveToBlock, goal_clone, reduced},
+};
+use horizon_core::random::RandomSource;
+
+pub fn register(m: &mut Mob) {
+    let g = &mut m.ai.goals;
+    g.add(1, Breed::new(1.0));
+    g.add(1, LayEgg(MoveToBlock::new(1.0, 16, 1)));
+    g.add(4, GoHome::default());
+}
+/// `Turtle.hasEgg`.
+pub fn has_egg(m: &Mob) -> bool {
+    m.extra.flag
+}
+/// `Turtle.setLayingEgg`.
+fn set_laying_egg(m: &mut Mob, on: bool) {
+    m.extra.counter = i32::from(on);
+    m.extra.flag2 = on;
+}
+/// `homePos.closerToCenterThan(position, distance)`; a turtle that never
+/// had a home is at home where it stands.
+fn close_to_home(m: &Mob, distance: f64) -> bool {
+    let home = m.extra.home.unwrap_or([
+        m.position.x.floor() as i32,
+        m.position.y.floor() as i32,
+        m.position.z.floor() as i32,
+    ]);
+    let d = [
+        f64::from(home[0]) + 0.5 - m.position.x,
+        f64::from(home[1]) + 0.5 - m.position.y,
+        f64::from(home[2]) + 0.5 - m.position.z,
+    ];
+    d[0] * d[0] + d[1] * d[1] + d[2] * d[2] < distance * distance
+}
+fn block_of(m: &Mob) -> [i32; 3] {
+    [
+        m.position.x.floor() as i32,
+        m.position.y.floor() as i32,
+        m.position.z.floor() as i32,
+    ]
+}
+/// `TurtleEggBlock.isSand`.
+fn is_sand(w: &MobWorld, p: [i32; 3]) -> bool {
+    w.has_tag("minecraft:sand", w.block_name(p[0], p[1], p[2]))
+}
+/// `Turtle.aiStep`: while digging, sand crumbs fly every fifth tick.
+pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
+    if m.alive() && m.extra.flag2 && m.extra.counter >= 1 && m.extra.counter % 5 == 0 {
+        let at = block_of(m);
+        let below = [at[0], at[1] - 1, at[2]];
+        if is_sand(w, below) {
+            events.push(MobEvent::BlockBreakEffect {
+                pos: at,
+                block: below,
+            });
+        }
+    }
+}
+
+/// `Turtle.TurtleLayEggGoal`: a mother with an egg within 9 blocks of home
+/// walks to sand with air above, digs for 200 ticks and lays it.
+#[derive(Clone, Debug)]
+struct LayEgg(MoveToBlock);
+impl LayEgg {
+    /// `isValidTarget`: sand with air above it.
+    fn valid(w: &MobWorld, p: [i32; 3]) -> bool {
+        w.facts.is_air(w.world.block(p[0], p[1] + 1, p[2])) && is_sand(w, p)
+    }
+}
+impl Goal for LayEgg {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        MOVE | JUMP
+    }
+    fn name(&self) -> &'static str {
+        "TurtleLayEggGoal"
+    }
+    fn every_tick(&self) -> bool {
+        true
+    }
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        if !(has_egg(m) && close_to_home(m, 9.0)) {
+            return false;
+        }
+        // MoveToBlockGoal.canUse.
+        if self.0.next_start > 0 {
+            self.0.next_start -= 1;
+            return false;
+        }
+        self.0.next_start = reduced(200 + m.random.next_int_bound(200).unwrap_or(0));
+        self.0.find_nearest(m, cx.w, Self::valid)
+    }
+    fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        self.0.can_continue(cx.w, Self::valid) && has_egg(m) && close_to_home(m, 9.0)
+    }
+    fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
+        self.0.start(m, cx.w);
+    }
+    fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
+        self.0.tick(m, cx.w);
+        if m.fluids.in_water || !self.0.reached {
+            return;
+        }
+        if m.extra.counter < 1 {
+            set_laying_egg(m, true);
+        } else if m.extra.counter > 200 {
+            let at = [m.position.x, m.position.y, m.position.z];
+            let pitch = 0.9 + m.random.next_float() * 0.2;
+            cx.events
+                .push(MobEvent::Sound("entity.turtle.lay_egg", at, 0.3, pitch));
+            // Blocks.TURTLE_EGG with EGGS = nextInt(4) + 1 above the sand.
+            let eggs = m.random.next_int_bound(4).unwrap_or(0) + 1;
+            let registry = cx.w.registry;
+            let state = registry
+                .default_state("minecraft:turtle_egg")
+                .and_then(|d| registry.state(d).cloned())
+                .and_then(|mut s| {
+                    s.properties.insert("eggs".into(), eggs.to_string());
+                    registry.resolve(&s).ok()
+                });
+            let b = self.0.block;
+            if let Some(state) = state {
+                cx.events.push(MobEvent::SetBlock {
+                    pos: [b[0], b[1] + 1, b[2]],
+                    state,
+                });
+            }
+            m.extra.flag = false;
+            set_laying_egg(m, false);
+            m.extra.in_love = 600;
+        }
+        if m.extra.flag2 {
+            m.extra.counter += 1;
+        }
+    }
+}
+
+/// `Turtle.TurtleGoHomeGoal`: a mother with an egg heads home; any adult
+/// that strayed 64 blocks away does now and then.
+#[derive(Clone, Debug, Default)]
+struct GoHome {
+    stuck: bool,
+    close_to_home_try_ticks: i32,
+}
+impl Goal for GoHome {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        0
+    }
+    fn name(&self) -> &'static str {
+        "TurtleGoHomeGoal"
+    }
+    fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool {
+        if m.is_baby() {
+            false
+        } else if has_egg(m) {
+            true
+        } else {
+            m.random.next_int_bound(reduced(700)).unwrap_or(1) == 0 && !close_to_home(m, 64.0)
+        }
+    }
+    fn start(&mut self, _m: &mut Mob, _cx: &mut Cx) {
+        self.stuck = false;
+        self.close_to_home_try_ticks = 0;
+    }
+    fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool {
+        !close_to_home(m, 7.0) && !self.stuck && self.close_to_home_try_ticks <= reduced(600)
+    }
+    fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
+        let home = m.extra.home.unwrap_or(block_of(m));
+        let close = close_to_home(m, 16.0);
+        if close {
+            self.close_to_home_try_ticks += 1;
+        }
+        if !m.ai.nav.is_done() {
+            return;
+        }
+        let to = [
+            f64::from(home[0]) + 0.5,
+            f64::from(home[1]),
+            f64::from(home[2]) + 0.5,
+        ];
+        let mut next = m
+            .default_random_pos_towards(cx.w, 16, 3, to, std::f64::consts::PI / 10.0)
+            .or_else(|| m.default_random_pos_towards(cx.w, 8, 7, to, std::f64::consts::FRAC_PI_2));
+        if let Some(at) = next
+            && !close
+            && cx.w.block_name(
+                at[0].floor() as i32,
+                at[1].floor() as i32,
+                at[2].floor() as i32,
+            ) != "minecraft:water"
+        {
+            next = m.default_random_pos_towards(cx.w, 16, 5, to, std::f64::consts::FRAC_PI_2);
+        }
+        match next {
+            Some(at) => {
+                m.nav_move_to(cx.w, at, 1.0);
+            }
+            None => self.stuck = true,
+        }
+    }
+}

From 4abf5c0ea2d907024318aaf2343139fd1273b7b2 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 14:58:57 +0100
Subject: [PATCH 065/475] Play no place sound after using an empty hand or a
 non-block item on a block

---
 crates/horizon-client/src/game/remote.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 857f955da..3bc62510e 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3950,15 +3950,11 @@ impl Game<'_> {
                 world_border: false,
                 sequence: seq,
             }));
-            let target = [
-                hit.pos[0] + hit.face[0],
-                hit.pos[1] + hit.face[1],
-                hit.pos[2] + hit.face[2],
-            ];
-            let ticks = self.ticks;
+            // Only a predicted placement (predict_place) marks a cell whose
+            // resend plays a place sound: an empty hand or a non-block item
+            // places nothing (BlockItem.place is where the sound comes from).
             if let Some(r) = self.remote.as_mut() {
                 r.use_target = Some(hit.pos);
-                r.placing = Some((target, ticks));
             }
             if reacts {
                 self.predict_use(&changes, seq);

From 0c22d75a2e6a88fa8daef1c8c59c34d2f154c6f2 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:02:41 +0100
Subject: [PATCH 066/475] Satisfy clippy

---
 crates/horizon-client/src/game/piglins.rs | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/game/piglins.rs b/crates/horizon-client/src/game/piglins.rs
index 337efe8a6..7e58620bf 100644
--- a/crates/horizon-client/src/game/piglins.rs
+++ b/crates/horizon-client/src/game/piglins.rs
@@ -30,15 +30,13 @@ impl Game<'_> {
     /// The `SLOT_NAMES` index `getEquipmentSlotForItem` picks: armour goes
     /// to its slot, anything else to the main hand.
     fn piglin_slot(&self, item: &str) -> usize {
-        let slot = match self
+        let slot = self
             .res
             .items()
             .get(item)
             .and_then(|i| i.equip_slot.as_deref())
-        {
-            Some(s @ ("head" | "chest" | "legs" | "feet")) => s,
-            _ => "mainhand",
-        };
+            .filter(|s| matches!(*s, "head" | "chest" | "legs" | "feet"))
+            .unwrap_or("mainhand");
         SLOT_NAMES.iter().position(|n| *n == slot).unwrap_or(0)
     }
     /// `Piglin.canReplaceCurrentItem`: an empty slot takes anything, a wanted

From 84b621096a193b3ff34fa2db9b93d4201c419c35 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:02:46 +0100
Subject: [PATCH 067/475] Satisfy clippy

---
 crates/horizon-client/src/mobs/piglin.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs
index 2c92ecd0a..59c0a9344 100644
--- a/crates/horizon-client/src/mobs/piglin.rs
+++ b/crates/horizon-client/src/mobs/piglin.rs
@@ -269,7 +269,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         m.extra.counter2 = 0;
     }
     // PiglinSpecificSensor (every 20 ticks): the nearest repelling block.
-    if m.species() == Species::Piglin && m.alive() && m.age.wrapping_add(m.id) % 20 == 0 {
+    if m.species() == Species::Piglin && m.alive() && m.age.wrapping_add(m.id).is_multiple_of(20) {
         m.extra.repellent = find_repellent(m, w);
     }
 }

From 7d5a05226183aedba5a95047d8ecf9f91a3442fa Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 13:47:55 +0100
Subject: [PATCH 068/475] Target blocks react to projectile hits

A target block never changed its power when something hit it. Every
projectile that hits a block now asks the block how to react, as vanilla
does: a target block takes its power from where the projectile landed
(1 to 15 by the distance from the face centre) and resets after 20
ticks for an arrow or 8 for any other projectile. A player's hit also
counts the target_hit statistic.
---
 crates/horizon-client/src/game/creatures.rs | 24 +++++++++++++
 crates/horizon-world/src/level/mod.rs       | 16 +++++++++
 crates/horizon-world/src/level/redstone.rs  | 37 +++++++++++++++++++++
 3 files changed, 77 insertions(+)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..d7e42f8c6 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1993,6 +1993,23 @@ impl Game<'_> {
             self.creatures.projectiles.push(arrow);
         }
     }
+    /// `TargetBlock.onProjectileHit`: a target block takes its power from
+    /// where the projectile landed and resets after 20 ticks for an arrow, 8
+    /// for any other projectile. A player's shot counts as a target hit.
+    fn target_block_hit(&mut self, p: &Projectile, pos: [i32; 3], at: Vec3, face: [i32; 3]) {
+        let block = BlockPos::new(pos[0], pos[1], pos[2]);
+        let arrow = p.arrow.is_some();
+        let location = [at.x, at.y, at.z];
+        let hit = self.with_level(|b, level, ticks| {
+            b.target_projectile_hit(level, ticks, block, location, face, arrow)
+        });
+        if hit.is_some() {
+            let _ = self.process_level_events();
+            if p.owner == Some(Who::Player) {
+                self.stats.custom("target_hit", 1);
+            }
+        }
+    }
     pub(super) fn projectile_hit(&mut self, p: &Projectile, hit: Hit) -> Result<()> {
         self.combat.projectile_owner = match p.owner {
             Some(Who::Mob(id)) => Some(id),
@@ -2002,6 +2019,13 @@ impl Game<'_> {
             Hit::Entity { at, .. } | Hit::Block { at, .. } => at,
             Hit::None => return Ok(()),
         };
+        // Projectile.onHitBlock: BlockState.onProjectileHit, for every
+        // projectile (a wind charge out of the world's top has no face).
+        if let Hit::Block { pos, face, .. } = hit
+            && face != [0; 3]
+        {
+            self.target_block_hit(p, pos, at, face);
+        }
         if let Hit::Entity {
             who: Who::Mob(id),
             at,
diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs
index 3831efbd6..38b953278 100644
--- a/crates/horizon-world/src/level/mod.rs
+++ b/crates/horizon-world/src/level/mod.rs
@@ -779,6 +779,22 @@ impl Behaviours {
     ) -> i32 {
         self.sim(level, ticks).best_neighbor_signal(pos)
     }
+    /// `BlockState.onProjectileHit` of a target block (`TargetBlock`) hit by
+    /// a projectile at `location` on the face with normal `face`; `arrow`
+    /// for an `AbstractArrow`. Returns the output strength, or None when the
+    /// block at `pos` is not a target block.
+    pub fn target_projectile_hit<L: LevelAccess + ?Sized>(
+        &self,
+        level: &mut L,
+        ticks: &mut Ticks,
+        pos: BlockPos,
+        location: [f64; 3],
+        face: [i32; 3],
+        arrow: bool,
+    ) -> Option<i32> {
+        self.sim(level, ticks)
+            .target_projectile_hit(pos, location, face, arrow)
+    }
 }
 
 /// One mutable view used by the ported behaviour code.
diff --git a/crates/horizon-world/src/level/redstone.rs b/crates/horizon-world/src/level/redstone.rs
index 92f9059e5..89bcfc5f2 100644
--- a/crates/horizon-world/src/level/redstone.rs
+++ b/crates/horizon-world/src/level/redstone.rs
@@ -1187,6 +1187,43 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
             self.set_block(pos, next, 2);
         }
     }
+    /// `TargetBlock.onProjectileHit` for a projectile that hit `face` of the
+    /// block at `pos` at `location`: the output power from how near the
+    /// face's centre it landed (1 to 15), reset after 20 ticks for an arrow
+    /// and 8 for anything else, unless a reset is already scheduled. None
+    /// when the block is not a target block, else the strength.
+    pub(crate) fn target_projectile_hit(
+        &mut self,
+        pos: BlockPos,
+        location: [f64; 3],
+        face: [i32; 3],
+        arrow: bool,
+    ) -> Option<i32> {
+        let b = self.b;
+        let state = self.state(pos);
+        if !b.data(state).is(Class::Target) {
+            return None;
+        }
+        // `getRedstoneStrength`: the distance from the centre along the
+        // face's two other axes (Mth.frac of the location, minus a half).
+        let off = |v: f64| (v - v.floor() - 0.5).abs();
+        let [dx, dy, dz] = [off(location[0]), off(location[1]), off(location[2])];
+        let distance = if face[1] != 0 {
+            dx.max(dz)
+        } else if face[2] != 0 {
+            dx.max(dy)
+        } else {
+            dy.max(dz)
+        };
+        let strength = ((15.0 * ((0.5 - distance) / 0.5).clamp(0.0, 1.0)).ceil() as i32).max(1);
+        let block = b.block(state);
+        if !self.ticks.has_block_tick(pos, block) {
+            // `setOutputPower`.
+            self.set_block_and_update(pos, b.table.set_int(state, b.props.power, strength));
+            self.schedule_tick(pos, block, if arrow { 20 } else { 8 });
+        }
+        Some(strength)
+    }
 }
 
 /// Order `positions` as a `java.util.HashSet<BlockPos>` of capacity 16 would

From d136dda0928f3150fead27675fa812eef83d8d66 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:08:48 +0100
Subject: [PATCH 069/475] Bee stings only poison on Normal and Hard

---
 crates/horizon-client/src/mobs/bee.rs      | 19 +++++++++++++------
 crates/horizon-client/src/mobs/spawning.rs |  4 ++++
 2 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/mobs/bee.rs b/crates/horizon-client/src/mobs/bee.rs
index 27d8e7c84..741a78df6 100644
--- a/crates/horizon-client/src/mobs/bee.rs
+++ b/crates/horizon-client/src/mobs/bee.rs
@@ -323,12 +323,19 @@ pub fn sting(m: &mut Mob, who: Who, cx: &mut Cx) {
     match who {
         Who::Player => {
             cx.events.push(MobEvent::AttackPlayer(amount, from));
-            let seconds = if cx.w.difficulty.hard { 18 } else { 10 };
-            cx.events.push(MobEvent::EffectPlayer {
-                effect: "minecraft:poison",
-                ticks: seconds * 20,
-                amplifier: 0,
-            });
+            // Poison only on normal (10 s) and hard (18 s).
+            let seconds = match cx.w.difficulty.base {
+                2 => 10,
+                3 => 18,
+                _ => 0,
+            };
+            if seconds > 0 {
+                cx.events.push(MobEvent::EffectPlayer {
+                    effect: "minecraft:poison",
+                    ticks: seconds * 20,
+                    amplifier: 0,
+                });
+            }
         }
         Who::Mob(id) => cx.events.push(MobEvent::AttackMob {
             target: id,
diff --git a/crates/horizon-client/src/mobs/spawning.rs b/crates/horizon-client/src/mobs/spawning.rs
index 93e3fe119..57ecb1692 100644
--- a/crates/horizon-client/src/mobs/spawning.rs
+++ b/crates/horizon-client/src/mobs/spawning.rs
@@ -37,6 +37,8 @@ pub struct LocalDifficulty {
     pub effective: f32,
     /// The world difficulty is hard.
     pub hard: bool,
+    /// The world difficulty id, 0 peaceful to 3 hard.
+    pub base: u8,
 }
 /// `DimensionType.MOON_BRIGHTNESS_PER_PHASE`.
 pub const MOON_BRIGHTNESS: [f32; 8] = [1.0, 0.75, 0.5, 0.25, 0.0, 0.25, 0.5, 0.75];
@@ -49,6 +51,7 @@ impl LocalDifficulty {
             return Self {
                 effective: 0.0,
                 hard,
+                base,
             };
         }
         let global = ((total as f32 - 72000.0) / 1_440_000.0).clamp(0.0, 1.0) * 0.25;
@@ -61,6 +64,7 @@ impl LocalDifficulty {
         Self {
             effective: f32::from(base) * (0.75 + global + local),
             hard,
+            base,
         }
     }
     /// `getSpecialMultiplier`.

From 790b191ed18f1e0fd839df8719a7d6300d3aac69 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:09:20 +0100
Subject: [PATCH 070/475] Bees let out of a sedated hive stay out for 400 ticks

---
 crates/horizon-client/src/mobs/bee.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/mobs/bee.rs b/crates/horizon-client/src/mobs/bee.rs
index 27d8e7c84..c351439a5 100644
--- a/crates/horizon-client/src/mobs/bee.rs
+++ b/crates/horizon-client/src/mobs/bee.rs
@@ -421,10 +421,10 @@ pub fn drop_off_nectar(m: &mut Mob) {
     set_has_nectar(m, false);
     st(m).crops_grown = 0;
 }
-/// `Bee.setStayOutOfHiveCountdown`, which in 26.3 only resets the time
-/// without nectar.
+/// `Bee.setStayOutOfHiveCountdown`: the bee will not enter a hive for 400
+/// ticks (the hive passes that when a sedated hive lets its bees out).
 pub fn set_stay_out_of_hive_countdown(m: &mut Mob) {
-    st(m).ticks_without_nectar = 0;
+    st(m).stay_out_of_hive = 400;
 }
 fn drop_hive(m: &mut Mob) {
     let b = st(m);

From e553db9bb5505ce579134136f6349432f21d6f30 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:10:09 +0100
Subject: [PATCH 071/475] Let frogs take fall damage five points below the base
 amount

---
 crates/horizon-client/src/mobs/living.rs  | 6 +++++-
 crates/horizon-client/src/mobs/species.rs | 1 -
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs
index 394821ace..f089b5355 100644
--- a/crates/horizon-client/src/mobs/living.rs
+++ b/crates/horizon-client/src/mobs/living.rs
@@ -629,7 +629,11 @@ impl Mob {
             return;
         }
         let power = self.fall_distance + 1.0e-6 - self.kind.safe_fall_distance;
-        let damage = (power * self.kind.fall_damage_multiplier).floor();
+        let mut damage = (power * self.kind.fall_damage_multiplier).floor();
+        // Frog.calculateFallDamage: five points less than the base damage.
+        if self.species() == super::Species::Frog {
+            damage -= 5.0;
+        }
         if damage > 0.0 {
             let at = [self.position.x, self.position.y, self.position.z];
             let sound = if damage > 4.0 {
diff --git a/crates/horizon-client/src/mobs/species.rs b/crates/horizon-client/src/mobs/species.rs
index f48a21fe9..fb62365a7 100644
--- a/crates/horizon-client/src/mobs/species.rs
+++ b/crates/horizon-client/src/mobs/species.rs
@@ -1447,7 +1447,6 @@ impl Def {
                     | S::IronGolem
                     | S::Cat
                     | S::Ocelot
-                    | S::Frog
                     | S::Slime
                     | S::MagmaCube
                     | S::Wither

From 7cc8def23f1d74efbd6b5dfa096b40e540a10c4c Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:10:57 +0100
Subject: [PATCH 072/475] Let a lit TNT minecart explode when it hits a wall

---
 crates/horizon-client/src/game/minecarts.rs | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index a19b6df73..ceff3f127 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -539,7 +539,6 @@ impl Game<'_> {
         // applyGravity
         c.velocity.y -= if self.cart_in_water(c) { 0.005 } else { 0.04 };
         let pos = self.rail_block(c.position);
-        let fall_speed = c.velocity;
         if let Some(rail) = self.rail(pos[0], pos[1], pos[2]) {
             self.move_along_track(c, pos, &rail, intent);
             if &*rail.name == "minecraft:activator_rail" {
@@ -581,15 +580,15 @@ impl Game<'_> {
                 }
             }
             CartKind::Tnt => {
-                let speed = fall_speed.x * fall_speed.x + fall_speed.z * fall_speed.z;
+                // MinecartTNT.tick: the fuse and the collision check are separate.
                 if c.fuse > 0 {
                     c.fuse -= 1;
                     let at = [c.position.x, c.position.y + 0.5, c.position.z];
                     self.particles
                         .add(&ParticleOptions::simple(ParticleType::Smoke), at, [0.0; 3]);
-                } else if c.fuse == 0 || (c.horizontal_collision && speed >= 0.01) {
+                } else if c.fuse == 0 {
                     let speed = c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z;
-                    let speed = if c.fuse == 0 && c.velocity.y > 0.0 {
+                    let speed = if c.velocity.y > 0.0 {
                         c.velocity.y * c.velocity.y
                     } else {
                         speed
@@ -597,6 +596,13 @@ impl Game<'_> {
                     self.explode_cart(c, speed);
                     return false;
                 }
+                if c.horizontal_collision {
+                    let speed = c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z;
+                    if speed >= f64::from(0.01_f32) {
+                        self.explode_cart(c, speed);
+                        return false;
+                    }
+                }
             }
             _ => {}
         }

From 3615c65d18e24888cea2e6b3a7dda86c7ba5c7a6 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:11:01 +0100
Subject: [PATCH 073/475] Make allays drop what they carry on death and use the
 default pickup delay when throwing

---
 crates/horizon-client/src/game/allays.rs |  3 ++-
 crates/horizon-client/src/mobs/drops.rs  | 22 ++++++++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/allays.rs b/crates/horizon-client/src/game/allays.rs
index bed835663..dba4edfad 100644
--- a/crates/horizon-client/src/game/allays.rs
+++ b/crates/horizon-client/src/game/allays.rs
@@ -131,7 +131,8 @@ impl Game<'_> {
         let m = &mut self.mobs[i];
         m.extra.ints[1] -= 1;
         m.extra.ints[3] = 60;
-        self.spawn_item(ItemStack::new(&item, 1), from, v, 40);
+        // ItemEntity.setDefaultPickUpDelay.
+        self.spawn_item(ItemStack::new(&item, 1), from, v, 10);
         if self.world.game_time % 7 == 0 && self.world.random.next_double() < 0.9 {
             const PITCHES: [f32; 16] = [
                 0.5625, 0.625, 0.75, 0.9375, 1.0, 1.0, 1.125, 1.25, 1.5, 1.875, 2.0, 2.25, 2.5,
diff --git a/crates/horizon-client/src/mobs/drops.rs b/crates/horizon-client/src/mobs/drops.rs
index e5ccfd283..cdad5b7af 100644
--- a/crates/horizon-client/src/mobs/drops.rs
+++ b/crates/horizon-client/src/mobs/drops.rs
@@ -399,6 +399,15 @@ pub fn die(m: &mut Mob, d: &Death, sequences: &mut RandomSequences) -> (Vec<Drop
         out.push(Drop::Item(stack));
         clear_slot(m, "mainhand");
     }
+    // Allay: what it carries (`ints[1]` of the held item) is its inventory.
+    let allay_load = (s == Species::Allay)
+        .then(|| {
+            m.extra
+                .main_hand
+                .clone()
+                .map(|item| (item, m.extra.ints[1]))
+        })
+        .flatten();
     let drops_loot = d.mob_drops && (is_monster(s) || !m.is_baby());
     if drops_loot {
         let table = format!(
@@ -455,6 +464,19 @@ pub fn die(m: &mut Mob, d: &Death, sequences: &mut RandomSequences) -> (Vec<Drop
             out.push(Drop::Item(loot_stack("minecraft:nether_star", 1)));
         }
     }
+    // Allay.dropEquipment: its inventory, then the main-hand item unless it
+    // prevents equipment drops.
+    if let Some((item, carried)) = allay_load {
+        if carried > 0 {
+            out.push(Drop::Item(loot_stack(&item, carried)));
+        }
+        if let Some(stack) = slot_item(m, "mainhand")
+            && !d.loot.prevents_equipment_drop(&stack)
+        {
+            out.push(Drop::Item(stack));
+            clear_slot(m, "mainhand");
+        }
+    }
     // dropEquipment: AbstractHorse's inventory, then a chested horse's chest.
     if equine::is_equine(s) {
         for stack in m.extra.items.iter().flatten() {

From 9c3450622b8b94f69540e87fa4e629ab8e1c654c Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:11:49 +0100
Subject: [PATCH 074/475] Update comparators when a copper golem moves items in
 or out of a chest

---
 crates/horizon-client/src/game/copper_golems.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/game/copper_golems.rs b/crates/horizon-client/src/game/copper_golems.rs
index 2f98e1c7e..db4e03b0b 100644
--- a/crates/horizon-client/src/game/copper_golems.rs
+++ b/crates/horizon-client/src/game/copper_golems.rs
@@ -44,13 +44,13 @@ impl Game<'_> {
         slot: usize,
         stack: Option<ItemStack>,
     ) {
-        if let Some(e) = self
-            .world
-            .block_entities
-            .get_mut(&(chest[0], chest[1], chest[2]))
+        let key = (chest[0], chest[1], chest[2]);
+        if let Some(e) = self.world.block_entities.get_mut(&key)
             && let Some(s) = e.slots_mut().get_mut(slot)
         {
             *s = stack;
+            // TransportItemsBetweenContainers calls Container.setChanged.
+            self.container_changed(key);
         }
     }
     /// `ContainerOpenersCounter.recheckOpeners` every five ticks: the golems

From b7c47ccbf9398b2131927f4c07d736f6228a2a4e Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:11:52 +0100
Subject: [PATCH 075/475] Let a sneaking player open chest and hopper minecarts

---
 crates/horizon-client/src/game/minecarts.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index a19b6df73..d7c57fca9 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -1063,10 +1063,8 @@ impl Game<'_> {
                 }
                 self.riding = Some(self.carts[i].id);
             }
+            // AbstractMinecartContainer.interact: no sneak check.
             CartKind::Chest | CartKind::Hopper => {
-                if sneaking {
-                    return false;
-                }
                 let c = self.carts[i].clone();
                 let key = (i32::MAX - 15, CART_KEY_Y, c.id as i32);
                 self.world

From 0a5e80de7ba474d420e5c215cabb7ac134817a5b Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:12:33 +0100
Subject: [PATCH 076/475] Step out of a minecart in vanilla's order

---
 crates/horizon-client/src/game/minecarts.rs | 30 +++++++++++++--------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index a19b6df73..454b15245 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -942,7 +942,7 @@ impl Game<'_> {
         }
         true
     }
-    /// `getDismountLocationForPassenger`: beside the cart (across its motion), else on top.
+    /// `getDismountLocationForPassenger`: beside the cart (across its facing), else on top.
     pub(super) fn dismount_cart(&mut self, i: usize) {
         self.riding = None;
         let c = &self.carts[i];
@@ -952,17 +952,25 @@ impl Game<'_> {
             c.position.z.floor() as i32,
         );
         let mut target = None;
+        // DismountHelper.offsetsForDirection of the cart's facing
+        // (Direction.fromYRot of its yaw): right, left, back right, back left,
+        // forward right, forward left, back, forward.
+        let step = |q: i32| [(0, 1), (-1, 0), (0, -1), (1, 0)][(q & 3) as usize];
+        let facing = (f64::from(c.yaw) / 90.0 + 0.5).floor() as i32;
+        let (fx, fz) = step(facing);
+        let (rx, rz) = (-fz, fx);
+        let offsets = [
+            (rx, rz),
+            (-rx, -rz),
+            (rx - fx, rz - fz),
+            (-rx - fx, -rz - fz),
+            (fx + rx, fz + rz),
+            (fx - rx, fz - rz),
+            (-fx, -fz),
+            (fx, fz),
+        ];
         'search: for dy in [0, 1, -1] {
-            for (dx, dz) in [
-                (1, 0),
-                (-1, 0),
-                (0, 1),
-                (0, -1),
-                (1, 1),
-                (-1, -1),
-                (1, -1),
-                (-1, 1),
-            ] {
+            for (dx, dz) in offsets {
                 let (x, y, z) = (bx + dx, by + dy, bz + dz);
                 let below = self.res.facts().get(self.world.block(x, y - 1, z));
                 let here = self.res.facts().get(self.world.block(x, y, z));

From cc39d57e070d73b84080e031157704f2295529ce Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:12:42 +0100
Subject: [PATCH 077/475] Explosions empty and anger the bees of destroyed
 hives

---
 crates/horizon-client/src/game/beehives.rs  |  2 +-
 crates/horizon-client/src/game/combat.rs    |  4 +++
 crates/horizon-client/src/game/creatures.rs | 10 ++++++-
 crates/horizon-client/src/game/explosion.rs | 29 +++++++++++++++++++++
 crates/horizon-client/src/game/minecarts.rs |  4 ++-
 crates/horizon-client/src/game/tnt.rs       |  4 ++-
 crates/horizon-client/src/game/wither.rs    |  2 +-
 7 files changed, 50 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/game/beehives.rs b/crates/horizon-client/src/game/beehives.rs
index b7f7efb1a..258610f5e 100644
--- a/crates/horizon-client/src/game/beehives.rs
+++ b/crates/horizon-client/src/game/beehives.rs
@@ -196,7 +196,7 @@ impl Game<'_> {
     }
     /// `BeehiveBlock.angerNearbyBees`: bees within 8 blocks (6 up and down)
     /// without a target go for a player in the same box.
-    fn anger_nearby_bees(&mut self, at: [i32; 3]) {
+    pub(super) fn anger_nearby_bees(&mut self, at: [i32; 3]) {
         let min = Vec3::new(
             f64::from(at[0]) - 8.0,
             f64::from(at[1]) - 6.0,
diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs
index 106e0e1a1..91cf5c61b 100644
--- a/crates/horizon-client/src/game/combat.rs
+++ b/crates/horizon-client/src/game/combat.rs
@@ -31,6 +31,10 @@ pub(super) struct CombatTracker {
     /// The mob exploding now (`ServerExplosion.source`): its team's friendly
     /// fire decides whom the blast may hurt.
     pub(super) explosion_source: Option<u32>,
+    /// The blast now going off comes from a primed TNT, creeper, wither
+    /// skull, wither or TNT minecart, the sources that empty a hive they
+    /// destroy (`BeehiveBlock.getDrops`).
+    pub(super) hive_emptying_blast: bool,
     /// The player's fall distance before this tick's movement (as of the
     /// end of the last one).
     fall_before: f64,
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..6e6610dcc 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -915,7 +915,15 @@ impl Game<'_> {
                         self.note_attacker("minecraft:explosion", id);
                     }
                     self.combat.explosion_source = source_mob;
-                    let result = self.explode(at, radius);
+                    // Only a creeper or a wither empties the hives it blows up.
+                    let empties_hives = source_mob
+                        .and_then(|id| self.mobs.iter().find(|m| m.id == id))
+                        .is_some_and(|m| matches!(m.species(), Species::Creeper | Species::Wither));
+                    let result = if empties_hives {
+                        self.with_hive_emptying_blast(|g| g.explode(at, radius))
+                    } else {
+                        self.explode(at, radius)
+                    };
                     self.combat.explosion_source = None;
                     result?
                 }
diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs
index 6ecba3a54..805e4ebff 100644
--- a/crates/horizon-client/src/game/explosion.rs
+++ b/crates/horizon-client/src/game/explosion.rs
@@ -489,6 +489,15 @@ impl Game<'_> {
             );
         }
     }
+    /// Runs an explosion whose source empties the hives it destroys
+    /// (`BeehiveBlock.getDrops`: primed TNT, creeper, wither skull, wither,
+    /// TNT minecart).
+    pub(super) fn with_hive_emptying_blast<R>(&mut self, blast: impl FnOnce(&mut Self) -> R) -> R {
+        self.combat.hive_emptying_blast = true;
+        let result = blast(self);
+        self.combat.hive_emptying_blast = false;
+        result
+    }
     /// `Level.explode` on the server: positions, entities, blocks, fire; then
     /// the client's explosion sound.
     pub(super) fn server_explode(
@@ -600,6 +609,22 @@ impl Game<'_> {
         // Block.onExplosionHit: the drops copy from the block entity, which
         // then spills its contents as the block turns to air.
         let key = (pos[0], pos[1], pos[2]);
+        let is_hive = matches!(&*name, "minecraft:beehive" | "minecraft:bee_nest");
+        // BeehiveBlock.getDrops: the bees of a hive blown up by TNT, a
+        // creeper, a wither skull, a wither or a TNT minecart come out.
+        if is_hive && self.combat.hive_emptying_blast {
+            let facing = self
+                .pack
+                .assets
+                .registry
+                .state(state)
+                .and_then(|s| s.properties.get("facing").cloned());
+            self.empty_hive(
+                pos,
+                horizon_client::beehive::facing_step(facing.as_deref()),
+                horizon_client::beehive::Release::Emergency,
+            );
+        }
         if let Some(entity) = self.world.block_entities.get(&key).cloned() {
             let custom = self.world.block_names.get(&key).cloned();
             self.pending.record(pos, &entity, &name, custom);
@@ -631,6 +656,10 @@ impl Game<'_> {
         }
         self.pending.clear(pos);
         self.level_set(pos, self.world.air)?;
+        // BeehiveBlock.onExplosionHit: the bees about turn on the player.
+        if is_hive {
+            self.anger_nearby_bees(pos);
+        }
         // TntBlock.wasExploded: new PrimedTnt (its push drawn first), then
         // getRandomShortFuse(80); no game event.
         if is_tnt && self.ui.rules.bool("tnt_explodes") {
diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index a19b6df73..d21c99a55 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -640,7 +640,9 @@ impl Game<'_> {
         // The cart is the explosion's source: it is gone before the blast
         // looks for entities, so it can't hit itself.
         self.carts.retain(|x| x.id != c.id);
-        let _ = self.server_explode(at, power, BlockInteraction::Destroy, false);
+        let _ = self.with_hive_emptying_blast(|g| {
+            g.server_explode(at, power, BlockInteraction::Destroy, false)
+        });
     }
     /// `MinecartHopper.suckInItems`: items above, into the five slots.
     fn hopper_cart_pickup(&mut self, c: &mut Minecart) {
diff --git a/crates/horizon-client/src/game/tnt.rs b/crates/horizon-client/src/game/tnt.rs
index 6bd2ae956..14d80c90e 100644
--- a/crates/horizon-client/src/game/tnt.rs
+++ b/crates/horizon-client/src/game/tnt.rs
@@ -178,7 +178,9 @@ impl Game<'_> {
                 ];
                 self.tnts.remove(i);
                 count -= 1;
-                self.server_explode(center, 4.0, BlockInteraction::Destroy, false)?;
+                self.with_hive_emptying_blast(|g| {
+                    g.server_explode(center, 4.0, BlockInteraction::Destroy, false)
+                })?;
             } else {
                 i += 1;
             }
diff --git a/crates/horizon-client/src/game/wither.rs b/crates/horizon-client/src/game/wither.rs
index 8084425ca..789e5cf68 100644
--- a/crates/horizon-client/src/game/wither.rs
+++ b/crates/horizon-client/src/game/wither.rs
@@ -130,7 +130,7 @@ impl Game<'_> {
         if let Some(id) = owner {
             self.note_attacker("minecraft:explosion", id);
         }
-        self.explode(at, 1.0)
+        self.with_hive_emptying_blast(|g| g.explode(at, 1.0))
     }
 }
 /// Wither skulls drawn as the skull model, blue when dangerous.

From a5fa40d2eea6609a3c567601059cdcf29415c4a3 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:12:48 +0100
Subject: [PATCH 078/475] Fire the villager_trade trigger so What a Deal! can
 be earned

---
 .../horizon-client/src/game/advancements.rs   | 21 ++++++++++++++
 crates/horizon-client/src/game/lan_trading.rs |  7 ++++-
 crates/horizon-client/src/game/trading.rs     | 28 +++++++++++++++----
 3 files changed, 50 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs
index 0f76d0ca9..f7bafd767 100644
--- a/crates/horizon-client/src/game/advancements.rs
+++ b/crates/horizon-client/src/game/advancements.rs
@@ -708,6 +708,27 @@ impl Game<'_> {
         let it = item_view(stack);
         self.trigger(name, |c, w| adv::item_entity(c, &me, target, &it, w));
     }
+    /// `TradeTrigger`: the villager and the item the trade gave.
+    pub(super) fn trigger_trade(&mut self, villager: &EntityView, stack: &ItemStack) {
+        let me = self.player_entity();
+        let villager = villager.clone();
+        let it = item_view(stack);
+        self.trigger("minecraft:villager_trade", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            let vctx = adv::Entities {
+                this: Some(&villager),
+                ..pctx
+            };
+            adv::conditions(&c["player"], &pctx, w)
+                && adv::conditions(&c["villager"], &vctx, w)
+                && adv::item(&c["item"], &it, w)
+        });
+    }
     /// `EnterBlockTrigger`: the block, its state properties and the player.
     pub(super) fn trigger_enter_block(&mut self, state: horizon_world::registry::BlockStateId) {
         let Some(definition) = self.pack.assets.registry.state(state).cloned() else {
diff --git a/crates/horizon-client/src/game/lan_trading.rs b/crates/horizon-client/src/game/lan_trading.rs
index 1bec9809d..9e8fa55b3 100644
--- a/crates/horizon-client/src/game/lan_trading.rs
+++ b/crates/horizon-client/src/game/lan_trading.rs
@@ -276,7 +276,12 @@ impl Game<'_> {
             g.carried = menu.carried.take();
         }
         self.register_exploration_maps(made);
-        gm.merchant.session = self.merchant_apply(session, gm.merchant.mob);
+        let (session, traded) = self.merchant_apply(session, gm.merchant.mob);
+        gm.merchant.session = session;
+        if !traded.is_empty() {
+            // The guest's own statistic and advancements.
+            self.as_guest(host, conn, |g| g.merchant_traded(gm.merchant.mob, &traded));
+        }
         self.drop_guest_items(host, gi, dropped);
         self.lan_send_offers(host, conn, &mut gm, false);
         self.lan_send_merchant_content(host, conn, &mut gm);
diff --git a/crates/horizon-client/src/game/trading.rs b/crates/horizon-client/src/game/trading.rs
index 87e0c18c6..4eaf00ec9 100644
--- a/crates/horizon-client/src/game/trading.rs
+++ b/crates/horizon-client/src/game/trading.rs
@@ -398,18 +398,21 @@ impl Game<'_> {
             .as_ref()
             .and_then(|s| s.merchant.as_ref())
             .and_then(|m| m.mob);
-        let session = self.merchant_apply(session, mob);
+        let (session, traded) = self.merchant_apply(session, mob);
+        self.merchant_traded(mob, &traded);
         if let Some(m) = self.station.as_mut().and_then(|s| s.merchant.as_mut()) {
             m.session = session;
         }
     }
-    /// What a menu click's session did, applied to the world and its mob.
+    /// What a menu click's session did, applied to the world and its mob;
+    /// with the result of each trade made, for `merchant_traded`.
     pub(super) fn merchant_apply(
         &mut self,
         session: Box<merchant::Session>,
         mob: Option<u32>,
-    ) -> Box<merchant::Session> {
+    ) -> (Box<merchant::Session>, Vec<ItemStack>) {
         let mut session = session;
+        let mut traded = Vec::new();
         let events = std::mem::take(&mut session.events);
         let (villager, origin) = (session.villager, session.origin);
         if let Some(m) = mob.and_then(|id| self.mobs.iter_mut().find(|m| m.id == id)) {
@@ -438,11 +441,26 @@ impl Game<'_> {
                     };
                     self.audio.play(sound, Some(origin), 1.0, pitch);
                 }
-                merchant::Event::Traded(_) => self.stats.custom("traded_with_villager", 1),
+                merchant::Event::Traded(index) => {
+                    traded.extend(session.offers.get(index).map(|o| o.result.clone()));
+                }
                 merchant::Event::TradeSound => {}
             }
         }
-        session
+        (session, traded)
+    }
+    /// `MerchantResultSlot.checkTakeAchievements` and `AbstractVillager.notifyTrade`
+    /// for each trade made: the statistic and the `villager_trade` trigger.
+    pub(super) fn merchant_traded(&mut self, mob: Option<u32>, results: &[ItemStack]) {
+        for result in results {
+            self.stats.custom("traded_with_villager", 1);
+            let villager = mob
+                .and_then(|id| self.mobs.iter().find(|m| m.id == id))
+                .map(|m| self.mob_entity(m));
+            if let Some(villager) = villager {
+                self.trigger_trade(&villager, result);
+            }
+        }
     }
     /// `Villager.customServerAiStep`: the TRADE reputation event of the last
     /// trade, a tick later; the prices follow the new reputation.

From 00e2cfec294cae389cb742de5e022f2e43f4ae10 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:12:57 +0100
Subject: [PATCH 079/475] Let tadpoles be fed slime balls to grow up faster

---
 crates/horizon-client/src/game/creatures.rs      | 13 +++++++++++++
 crates/horizon-client/src/game/remote_mob_use.rs |  7 +++++--
 crates/horizon-client/src/mobs/species.rs        |  2 +-
 3 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..fb3cea6bb 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2797,6 +2797,19 @@ impl Game<'_> {
                     self.trigger_entity("minecraft:tame_animal", "entity", &view);
                 }
             }
+            // Tadpole.feed: frog food ages it by a tenth of the time left to
+            // grow into a frog (it grows on its next tick once past 24000).
+            Species::Tadpole if is_food && !m.extra.age_locked => {
+                consume = true;
+                let left = 24_000 - m.extra.age;
+                m.extra.age += ((left / 20) as f32 * 0.1) as i32 * 20;
+                // One happy villager particle at rest about the body.
+                self.particles_around_mob(
+                    self.mobs[index].id,
+                    "happy_villager",
+                    horizon_client::particles::Burst::HORSE_EATING,
+                );
+            }
             // HappyGhast.canFallInLove: never, so only a ghastling takes food.
             _ if is_food
                 && m.kind.flags.animal
diff --git a/crates/horizon-client/src/game/remote_mob_use.rs b/crates/horizon-client/src/game/remote_mob_use.rs
index 9575cf925..bd38c7301 100644
--- a/crates/horizon-client/src/game/remote_mob_use.rs
+++ b/crates/horizon-client/src/game/remote_mob_use.rs
@@ -66,8 +66,11 @@ impl Game<'_> {
             | Species::Salmon
             | Species::TropicalFish
             | Species::Pufferfish
-            | Species::Axolotl
-            | Species::Tadpole => item == "minecraft:water_bucket",
+            | Species::Axolotl => item == "minecraft:water_bucket",
+            // Tadpole.mobInteract: frog food, else the bucket.
+            Species::Tadpole => {
+                item == "minecraft:water_bucket" || m.kind.food.iter().any(|f| f.as_str() == item)
+            }
             Species::Armadillo => item == "minecraft:brush",
             // ZombieVillager.mobInteract: CONSUME for a golden apple.
             Species::ZombieVillager => item == "minecraft:golden_apple",
diff --git a/crates/horizon-client/src/mobs/species.rs b/crates/horizon-client/src/mobs/species.rs
index f48a21fe9..3f3ff4e31 100644
--- a/crates/horizon-client/src/mobs/species.rs
+++ b/crates/horizon-client/src/mobs/species.rs
@@ -1581,7 +1581,7 @@ impl Def {
             S::Bee => "bee_food",
             S::Turtle => "turtle_food",
             S::Armadillo => "armadillo_food",
-            S::Frog => "frog_food",
+            S::Frog | S::Tadpole => "frog_food",
             S::Axolotl => "axolotl_food",
             S::Hoglin => "hoglin_food",
             S::Strider => "strider_food",

From a4d0f76edd735cc6bcb5a9452679759564ebb3b8 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:13:08 +0100
Subject: [PATCH 080/475] Count movement statistics as vanilla does

Fall distance is counted once per landing from 2 blocks or more instead of on
every downward tick. Riding counts only for the mounts vanilla lists (pig,
horse family by full distance, strider, happy ghast, nautilus, boat, minecart),
and airborne sideways moves over 25 cm count as flying.
---
 crates/horizon-client/src/game.rs             |  4 +++
 crates/horizon-client/src/game/lan_actions.rs |  7 ++++
 crates/horizon-client/src/game/stats.rs       | 32 +++++++++++++------
 3 files changed, 33 insertions(+), 10 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..5ac53d7df 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4421,6 +4421,10 @@ impl Game<'_> {
                     };
                     self.audio.play(name, Some(feet), volume, pitch);
                 }
+                // Player.causeFallDamage: a fall of 2 blocks or more counts.
+                MotionEvent::Fall(horizon_client::landing::FallEvent::Statistic(cm)) => {
+                    self.stats.custom("fall_one_cm", cm)
+                }
                 MotionEvent::Fall(event) => self.landing_block_updates(&event),
                 MotionEvent::Snowflake { position, velocity } => self.snowflake(position, velocity),
                 MotionEvent::EnterBlock { state } => self.trigger_enter_block(state),
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 0ad14bbcc..644ec7785 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -2252,6 +2252,13 @@ impl Game<'_> {
             // ServerEntity.sendChanges sends it as it is after this travel.
             let marked = std::mem::take(&mut player.health.sync_velocity);
             let velocity = marked.then_some(player.velocity);
+            // Player.causeFallDamage: a fall of 2 blocks or more counts.
+            for event in &events {
+                if let MotionEvent::Fall(horizon_client::landing::FallEvent::Statistic(cm)) = event
+                {
+                    game.stats.custom("fall_one_cm", *cm);
+                }
+            }
             game.record_combat(&events);
             (events, velocity)
         });
diff --git a/crates/horizon-client/src/game/stats.rs b/crates/horizon-client/src/game/stats.rs
index 7f64c6bb2..68a574eb1 100644
--- a/crates/horizon-client/src/game/stats.rs
+++ b/crates/horizon-client/src/game/stats.rs
@@ -256,9 +256,8 @@ impl Game<'_> {
             .fluid
             == horizon_client::blocks::Fluid::Water;
         let on_ground = p.ground.on_ground;
-        let (sprinting, flying, gliding, swimming) = (
+        let (sprinting, gliding, swimming) = (
             p.sprinting,
-            p.flying,
             p.fall_flying,
             p.pose == horizon_client::pose::Pose::Swimming,
         );
@@ -272,15 +271,27 @@ impl Game<'_> {
         });
         let s = &mut self.stats;
         match riding {
-            Some(Ok(horizon_client::mobs::Species::Pig)) => s.custom("pig_one_cm", total),
-            Some(Ok(horizon_client::mobs::Species::Strider)) => s.custom("strider_one_cm", total),
-            Some(Ok(sp)) if horizon_client::mobs::equine::is_equine(sp) => {
-                s.custom("horse_one_cm", horizontal)
+            Some(Ok(sp)) => {
+                use horizon_client::mobs::Species;
+                // `checkRidingStatistics`: only these mounts count, the horse
+                // family by the full 3D distance; any other mount nothing.
+                match sp {
+                    Species::Pig => s.custom("pig_one_cm", total),
+                    Species::Strider => s.custom("strider_one_cm", total),
+                    Species::HappyGhast => s.custom("happy_ghast_one_cm", total),
+                    Species::Nautilus | Species::ZombieNautilus => {
+                        s.custom("nautilus_one_cm", total)
+                    }
+                    sp if horizon_client::mobs::equine::is_equine(sp) => {
+                        s.custom("horse_one_cm", total)
+                    }
+                    _ => {}
+                }
             }
-            Some(_) => {
+            Some(Err(())) => {
                 if self.boats.iter().any(|b| Some(b.id) == self.riding) {
                     s.custom("boat_one_cm", total)
-                } else {
+                } else if self.carts.iter().any(|c| Some(c.id) == self.riding) {
                     s.custom("minecart_one_cm", total)
                 }
             }
@@ -300,8 +311,9 @@ impl Game<'_> {
                 }
             }
             None if gliding => s.custom("aviate_one_cm", total),
-            None if flying => s.custom("fly_one_cm", horizontal),
-            None if d.y < 0.0 => s.custom("fall_one_cm", (-d.y * 100.0).round() as i32),
+            // Airborne and not gliding: more than 25 cm sideways per move
+            // (creative flight, or a long jump), not only flying.
+            None if horizontal > 25 => s.custom("fly_one_cm", horizontal),
             None => {}
         }
     }

From 2a0824cf5f532d1671e71b878dd03673be6ec0a2 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:13:15 +0100
Subject: [PATCH 081/475] Invisible players are harder for mobs to notice

Mobs now scale their detection range by 0.7 times the worn armor fraction (at least 0.1) when the player has Invisibility, like vanilla's getVisibilityPercent.
---
 .../horizon-client/examples/probe/mob_ai_probe.rs |  1 +
 crates/horizon-client/src/game/creatures.rs       |  1 +
 crates/horizon-client/src/game/lan_mobs.rs        |  1 +
 crates/horizon-client/src/mobs.rs                 | 15 +++++++++++++++
 crates/horizon-client/src/mobs/animal_brain.rs    |  3 +--
 crates/horizon-client/src/mobs/goals.rs           |  5 +----
 crates/horizon-client/src/mobs/happy_ghast.rs     |  3 +--
 7 files changed, 21 insertions(+), 8 deletions(-)

diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs
index ecdf02901..033ef6faa 100644
--- a/crates/horizon-client/examples/probe/mob_ai_probe.rs
+++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs
@@ -1050,6 +1050,7 @@ pub fn main() -> horizon_client::Result<()> {
                 off_hand: None,
                 head: None,
                 armor_cover: 0.0,
+                invisible: false,
                 spectator: false,
                 gold_armor: false,
                 hurt_by: None,
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..ae31d23dd 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -186,6 +186,7 @@ impl Game<'_> {
             off_hand: None,
             head: self.armor[0].as_ref().map(|s| s.item.clone()),
             armor_cover: self.armor.iter().filter(|a| a.is_some()).count() as f32 / 4.0,
+            invisible: self.potions.effects.get("invisibility").is_some(),
             spectator: self.spectator(),
             gold_armor: self.wearing_gold(),
             hurt_by: self.player_hurt_by(),
diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs
index 4f53cec60..88632c7aa 100644
--- a/crates/horizon-client/src/game/lan_mobs.rs
+++ b/crates/horizon-client/src/game/lan_mobs.rs
@@ -363,6 +363,7 @@ mod tests {
             off_hand: None,
             head: None,
             armor_cover: 0.0,
+            invisible: false,
             spectator: false,
             gold_armor: false,
             hurt_by: None,
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..ba9d63080 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1448,6 +1448,8 @@ pub struct PlayerView {
     pub off_hand: Option<Arc<str>>,
     pub head: Option<Arc<str>>,
     pub armor_cover: f32,
+    /// The Invisibility effect (`isInvisible`).
+    pub invisible: bool,
     pub spectator: bool,
     /// `PiglinAi.isWearingSafeArmor`: some golden armour.
     pub gold_armor: bool,
@@ -1468,6 +1470,19 @@ pub struct PlayerView {
     /// (`EntitySelector.pushableBy` on the client).
     pub remote: bool,
 }
+impl PlayerView {
+    /// `LivingEntity.getVisibilityPercent` without the worn-skull scaling.
+    pub fn visibility_percent(&self) -> f64 {
+        let mut visibility = 1.0;
+        if self.sneaking {
+            visibility *= 0.8;
+        }
+        if self.invisible {
+            visibility *= 0.7 * f64::from(self.armor_cover).max(0.1);
+        }
+        visibility
+    }
+}
 #[derive(Clone)]
 pub struct MobWorld<'a> {
     pub world: &'a World,
diff --git a/crates/horizon-client/src/mobs/animal_brain.rs b/crates/horizon-client/src/mobs/animal_brain.rs
index bd0eb9c90..d928c34ee 100644
--- a/crates/horizon-client/src/mobs/animal_brain.rs
+++ b/crates/horizon-client/src/mobs/animal_brain.rs
@@ -625,8 +625,7 @@ fn targetable(m: &mut Mob, w: &MobWorld, who: Who) -> bool {
             // TargetingConditions.forNonCombat(): in range (scaled by the
             // player's visibility, at least 2) and in sight.
             let Some(p) = &w.player else { return false };
-            let visibility = if p.sneaking { 0.8 } else { 1.0 };
-            let r = (range * visibility).max(2.0);
+            let r = (range * p.visibility_percent()).max(2.0);
             p.alive && !p.spectator && m.distance_sqr(p.position) <= r * r && m.sees(w, who)
         }
         Who::Mob(id) => {
diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs
index 7f73e32c4..c44614571 100644
--- a/crates/horizon-client/src/mobs/goals.rs
+++ b/crates/horizon-client/src/mobs/goals.rs
@@ -601,10 +601,7 @@ impl Mob {
             return false;
         }
         // LivingEntity.getVisibilityPercent
-        let mut visibility = 1.0;
-        if p.sneaking {
-            visibility *= 0.8;
-        }
+        let mut visibility = p.visibility_percent();
         if let Some(head) = &p.head {
             let skull = match self.species() {
                 Species::Zombie | Species::Husk | Species::Drowned | Species::ZombieVillager => {
diff --git a/crates/horizon-client/src/mobs/happy_ghast.rs b/crates/horizon-client/src/mobs/happy_ghast.rs
index bd4c5b1f3..efcbf5246 100644
--- a/crates/horizon-client/src/mobs/happy_ghast.rs
+++ b/crates/horizon-client/src/mobs/happy_ghast.rs
@@ -364,8 +364,7 @@ impl Goal for GhastTempt {
         let Some(p) = &cx.w.player else { return false };
         // getNearestPlayer(TargetingConditions.forNonCombat()
         // .ignoreLineOfSight().range(TEMPT_RANGE 16)): creative players too.
-        let visibility = if p.sneaking { 0.8 } else { 1.0 };
-        let range = (16.0_f64 * visibility).max(2.0);
+        let range = (16.0_f64 * p.visibility_percent()).max(2.0);
         p.alive
             && !p.spectator
             && (Self::wants(m, &p.main_hand) || Self::wants(m, &p.off_hand))

From e2a399aff0ee5463e9059a9a3dd49cb67e5167db Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:13:19 +0100
Subject: [PATCH 082/475] Reopen signs on right click and apply dyes, ink sacs
 and honeycomb

Right-clicking a placed sign opened an empty inventory screen. It now
opens the editor for the side the player faces, or plays the waxed-sign
fail sound. Dyes, glow ink sacs, ink sacs and honeycomb change the
colour, glow or wax of the side the player faces and are used up.
---
 crates/horizon-client/src/game.rs           |   9 ++
 crates/horizon-client/src/game/sign_edit.rs | 152 +++++++++++++++++++-
 2 files changed, 160 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..35371a766 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -3014,6 +3014,11 @@ impl Game<'_> {
             self.open_command_block(key);
             return;
         }
+        // SignBlock.useWithoutItem: the text editor, not a container.
+        if horizon_client::signs::sign_kind(&name).is_some() {
+            self.use_sign_empty_hand(pos);
+            return;
+        }
         if &*name == "minecraft:crafting_table" {
             self.craft_size = 3;
             self.craft_table = Some(pos);
@@ -3519,6 +3524,10 @@ impl Game<'_> {
                 self.swing_arm();
                 return Ok(true);
             }
+            if self.use_sign_applicator(hit.pos, held.as_ref()) {
+                self.swing_arm();
+                return Ok(true);
+            }
             if self.use_jukebox(hit.pos, held.as_ref()) {
                 self.swing_arm();
                 return Ok(true);
diff --git a/crates/horizon-client/src/game/sign_edit.rs b/crates/horizon-client/src/game/sign_edit.rs
index 2f50ad9ab..ea0abad3e 100644
--- a/crates/horizon-client/src/game/sign_edit.rs
+++ b/crates/horizon-client/src/game/sign_edit.rs
@@ -5,7 +5,8 @@ use super::{Game, lan::LanHost};
 use horizon_client::{
     containers::BlockEntity,
     hud::{HudBatch, rgba},
-    signs::wood_type,
+    items::ItemStack,
+    signs::{DYE_TEXT, wood_type},
 };
 use horizon_protocol::packets::play::{self, Clientbound as C, Serverbound as S};
 use std::time::Instant;
@@ -22,6 +23,155 @@ pub(super) struct SignEditor {
 }
 
 impl Game<'_> {
+    /// `SignBlockEntity.getSlotPlayerIsFacing`: whether the player stands in
+    /// front of the sign's text (within 90 degrees of its facing).
+    fn facing_sign_front(&self, pos: (i32, i32, i32)) -> bool {
+        let Some(player) = self.player.as_ref() else {
+            return true;
+        };
+        let state = self.world.block(pos.0, pos.1, pos.2);
+        let Some(state) = self.pack.assets.registry.state(state) else {
+            return true;
+        };
+        let prop = |key: &str| state.properties.get(key).map(String::as_str);
+        // getYRotationDegrees: a wall sign's `Direction.toYRot`, a standing or
+        // ceiling sign's rotation segment.
+        let y_rot = if state.name.contains("_wall_") {
+            match prop("facing") {
+                Some("west") => 90.0,
+                Some("north") => 180.0,
+                Some("east") => 270.0,
+                _ => 0.0,
+            }
+        } else {
+            prop("rotation")
+                .and_then(|r| r.parse::<f32>().ok())
+                .unwrap_or(0.0)
+                * 22.5
+        };
+        // getSignHitboxCenterPosition: only a wall sign's board is off-centre,
+        // against the wall it hangs on.
+        let centre = if state.name.ends_with("_wall_sign") {
+            match y_rot as i32 {
+                90 => (0.9375, 0.5),
+                180 => (0.5, 0.9375),
+                270 => (0.0625, 0.5),
+                _ => (0.5, 0.0625),
+            }
+        } else {
+            (0.5, 0.5)
+        };
+        let xd = player.position.x - (f64::from(pos.0) + centre.0);
+        let zd = player.position.z - (f64::from(pos.2) + centre.1);
+        let player_y_rot = (zd.atan2(xd).to_degrees() - 90.0) as f32;
+        // Mth.degreesDifferenceAbs.
+        let diff = (player_y_rot - y_rot).rem_euclid(360.0);
+        let diff = if diff >= 180.0 { 360.0 - diff } else { diff };
+        diff <= 90.0
+    }
+    /// `SignBlock.useWithoutItem` (the block's `OpenMenu` effect): a waxed
+    /// sign plays the failed-interaction sound; otherwise a player who may
+    /// build edits the side they face.
+    pub(super) fn use_sign_empty_hand(&mut self, pos: [i32; 3]) {
+        let key = (pos[0], pos[1], pos[2]);
+        let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get(&key) else {
+            return;
+        };
+        if sign.waxed {
+            self.audio.play(
+                "minecraft:block.sign.waxed_interact_fail",
+                Some(pos.map(|v| f64::from(v) + 0.5)),
+                1.0,
+                1.0,
+            );
+        } else if self.may_build() {
+            let front = self.facing_sign_front(key);
+            self.open_sign_editor(key, front);
+        }
+    }
+    /// `SignBlock.useItemOn` with a `SignApplicator` in hand (dyes, ink sacs,
+    /// honeycomb): the item changes the side the player faces and is used up.
+    /// Whether it did; a sign it does not apply to goes on to the empty hand.
+    pub(super) fn use_sign_applicator(&mut self, pos: [i32; 3], held: Option<&ItemStack>) -> bool {
+        let Some(stack) = held else {
+            return false;
+        };
+        let key = (pos[0], pos[1], pos[2]);
+        let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get(&key) else {
+            return false;
+        };
+        if sign.waxed || !self.may_build() {
+            return false;
+        }
+        let item = &*stack.item;
+        let dye = if item.ends_with("_dye") {
+            self.res
+                .items()
+                .get(&stack.item)
+                .and_then(|i| i.dye.clone())
+        } else {
+            None
+        };
+        let colour = dye.and_then(|d| DYE_TEXT.iter().position(|(n, _)| *n == d));
+        if !matches!(
+            item,
+            "minecraft:honeycomb" | "minecraft:glow_ink_sac" | "minecraft:ink_sac"
+        ) && colour.is_none()
+        {
+            return false;
+        }
+        let front = self.facing_sign_front(key);
+        let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&key) else {
+            return false;
+        };
+        let centre = pos.map(|v| f64::from(v) + 0.5);
+        let sound = if item == "minecraft:honeycomb" {
+            // HoneycombItem.tryApplyToSign: waxes any sign, empty or not.
+            sign.waxed = true;
+            "minecraft:item.honeycomb.wax_on"
+        } else {
+            let side = if front {
+                &mut sign.front
+            } else {
+                &mut sign.back
+            };
+            // SignApplicator.canApplyToSign: the side must have text.
+            if side.is_empty() {
+                return false;
+            }
+            match colour {
+                Some(c) if side.color != c as u8 => {
+                    side.color = c as u8;
+                    "minecraft:item.dye.use"
+                }
+                None if item == "minecraft:glow_ink_sac" && !side.glowing => {
+                    side.glowing = true;
+                    "minecraft:item.glow_ink_sac.use"
+                }
+                None if item == "minecraft:ink_sac" && side.glowing => {
+                    side.glowing = false;
+                    "minecraft:item.ink_sac.use"
+                }
+                _ => return false,
+            }
+        };
+        if item == "minecraft:honeycomb" {
+            self.level_event_at(3003, pos, 0);
+        }
+        self.audio.play(sound, Some(centre), 1.0, 1.0);
+        self.mark_block_entity_updated(key);
+        let state = self.world.block(pos[0], pos[1], pos[2]);
+        self.post_block_game_event(
+            "minecraft:block_change",
+            pos,
+            self.sculk_actor(),
+            Some(state),
+        );
+        self.stats.add("used", &stack.item, 1);
+        self.consume_held();
+        self.trigger_block("minecraft:item_used_on_block", pos, stack);
+        true
+    }
     /// `SignBlock.openTextEdit` for the front side after placement.
     pub(super) fn open_sign_editor(&mut self, pos: (i32, i32, i32), front: bool) {
         self.sign_edit = Some(SignEditor {

From 329ce1b724aa72ee67dc1cfeeaeb884acb541399 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:13:27 +0100
Subject: [PATCH 083/475] Make armadillos shed scutes on their own

Armadillos never dropped scutes because nothing ran their shed timer.
Follow Armadillo.customServerAiStep: count down 5 to 10 minutes, then
drop a scute, play the sound and post the entity_place game event.
---
 crates/horizon-client/src/game/creatures.rs | 18 +++++++++++++++
 crates/horizon-client/src/mobs.rs           |  6 +++++
 crates/horizon-client/src/mobs/ai.rs        | 25 +++++++++++++++++++++
 3 files changed, 49 insertions(+)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..9a78bc2e5 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1221,6 +1221,24 @@ impl Game<'_> {
                         m.ai.aggressive |= aggressive;
                     }
                 }
+                MobEvent::ShedScute { mob, at, pitch } => {
+                    // shouldDropLoot: the `mob_drops` rule.
+                    if self.ui.rules.bool("mob_drops") {
+                        let table = "minecraft:gameplay/armadillo_shed";
+                        let drops = self.sequence_loot(table, table, None);
+                        for d in drops {
+                            self.spawn_at_location(Vec3::new(at[0], at[1], at[2]), 0.0, d);
+                        }
+                        self.audio.play(
+                            "minecraft:entity.armadillo.scute_drop",
+                            Some(at),
+                            1.0,
+                            pitch,
+                        );
+                        let ctx = self.who_context(Some(Who::Mob(mob)), None);
+                        self.post_game_event("minecraft:entity_place", at, ctx);
+                    }
+                }
                 MobEvent::GiftLoot { table, at } => {
                     let drops =
                         self.res
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..315bfdce2 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1131,6 +1131,12 @@ pub enum MobEvent {
         table: &'static str,
         at: [f64; 3],
     },
+    /// `Armadillo.customServerAiStep`: the armadillo sheds a scute.
+    ShedScute {
+        mob: u32,
+        at: [f64; 3],
+        pitch: f32,
+    },
     /// A lead snaps or loses its holder: the lead item drops when asked.
     LeashBreak {
         mob: u32,
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 8335cb745..8259ddccb 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -307,6 +307,10 @@ fn generic(m: &mut Mob) {
         g.add(5, Stroll::avoiding_water(if rabbit { 0.6 } else { 1.0 }));
         g.add(6, LookAtPlayer::new(6.0));
         g.add(7, RandomLookAround::default());
+        if m.kind.species == Species::Armadillo {
+            // Armadillo's constructor: pickNextScuteDropTime.
+            m.extra.egg_time = next_scute_time(m);
+        }
     }
 }
 /// Subclasses of `net.minecraft.world.entity.monster.Monster`.
@@ -930,9 +934,30 @@ fn server_ai_step(
     }
     m.jump_control_tick();
 }
+/// `Armadillo.pickNextScuteDropTime`: 5 to 10 minutes.
+fn next_scute_time(m: &mut Mob) -> i32 {
+    m.random.next_int_bound(20 * 60 * 5).unwrap_or(0) + 20 * 60 * 5
+}
+/// `Armadillo.customServerAiStep`: the scute timer. A baby only resets it
+/// (`shouldDropLoot`); the game checks the `mob_drops` rule.
+fn armadillo_server_ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
+    m.extra.egg_time -= 1;
+    if m.alive() && m.extra.egg_time <= 0 {
+        if !m.is_baby() {
+            let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0;
+            events.push(MobEvent::ShedScute {
+                mob: m.id,
+                at: [m.position.x, m.position.y, m.position.z],
+                pitch,
+            });
+        }
+        m.extra.egg_time = next_scute_time(m);
+    }
+}
 fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) {
     match m.species() {
         Species::Rabbit => super::rabbit::server_ai_step(m),
+        Species::Armadillo => armadillo_server_ai_step(m, cx.events),
         Species::Sheep => {}
         Species::Zombie
         | Species::Husk

From 84aba7b3d494f6d1315214c41a27464e14e8be87 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:13:27 +0100
Subject: [PATCH 084/475] Count talking to villagers under vanilla's statistic
 name

The statistic was written as talk_to_villager, but vanilla's key is
talked_to_villager, so the statistics screen and scoreboard criteria always
showed 0. Wandering traders already count through the same code.
---
 crates/horizon-client/src/game/trading.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/trading.rs b/crates/horizon-client/src/game/trading.rs
index 87e0c18c6..bd43e5af2 100644
--- a/crates/horizon-client/src/game/trading.rs
+++ b/crates/horizon-client/src/game/trading.rs
@@ -245,7 +245,7 @@ impl Game<'_> {
             self.handle_mob_events(events)?;
             return Ok(true);
         }
-        self.stats.custom("talk_to_villager", 1);
+        self.stats.custom("talked_to_villager", 1);
         self.ensure_offers(index);
         let m = &self.mobs[index];
         let trade = m.extra.trade.as_deref().cloned().unwrap_or_default();

From 183382cd2beead9560f0d6303106b9886dd3307c Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:13:34 +0100
Subject: [PATCH 085/475] Fire the fishing_rod_hooked trigger when a hook is
 reeled in

---
 .../horizon-client/src/game/advancements.rs   | 29 +++++++++++++++++++
 crates/horizon-client/src/game/fishing.rs     | 24 +++++++++++++--
 2 files changed, 51 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs
index 0f76d0ca9..082bf0d62 100644
--- a/crates/horizon-client/src/game/advancements.rs
+++ b/crates/horizon-client/src/game/advancements.rs
@@ -708,6 +708,35 @@ impl Game<'_> {
         let it = item_view(stack);
         self.trigger(name, |c, w| adv::item_entity(c, &me, target, &it, w));
     }
+    /// `FishingRodHookedTrigger`: the rod, what the hook is in (or the hook)
+    /// and the items it caught.
+    pub(super) fn trigger_fishing_rod_hooked(
+        &mut self,
+        rod: &ItemStack,
+        hooked: &EntityView,
+        items: &[ItemStack],
+    ) {
+        let me = self.player_entity();
+        let rod = item_view(rod);
+        let hooked = hooked.clone();
+        let items: Vec<ItemView> = items.iter().map(item_view).collect();
+        self.trigger("minecraft:fishing_rod_hooked", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            let ectx = adv::Entities {
+                this: Some(&hooked),
+                ..pctx
+            };
+            adv::conditions(&c["player"], &pctx, w)
+                && adv::item(&c["rod"], &rod, w)
+                && adv::conditions(&c["entity"], &ectx, w)
+                && (c["item"].is_null() || items.iter().any(|i| adv::item(&c["item"], i, w)))
+        });
+    }
     /// `EnterBlockTrigger`: the block, its state properties and the player.
     pub(super) fn trigger_enter_block(&mut self, state: horizon_world::registry::BlockStateId) {
         let Some(definition) = self.pack.assets.registry.state(state).cloned() else {
diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs
index d454df406..33d93fb82 100644
--- a/crates/horizon-client/src/game/fishing.rs
+++ b/crates/horizon-client/src/game/fishing.rs
@@ -2,6 +2,7 @@
 //! bobbing, lure and bite timers, open water, hooking mobs, retrieving the
 //! `gameplay/fishing` loot) and `FishingHookRenderer` (bobber and line).
 use super::{Game, view_vector};
+use horizon_client::advancements::EntityView;
 use horizon_client::lan::{entity::States, hub::Hub};
 use horizon_client::{
     blocks::Fluid,
@@ -77,7 +78,7 @@ impl Game<'_> {
         let at = [p.position.x, p.position.y, p.position.z];
         let pitch = 0.4 / (self.world.random.next_float() * 0.4 + 0.8);
         if self.hook.is_some() {
-            let damage = self.retrieve_hook();
+            let damage = self.retrieve_hook(stack);
             self.damage_held(damage);
             self.audio.play(
                 "minecraft:entity.fishing_bobber.retrieve",
@@ -143,7 +144,7 @@ impl Game<'_> {
         true
     }
     /// `FishingHook.retrieve`: the rod damage it costs.
-    fn retrieve_hook(&mut self) -> u32 {
+    fn retrieve_hook(&mut self, rod: &ItemStack) -> u32 {
         let Some(hook) = self.hook.take() else {
             return 0;
         };
@@ -166,6 +167,15 @@ impl Game<'_> {
                     m.velocity.z + d.z * 0.1,
                 );
             }
+            // CriteriaTriggers.FISHING_ROD_HOOKED with no items.
+            let hooked = self
+                .mobs
+                .iter()
+                .find(|m| m.id == id)
+                .map(|m| self.mob_entity(m));
+            if let Some(hooked) = hooked {
+                self.trigger_fishing_rod_hooked(rod, &hooked, &[]);
+            }
             damage = 5;
         } else if hook.nibble > 0 {
             let biome = self.biome_name_at(hook.position);
@@ -184,6 +194,7 @@ impl Game<'_> {
             self.world.random = random;
             // FishingHook.retrieve: fish_caught for a catch.
             self.stats.custom("fish_caught", 1);
+            let mut caught = Vec::new();
             for stack in items {
                 let mut item = ItemStack {
                     item: Arc::from(stack.item.as_str()),
@@ -205,6 +216,7 @@ impl Game<'_> {
                 if let Some(potion) = &stack.potion {
                     item = item.with_potion(potion);
                 }
+                caught.push(item.clone());
                 let (dx, dy, dz) = (
                     owner.x - hook.position.x,
                     owner.y - hook.position.y,
@@ -224,6 +236,14 @@ impl Game<'_> {
                 let xp = self.world.random.next_int_bound(6).unwrap_or(0) as u32 + 1;
                 self.spawn_orbs([owner.x, owner.y + 0.5, owner.z + 0.5], xp);
             }
+            // CriteriaTriggers.FISHING_ROD_HOOKED: the hook itself is the entity.
+            let bobber = EntityView {
+                kind: "minecraft:fishing_bobber".into(),
+                position: [hook.position.x, hook.position.y, hook.position.z],
+                on_ground: hook.on_ground,
+                ..Default::default()
+            };
+            self.trigger_fishing_rod_hooked(rod, &bobber, &caught);
             damage = 1;
         }
         if hook.on_ground {

From 5fa423169f8fe5791f4cf31ee5b97e485806e46a Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:13:51 +0100
Subject: [PATCH 086/475] Fire player_hurt_entity and entity_hurt_player
 advancement triggers

---
 crates/horizon-client/src/advancements.rs     | 46 ++++++++++++
 crates/horizon-client/src/game.rs             |  9 +++
 .../horizon-client/src/game/advancements.rs   | 71 +++++++++++++++++++
 crates/horizon-client/src/game/creatures.rs   | 35 +++++++++
 crates/horizon-client/src/game/trident.rs     | 13 +++-
 5 files changed, 173 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/advancements.rs b/crates/horizon-client/src/advancements.rs
index 6706532b7..62e7f365f 100644
--- a/crates/horizon-client/src/advancements.rs
+++ b/crates/horizon-client/src/advancements.rs
@@ -703,6 +703,52 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo
     }
     true
 }
+/// A damage event as `DamagePredicate` sees it.
+#[derive(Clone, Debug, Default)]
+pub struct DamageView {
+    /// The damage type id (`minecraft:arrow`).
+    pub kind: String,
+    /// `DamageSource.getDirectEntity` and `getEntity`.
+    pub direct: Option<EntityView>,
+    pub source: Option<EntityView>,
+    /// `DamageSource.isDirect`: the direct entity is the causing one.
+    pub is_direct: bool,
+    /// The damage before and after the shield took its share.
+    pub original: f32,
+    pub actual: f32,
+    pub blocked: bool,
+}
+/// `DamagePredicate`, with its `DamageSourcePredicate` as `type`.
+pub fn damage(v: &Value, d: &DamageView, w: &dyn World, origin: [f64; 3]) -> bool {
+    if v.is_null() {
+        return true;
+    }
+    let by = |key: &str, e: &Option<EntityView>| {
+        v[key].is_null() || e.as_ref().is_some_and(|e| entity(&v[key], e, w, origin))
+    };
+    if !range_f(&v["dealt"], f64::from(d.original))
+        || !range_f(&v["taken"], f64::from(d.actual))
+        || !by("source_entity", &d.source)
+        || v["blocked"].as_bool().is_some_and(|b| b != d.blocked)
+    {
+        return false;
+    }
+    let ty = &v["type"];
+    let tags_ok = ty["tags"].as_array().into_iter().flatten().all(|t| {
+        let tag = t["id"].as_str().unwrap_or("");
+        let tag = tag.strip_prefix('#').unwrap_or(tag);
+        w.in_tag("damage_type", tag, &d.kind) == t["expected"].as_bool().unwrap_or(true)
+    });
+    let direct_ok = ty["direct_entity"].is_null()
+        || d.direct
+            .as_ref()
+            .is_some_and(|e| entity(&ty["direct_entity"], e, w, origin));
+    let source_ok = ty["source_entity"].is_null()
+        || d.source
+            .as_ref()
+            .is_some_and(|e| entity(&ty["source_entity"], e, w, origin));
+    tags_ok && direct_ok && source_ok && ty["is_direct"].as_bool().is_none_or(|b| b == d.is_direct)
+}
 /// The entities a loot-style condition list may refer to.
 pub struct Entities<'a> {
     pub this: Option<&'a EntityView>,
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..44ae588cb 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -7602,6 +7602,15 @@ impl Game<'_> {
             None => horizon_client::mobs::Damage::of(horizon_client::mobs::DamageKind::Generic),
         };
         let landed = self.hurt_by_player(index, amount, source);
+        if landed {
+            let victim = self.mob_entity(&self.mobs[index]);
+            self.player_hit(
+                &victim,
+                creatures::damage_type(source.kind, true),
+                None,
+                amount,
+            );
+        }
         if let Some(p) = self.player.as_mut() {
             if p.attack_log.len() >= 64 {
                 p.attack_log.remove(0);
diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs
index 0f76d0ca9..ab783cbfa 100644
--- a/crates/horizon-client/src/game/advancements.rs
+++ b/crates/horizon-client/src/game/advancements.rs
@@ -180,6 +180,14 @@ impl adv::World for View<'_, '_> {
             "block" => items.block_tags.get(tag).is_some_and(|t| t.contains(id)),
             "entity_type" => self.0.res.mob_data().entity_has(tag, id),
             "worldgen/biome" => self.0.res.mob_data().biome_has(tag, id),
+            "damage_type" => self
+                .0
+                .res
+                .stations()
+                .enchantments
+                .damage_tags
+                .get(tag)
+                .is_some_and(|t| t.contains(id)),
             _ => false,
         }
     }
@@ -681,6 +689,69 @@ impl Game<'_> {
             adv::conditions(&c["player"], &pctx, w) && adv::conditions(&c[&key], &ectx, w)
         });
     }
+    /// `PlayerHurtEntityTrigger`: the player, the damage and the victim.
+    pub(super) fn trigger_player_hurt_entity(
+        &mut self,
+        victim: &EntityView,
+        damage: &adv::DamageView,
+    ) {
+        let me = self.player_entity();
+        let (victim, damage) = (victim.clone(), damage.clone());
+        self.trigger("minecraft:player_hurt_entity", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            let vctx = adv::Entities {
+                this: Some(&victim),
+                ..pctx
+            };
+            adv::conditions(&c["player"], &pctx, w)
+                && adv::damage(&c["damage"], &damage, w, me.position)
+                && adv::conditions(&c["entity"], &vctx, w)
+        });
+    }
+    /// The player's hit on `victim` as `LivingEntity.hurtServer` reports it:
+    /// `kind` damage of `amount` from `direct` (the player's own hand when
+    /// `None`), nothing blocked.
+    pub(super) fn player_hit(
+        &mut self,
+        victim: &EntityView,
+        kind: &str,
+        direct: Option<EntityView>,
+        amount: f32,
+    ) {
+        let me = self.player_entity();
+        self.trigger_player_hurt_entity(
+            victim,
+            &adv::DamageView {
+                kind: kind.to_owned(),
+                is_direct: direct.is_none(),
+                direct: direct.or_else(|| Some(me.clone())),
+                source: Some(me),
+                original: amount,
+                actual: amount,
+                blocked: false,
+            },
+        );
+    }
+    /// `EntityHurtPlayerTrigger`: the player and the damage it took.
+    pub(super) fn trigger_entity_hurt_player(&mut self, damage: &adv::DamageView) {
+        let me = self.player_entity();
+        let damage = damage.clone();
+        self.trigger("minecraft:entity_hurt_player", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            adv::conditions(&c["player"], &pctx, w)
+                && adv::damage(&c["damage"], &damage, w, me.position)
+        });
+    }
     /// A player condition plus one item (`item` key).
     pub(super) fn trigger_item(&mut self, name: &str, stack: &ItemStack) {
         let me = self.player_entity();
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..e7395c3f0 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1544,6 +1544,23 @@ impl Game<'_> {
             self.hurt_armor(amount);
             self.thorns(from);
         }
+        // LivingEntity.hurtServer: ENTITY_HURT_PLAYER, unless it returned
+        // early (invulnerable, or inside the hurt cooldown).
+        if outcome.hurt || outcome.sound {
+            let source = attacker
+                .or(owner)
+                .and_then(|id| self.mobs.iter().find(|m| m.id == id))
+                .map(|m| self.mob_entity(m));
+            self.trigger_entity_hurt_player(&horizon_client::advancements::DamageView {
+                kind: damage_type.to_owned(),
+                direct: source.clone().filter(|_| !projectile),
+                is_direct: !projectile,
+                source,
+                original: amount,
+                actual: amount - outcome.blocked,
+                blocked: outcome.blocked > 0.0,
+            });
+        }
         if raised {
             self.after_block(outcome, amount, attacker, projectile);
         }
@@ -2111,6 +2128,24 @@ impl Game<'_> {
                             .is_some_and(|m| m.damage(amount, source));
                         if p.owner == Some(Who::Player) {
                             self.last_hurt_by_player.insert(id, self.lan_acting);
+                            if hurt && let Some(m) = self.mobs.iter().find(|m| m.id == id) {
+                                // LivingEntity.hurtServer: PLAYER_HURT_ENTITY.
+                                let victim = self.mob_entity(m);
+                                let spectral = p.arrow.as_ref().is_some_and(|a| {
+                                    &*a.pickup_item.item == "minecraft:spectral_arrow"
+                                });
+                                let direct = horizon_client::advancements::EntityView {
+                                    kind: if spectral {
+                                        "minecraft:spectral_arrow"
+                                    } else {
+                                        "minecraft:arrow"
+                                    }
+                                    .into(),
+                                    position: [p.position.x, p.position.y, p.position.z],
+                                    ..Default::default()
+                                };
+                                self.player_hit(&victim, "minecraft:arrow", Some(direct), amount);
+                            }
                         }
                         hurt
                     }
diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs
index c31094596..04a1be415 100644
--- a/crates/horizon-client/src/game/trident.rs
+++ b/crates/horizon-client/src/game/trident.rs
@@ -311,9 +311,10 @@ impl Game<'_> {
                     });
                     let damage = 8.0 + if aquatic { 2.5 * impaling } else { 0.0 };
                     t.dealt_damage = true;
+                    let mut hurt = false;
                     if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
                         let from = Some([t.position.x, t.position.y, t.position.z]);
-                        m.damage(
+                        hurt = m.damage(
                             damage,
                             Damage {
                                 kind: DamageKind::Arrow,
@@ -322,6 +323,16 @@ impl Game<'_> {
                             },
                         );
                     }
+                    if hurt && let Some(m) = self.mobs.iter().find(|m| m.id == id) {
+                        // LivingEntity.hurtServer: PLAYER_HURT_ENTITY.
+                        let victim = self.mob_entity(m);
+                        let direct = horizon_client::advancements::EntityView {
+                            kind: "minecraft:trident".into(),
+                            position: [t.position.x, t.position.y, t.position.z],
+                            ..Default::default()
+                        };
+                        self.player_hit(&victim, "minecraft:trident", Some(direct), damage);
+                    }
                     self.audio.play(
                         "minecraft:item.trident.hit",
                         Some([t.position.x, t.position.y, t.position.z]),

From 8d77913ea524f60ea52c7ac22ccba3092f5d7409 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:14:10 +0100
Subject: [PATCH 087/475] Note blocks play on a left click, and take mob heads
 on top

Mining a note block now plays its note and counts the play_noteblock
statistic. A mob head used on the top face is placed instead of tuning
the block.
---
 crates/horizon-client/src/game.rs          |  8 +++--
 crates/horizon-world/src/level/interact.rs | 35 ++++++++++++++++++----
 2 files changed, 36 insertions(+), 7 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..3548bf15a 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2510,9 +2510,13 @@ impl Game<'_> {
         self.process_level_events()
     }
     fn attack_block(&mut self, pos: [i32; 3]) -> Result<()> {
-        self.with_level(|b, level, ticks| {
-            b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2]));
+        let note = self.with_level(|b, level, ticks| {
+            b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2]))
         });
+        // NoteBlock.attack awards the statistic.
+        if note {
+            self.stats.custom("play_noteblock", 1);
+        }
         self.process_level_events()
     }
     /// Track which chunks are ticking (Ticks needs chunk load/unload).
diff --git a/crates/horizon-world/src/level/interact.rs b/crates/horizon-world/src/level/interact.rs
index 7b2195c34..ed7c03dfb 100644
--- a/crates/horizon-world/src/level/interact.rs
+++ b/crates/horizon-world/src/level/interact.rs
@@ -513,20 +513,26 @@ impl Behaviours {
         sim.game_event_state(pos, "minecraft:block_change", next);
     }
 
-    /// The state change of `RedStoneOreBlock.attack` when mining begins.
+    /// `BlockBehaviour.attack` when mining begins: `RedStoneOreBlock.attack`
+    /// lights the ore, `NoteBlock.attack` plays the note. True for a note
+    /// block, whose player also earns the `play_noteblock` statistic.
     pub fn attack_block<L: LevelAccess + ?Sized>(
         &self,
         level: &mut L,
         ticks: &mut Ticks,
         pos: BlockPos,
-    ) {
+    ) -> bool {
         let mut sim = self.sim(level, ticks);
         let state = sim.state(pos);
-        if self.data(state).chain.contains(&Class::RedStoneOre)
-            && !self.table.bool(state, self.props.lit)
-        {
+        let chain = &self.data(state).chain;
+        if chain.contains(&Class::Note) {
+            sim.note_play(pos, state);
+            return true;
+        }
+        if chain.contains(&Class::RedStoneOre) && !self.table.bool(state, self.props.lit) {
             sim.set_block_and_update(pos, self.table.set_bool(state, self.props.lit, true));
         }
+        false
     }
 
     /// `BlockState.useWithoutItem` for a right-click on `pos` (hit face and
@@ -595,6 +601,25 @@ impl Behaviours {
         if self.data(state).chain.contains(&Class::CopperGolemStatue) {
             return self.turn_statue(level, ticks, pos, state, item);
         }
+        // NoteBlock.useItemOn: a mob head on the top face is placed, not tuned
+        // (`#minecraft:noteblock_top_instruments`).
+        if face == Direction::Up
+            && self.data(state).chain.contains(&Class::Note)
+            && item.is_some_and(|i| {
+                matches!(
+                    i,
+                    "minecraft:zombie_head"
+                        | "minecraft:skeleton_skull"
+                        | "minecraft:creeper_head"
+                        | "minecraft:dragon_head"
+                        | "minecraft:wither_skeleton_skull"
+                        | "minecraft:piglin_head"
+                        | "minecraft:player_head"
+                )
+            })
+        {
+            return InteractionResult::Pass;
+        }
         self.use_without_item(level, ticks, pos, face, hit, player)
     }
 

From 79bfb8fcb81860893bd4664d4f3e86effd015eef Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:14:26 +0100
Subject: [PATCH 088/475] Let a brush take a scute off an armadillo

Right-clicking an adult armadillo with a brush did nothing. Follow
Armadillo.mobInteract: drop a scute from the brush loot table, play the
brush sound, post the entity_interact game event and wear the brush by 16.
---
 crates/horizon-client/src/game/creatures.rs | 52 +++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..0d4e94601 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2507,6 +2507,14 @@ impl Game<'_> {
             self.swing_arm();
             return Ok(true);
         }
+        if self.interact_armadillo(index, &item) {
+            if let Some(stack) = &held {
+                let target = self.mob_entity(&self.mobs[index]);
+                self.trigger_item_entity("minecraft:player_interacted_with_entity", stack, &target);
+            }
+            self.swing_arm();
+            return Ok(true);
+        }
         if self.interact_copper_golem(index, &item) {
             self.swing_arm();
             return Ok(true);
@@ -2876,6 +2884,50 @@ impl Game<'_> {
         }
         Ok(true)
     }
+    /// `Armadillo.mobInteract`: a brush brushes a scute off an adult
+    /// (`brushOffScute`) and loses 16 durability.
+    fn interact_armadillo(&mut self, index: usize, item: &str) -> bool {
+        let m = &self.mobs[index];
+        if item != "minecraft:brush"
+            || m.species() != Species::Armadillo
+            || !m.alive()
+            || m.is_baby()
+        {
+            return false;
+        }
+        let (id, at) = (m.id, m.position);
+        let feet = [at.x, at.y, at.z];
+        let tool = self.held().cloned();
+        let table = "minecraft:brush/armadillo";
+        for d in self.sequence_loot(table, table, tool.as_ref()) {
+            self.spawn_at_location(at, 0.0, d);
+        }
+        self.audio
+            .play("minecraft:entity.armadillo.brush", Some(feet), 1.0, 1.0);
+        let ctx = self.who_context(Some(Who::Mob(id)), None);
+        self.post_game_event("minecraft:entity_interact", feet, ctx);
+        // ItemStack.hurtAndBreak(16).
+        if !self.creative
+            && let Some(stack) = tool
+        {
+            let max = self
+                .res
+                .items()
+                .get(&stack.item)
+                .map_or(0, |i| i.max_damage);
+            if max > 0 {
+                let loss = self.durability_loss(&stack, 16);
+                let slot = self.held_slot();
+                if let Some(held) = self.stack_in_mut(slot).as_mut() {
+                    held.damage += loss;
+                    if held.damage >= max {
+                        *self.stack_in_mut(slot) = None;
+                    }
+                }
+            }
+        }
+        true
+    }
     pub(super) fn damage_held_tool(&mut self) {
         if self.creative {
             return;

From 8691d9a8e88dcdd3f25783a42f24cd00af293eaa Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:14:34 +0100
Subject: [PATCH 089/475] Let players harvest a full beehive with shears or a
 glass bottle

---
 crates/horizon-client/src/game.rs          |   4 +
 crates/horizon-client/src/game/beehives.rs | 107 +++++++++++++++++++++
 2 files changed, 111 insertions(+)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..01442b5c4 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -3539,6 +3539,10 @@ impl Game<'_> {
                 self.swing_arm();
                 return Ok(true);
             }
+            if self.use_beehive(hit.pos, held.as_ref())? {
+                self.swing_arm();
+                return Ok(true);
+            }
             match self.use_respawn_anchor(hit.pos, held.as_ref())? {
                 respawn_anchor::AnchorUse::Charged => {
                     self.swing_arm();
diff --git a/crates/horizon-client/src/game/beehives.rs b/crates/horizon-client/src/game/beehives.rs
index b7f7efb1a..dfd4382a8 100644
--- a/crates/horizon-client/src/game/beehives.rs
+++ b/crates/horizon-client/src/game/beehives.rs
@@ -3,8 +3,10 @@
 //! player breaks the hive or fire reaches it.
 use super::Game;
 use horizon_client::{
+    Result,
     beehive::{self, Beehive, HiveHost, Release},
     containers::BlockEntity,
+    items::ItemStack,
     mobs::{Mob, Who, bee},
 };
 use horizon_core::{
@@ -194,6 +196,111 @@ impl Game<'_> {
         }
         self.anger_nearby_bees(at);
     }
+    /// `BeehiveBlock.useItemOn` with `held` in the acting hand: shears take
+    /// the honeycombs and a glass bottle a honey bottle from a full hive
+    /// (honey level 5), then the honey level resets and, unless a campfire
+    /// smokes the hive, the bees come out angry. True when it took the click.
+    pub(super) fn use_beehive(&mut self, pos: [i32; 3], held: Option<&ItemStack>) -> Result<bool> {
+        let Some(held) = held else { return Ok(false) };
+        let shears = &*held.item == "minecraft:shears";
+        if !shears && &*held.item != "minecraft:glass_bottle" {
+            return Ok(false);
+        }
+        let state = self.world.block(pos[0], pos[1], pos[2]);
+        if !matches!(
+            &*self.res.facts().get(state).name,
+            "minecraft:beehive" | "minecraft:bee_nest"
+        ) {
+            return Ok(false);
+        }
+        let prop = |key: &str| {
+            self.pack
+                .assets
+                .registry
+                .state(state)
+                .and_then(|s| s.properties.get(key).cloned())
+        };
+        if prop("honey_level").and_then(|v| v.parse::<i32>().ok()) != Some(5) {
+            return Ok(false);
+        }
+        let facing = beehive::facing_step(prop("facing").as_deref());
+        let at = self
+            .player
+            .as_ref()
+            .map(|p| [p.position.x, p.position.y, p.position.z]);
+        if shears {
+            // dropHoneycomb (harvest/beehive), the shear sound, hurtAndBreak.
+            for stack in self.sequence_loot(
+                "minecraft:harvest/beehive",
+                "minecraft:harvest/beehive",
+                Some(held),
+            ) {
+                self.pop_resource(pos, stack);
+            }
+            self.audio
+                .play("minecraft:block.beehive.shear", at, 1.0, 1.0);
+            self.damage_held(1);
+            self.post_block_game_event("minecraft:shear", pos, self.sculk_actor(), None);
+        } else {
+            // shrink(1), then the honey bottle in the hand, the inventory or
+            // on the ground.
+            self.audio.play("minecraft:item.bottle.fill", at, 1.0, 1.0);
+            let cell = self.held_mut();
+            if let Some(s) = cell.as_mut() {
+                s.count -= 1;
+                if s.count == 0 {
+                    *cell = None;
+                }
+            }
+            let bottle = ItemStack::new("minecraft:honey_bottle", 1);
+            if self.held().is_none() {
+                *self.held_mut() = Some(bottle);
+            } else if let Some(rest) = self.give(bottle)
+                && let Some(eye) = self.eye_position()
+            {
+                self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40);
+            }
+            self.post_block_game_event("minecraft:fluid_pickup", pos, self.sculk_actor(), None);
+        }
+        self.stats.add("used", &held.item, 1);
+        let smokey = beehive::smokey(&self.mob_world_base(&[]), pos);
+        let key = (pos[0], pos[1], pos[2]);
+        if !smokey
+            && matches!(self.world.block_entities.get(&key), Some(BlockEntity::Beehive(h)) if !h.bees.is_empty())
+        {
+            self.anger_nearby_bees(pos);
+        }
+        // resetHoneyLevel.
+        if let Some(reset) = self.with_props(state, &[("honey_level", "0")]) {
+            self.level_set(pos, reset)?;
+        }
+        if !smokey
+            && let Some(BlockEntity::Beehive(mut hive)) = self.world.block_entities.take(&key)
+        {
+            // emptyAllLivingFromHive: the bees within 4 blocks of the player
+            // go for them.
+            let released = hive.release_all(
+                pos,
+                facing,
+                None,
+                Release::Emergency,
+                &mut GameHive { game: self },
+            );
+            self.world
+                .block_entities
+                .put(key, BlockEntity::Beehive(hive));
+            if let Some(p) = self.player_view().map(|p| p.position) {
+                for m in self.mobs.iter_mut().filter(|m| released.contains(&m.id)) {
+                    if m.distance_sqr(p) <= 16.0 {
+                        m.ai.target = Some(Who::Player);
+                    }
+                }
+            }
+        }
+        // ServerPlayerGameMode.useItemOn: the action was consumed.
+        self.trigger_block("minecraft:item_used_on_block", pos, held);
+        Ok(true)
+    }
     /// `BeehiveBlock.angerNearbyBees`: bees within 8 blocks (6 up and down)
     /// without a target go for a player in the same box.
     fn anger_nearby_bees(&mut self, at: [i32; 3]) {

From 4c72a3a44f41278aa0481f95acf0d184bf540421 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:14:42 +0100
Subject: [PATCH 090/475] Make a detector rail's comparator read the minecart
 on it

---
 crates/horizon-client/src/game.rs           | 43 +++++++++++++++++++++
 crates/horizon-client/src/game/minecarts.rs | 29 +++++++++++++-
 2 files changed, 71 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..cc8cf7f1d 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -541,6 +541,8 @@ struct GameLevel<'w> {
     player_collision: Option<PlayerCollision>,
     /// Minecart boxes (detector rails).
     cart_boxes: Vec<([f64; 3], [f64; 3])>,
+    /// Each minecart's kind and comparator signal, in `cart_boxes` order.
+    cart_signals: Vec<(minecarts::CartKind, i32)>,
     /// The other entities that keep blocks from being placed into them.
     blockers: Blockers<'w>,
     biomes: &'w Biomes,
@@ -609,6 +611,37 @@ impl EntityObstructionWorld for BuildingObstruction {
     }
 }
 impl GameLevel<'_> {
+    /// `DetectorRailBlock.getAnalogOutputSignal`: a powered rail reads the
+    /// minecart on it, a command block cart first (its success count, which
+    /// is 0 here), else the first container cart's fullness.
+    fn detector_rail_signal(&self, pos: BlockPos, powered: bool) -> i32 {
+        if !powered {
+            return 0;
+        }
+        let (x, y, z) = (f64::from(pos.x), f64::from(pos.y), f64::from(pos.z));
+        let area = Aabb::new(
+            Vec3::new(x + 0.2, y, z + 0.2),
+            Vec3::new(x + 0.8, y + 0.8, z + 0.8),
+        );
+        let mut container = None;
+        for ((lo, hi), &(kind, signal)) in self.cart_boxes.iter().zip(&self.cart_signals) {
+            let cart = Aabb::new(
+                Vec3::new(lo[0], lo[1], lo[2]),
+                Vec3::new(hi[0], hi[1], hi[2]),
+            );
+            if !area.intersects(cart) {
+                continue;
+            }
+            match kind {
+                minecarts::CartKind::CommandBlock => return 0,
+                minecarts::CartKind::Chest | minecarts::CartKind::Hopper => {
+                    container = container.or(Some(signal));
+                }
+                _ => {}
+            }
+        }
+        container.unwrap_or(0)
+    }
     /// Every entity box that blocks building: the players who aren't
     /// spectators, the minecarts and the `Blockers` (a removed mob or a marker
     /// armor stand, whose box is empty, doesn't).
@@ -666,6 +699,14 @@ impl LevelAccess for GameLevel<'_> {
         state: BlockStateId,
         _direction: Direction,
     ) -> i32 {
+        if let Some(s) = self.registry.state(state)
+            && s.name == "minecraft:detector_rail"
+        {
+            return self.detector_rail_signal(
+                pos,
+                s.properties.get("powered").is_some_and(|v| v == "true"),
+            );
+        }
         if let Some(signal) = command_blocks::analog_signal(self.world, (pos.x, pos.y, pos.z)) {
             return signal;
         }
@@ -2448,6 +2489,7 @@ impl Game<'_> {
                 )
             })
             .collect();
+        let cart_signals = self.cart_signals();
         let guest_boxes = self.lan_block_trigger_boxes();
         let dimension = match self.dim {
             Dim::Overworld => LevelDimension::Overworld,
@@ -2465,6 +2507,7 @@ impl Game<'_> {
         };
         let mut level = GameLevel {
             cart_boxes,
+            cart_signals,
             blockers,
             world: &mut self.world,
             facts: self.res.facts(),
diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index a19b6df73..08eb20e02 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -9,7 +9,7 @@ use horizon_client::{
     blocks::Fluid,
     collisions::SceneCollisions,
     containers::BlockEntity,
-    items::ItemStack,
+    items::{ItemStack, Items},
     mesher::Vertex,
     mobs::{Part, anim::Poses},
     particles::{ParticleOptions, ParticleType},
@@ -194,6 +194,17 @@ impl Minecart {
     fn horizontal(&self) -> f64 {
         self.velocity.x.hypot(self.velocity.z)
     }
+    /// `AbstractContainerMenu.getRedstoneSignalFromContainer` of `slots`.
+    fn container_signal(slots: &[Option<ItemStack>], items: &Items) -> i32 {
+        let mut total = 0.0f32;
+        for s in slots.iter().flatten() {
+            let max = items.get(&s.item).map_or(64, |i| i.max_stack).min(64);
+            total += s.count as f32 / max as f32;
+        }
+        total /= slots.len().max(1) as f32;
+        // Mth.lerpDiscrete(total, 0, 15)
+        (total * 14.0).floor() as i32 + i32::from(total > 0.0)
+    }
 }
 pub(super) struct CartModels {
     pub models: HashMap<CartKind, Part>,
@@ -1046,6 +1057,22 @@ impl Game<'_> {
         }
         best
     }
+    /// Each cart's kind and comparator signal, for the detector rail
+    /// (`DetectorRailBlock.getAnalogOutputSignal`). A cart whose menu is open
+    /// counts the items in that menu.
+    pub(super) fn cart_signals(&self) -> Vec<(CartKind, i32)> {
+        self.carts
+            .iter()
+            .map(|c| {
+                let key = (i32::MAX - 15, CART_KEY_Y, c.id as i32);
+                let slots = match self.world.block_entities.get(&key) {
+                    Some(BlockEntity::Chest(open)) => open,
+                    _ => &c.items,
+                };
+                (c.kind, Minecart::container_signal(slots, self.res.items()))
+            })
+            .collect()
+    }
     /// `interact`: ride, open, fuel or ignite the cart under the crosshair.
     pub(super) fn interact_cart(&mut self) -> bool {
         let Some((i, d)) = self.cart_hit() else {

From 5b9a66089e9bcabcad2a9f864be534fd35f841a7 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:14:43 +0100
Subject: [PATCH 091/475] Give a partial item pickup the random pitch of a full
 pickup

---
 crates/horizon-client/src/game.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..57f817a00 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2390,8 +2390,14 @@ impl Game<'_> {
                                 pickups::Taken::Item(Box::new(item.clone())),
                                 pickups::Collector::Player,
                             );
+                            // handleTakeItemEntity: the random pitch of a full pickup.
+                            let pitch = ((self.world.random.next_float()
+                                - self.world.random.next_float())
+                                * 0.7
+                                + 1.0)
+                                * 2.0;
                             self.audio
-                                .play("minecraft:entity.item.pickup", Some(feet), 0.2, 1.0);
+                                .play("minecraft:entity.item.pickup", Some(feet), 0.2, pitch);
                         }
                         item.stack = rest;
                     }

From c273a7271ed3dbc53c28ad50784f2cbb69d04e76 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:14:59 +0100
Subject: [PATCH 092/475] Make breeze shots follow the world difficulty and aim
 higher at riders

---
 .../examples/probe/mob_ai_probe.rs               |  1 +
 crates/horizon-client/src/game/creatures.rs      |  1 +
 crates/horizon-client/src/game/lan_mobs.rs       |  1 +
 crates/horizon-client/src/mobs.rs                |  5 +++++
 crates/horizon-client/src/mobs/monster_brain.rs  | 16 ++++++++++++----
 crates/horizon-client/src/mobs/spawning.rs       |  4 ++++
 crates/horizon-client/src/mobs/world.rs          |  4 ++++
 7 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs
index ecdf02901..d3b091490 100644
--- a/crates/horizon-client/examples/probe/mob_ai_probe.rs
+++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs
@@ -1060,6 +1060,7 @@ pub fn main() -> horizon_client::Result<()> {
                 uuid: PLAYER_UUID,
                 allies: Default::default(),
                 remote: false,
+                passenger: false,
             }
         });
         let mut scratch = LegacyRandom::new(0);
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..17d518c3a 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -196,6 +196,7 @@ impl Game<'_> {
             uuid: self.level.player_uuid.unwrap_or_default(),
             allies: std::sync::Arc::new(self.player_allies()),
             remote: false,
+            passenger: self.riding.is_some(),
         })
     }
     /// Biome facts at a position for finalizeSpawn and variant rules.
diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs
index 4f53cec60..746a712a4 100644
--- a/crates/horizon-client/src/game/lan_mobs.rs
+++ b/crates/horizon-client/src/game/lan_mobs.rs
@@ -373,6 +373,7 @@ mod tests {
             uuid: [0; 4],
             allies: Default::default(),
             remote: false,
+            passenger: false,
         }
     }
 
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..240ab4218 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1223,6 +1223,8 @@ pub struct Seen {
     pub active_raid: bool,
     /// A copper golem's `openedChestPos` (`ContainerUser.hasContainerOpen`).
     pub opened_chest: Option<[i32; 3]>,
+    /// `isPassenger`.
+    pub passenger: bool,
     /// A villager's reputation of the player (`getPlayerReputation`).
     pub player_rep: i32,
     /// `isPushable` and pushed by others (`Entity.push(Entity)` moves it).
@@ -1298,6 +1300,7 @@ impl Mob {
             hurt_by: m.ai.last_hurt_by.map(|w| (w, m.ai.last_hurt_by_time)),
             active_raid: raider::has_active_raid(m),
             opened_chest: m.extra.opened_chest,
+            passenger: m.extra.mount.is_some(),
             player_rep: match (villager, player) {
                 (true, Some(uuid)) => villager::ext(m).map_or(0, |e| e.gossips.reputation(uuid)),
                 _ => 0,
@@ -1467,6 +1470,8 @@ pub struct PlayerView {
     /// A LAN guest: its own client moves it, and touching mobs push it there
     /// (`EntitySelector.pushableBy` on the client).
     pub remote: bool,
+    /// `isPassenger`.
+    pub passenger: bool,
 }
 #[derive(Clone)]
 pub struct MobWorld<'a> {
diff --git a/crates/horizon-client/src/mobs/monster_brain.rs b/crates/horizon-client/src/mobs/monster_brain.rs
index 9456c00a1..827360406 100644
--- a/crates/horizon-client/src/mobs/monster_brain.rs
+++ b/crates/horizon-client/src/mobs/monster_brain.rs
@@ -1137,6 +1137,7 @@ struct Quarry {
     position: Vec3,
     head_yaw: f32,
     height: f64,
+    passenger: bool,
 }
 fn quarry(w: &MobWorld, who: Who) -> Option<Quarry> {
     let t = w.target_info(who)?;
@@ -1148,6 +1149,7 @@ fn quarry(w: &MobWorld, who: Who) -> Option<Quarry> {
         position: t.position,
         head_yaw,
         height: t.bounds.max_position().y - t.bounds.min_position().y,
+        passenger: t.passenger,
     })
 }
 /// `BreezeUtil.randomPointBehindTarget`.
@@ -1233,7 +1235,8 @@ fn shoot_tick(m: &mut Mob, cx: &mut Bx) {
     let firing = super::breeze::firing_y(m);
     let (xd, yd, zd) = (
         q.position.x - m.position.x,
-        q.position.y + q.height * 0.3 - firing,
+        // target.getY(target.isPassenger() ? 0.8 : 0.3).
+        q.position.y + q.height * if q.passenger { 0.8 } else { 0.3 } - firing,
         q.position.z - m.position.z,
     );
     let start = Vec3::new(m.position.x, firing, m.position.z);
@@ -1242,14 +1245,19 @@ fn shoot_tick(m: &mut Mob, cx: &mut Bx) {
         start,
         Some(Who::Mob(m.id)),
     );
-    // The new entity's own random spreads the shot (5 - difficulty * 4 at
-    // normal): not the breeze's.
+    // The new entity's own random spreads the shot (5 - difficulty id * 4):
+    // not the breeze's.
     let mut own = LegacyRandom::new(
         cx.now
             .wrapping_mul(0x5DEE_CE66)
             .wrapping_add(i64::from(m.id)),
     );
-    p.shoot(&mut own, [xd, yd, zd], 0.7, -3.0);
+    p.shoot(
+        &mut own,
+        [xd, yd, zd],
+        0.7,
+        5.0 - f32::from(cx.w.difficulty.id) * 4.0,
+    );
     cx.events.push(MobEvent::Projectile(p));
     breeze_sound(m, cx, "entity.breeze.shoot", 1.5);
 }
diff --git a/crates/horizon-client/src/mobs/spawning.rs b/crates/horizon-client/src/mobs/spawning.rs
index 93e3fe119..bbb8e2e46 100644
--- a/crates/horizon-client/src/mobs/spawning.rs
+++ b/crates/horizon-client/src/mobs/spawning.rs
@@ -37,6 +37,8 @@ pub struct LocalDifficulty {
     pub effective: f32,
     /// The world difficulty is hard.
     pub hard: bool,
+    /// `Difficulty.getId`: 0 peaceful to 3 hard.
+    pub id: u8,
 }
 /// `DimensionType.MOON_BRIGHTNESS_PER_PHASE`.
 pub const MOON_BRIGHTNESS: [f32; 8] = [1.0, 0.75, 0.5, 0.25, 0.0, 0.25, 0.5, 0.75];
@@ -49,6 +51,7 @@ impl LocalDifficulty {
             return Self {
                 effective: 0.0,
                 hard,
+                id: base,
             };
         }
         let global = ((total as f32 - 72000.0) / 1_440_000.0).clamp(0.0, 1.0) * 0.25;
@@ -61,6 +64,7 @@ impl LocalDifficulty {
         Self {
             effective: f32::from(base) * (0.75 + global + local),
             hard,
+            id: base,
         }
     }
     /// `getSpecialMultiplier`.
diff --git a/crates/horizon-client/src/mobs/world.rs b/crates/horizon-client/src/mobs/world.rs
index 7836a49ef..0fb80d9e9 100644
--- a/crates/horizon-client/src/mobs/world.rs
+++ b/crates/horizon-client/src/mobs/world.rs
@@ -25,6 +25,8 @@ pub struct TargetInfo {
     pub can_be_seen_as_enemy: bool,
     pub is_player: bool,
     pub creative: bool,
+    /// `isPassenger`.
+    pub passenger: bool,
 }
 impl MobWorld<'_> {
     /// The biome's base temperature at a position.
@@ -201,6 +203,7 @@ impl MobWorld<'_> {
                 can_be_seen_as_enemy: true,
                 is_player: true,
                 creative: p.creative,
+                passenger: p.passenger,
             }),
             Who::Mob(id) => self.seen(id).map(|s| TargetInfo {
                 position: s.position,
@@ -210,6 +213,7 @@ impl MobWorld<'_> {
                 can_be_seen_as_enemy: !s.playing_dead,
                 is_player: false,
                 creative: false,
+                passenger: s.passenger,
             }),
         }
     }

From c418034f10e15eb6dccba6e4d9a18365eb08a3f0 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:15:07 +0100
Subject: [PATCH 093/475] Let goats breed, follow wheat and be milked

Goats only strolled and panicked, so wheat did nothing after the love
hearts and a bucket gave no milk. Give them the GoatAi core and idle
behaviours that exist here (panic 2.0, breed, tempt 1.25, baby follow
1.25) and Goat.mobInteract's milking with the goat milk sounds.
---
 crates/horizon-client/src/game/creatures.rs | 10 ++++++++++
 crates/horizon-client/src/mobs/ai.rs        | 14 ++++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..0fe0f4210 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2548,6 +2548,16 @@ impl Game<'_> {
                 consume = true;
                 sound = Some("entity.cow.milk");
             }
+            // Goat.mobInteract: a bucket on an adult gives milk.
+            Species::Goat if item == "minecraft:bucket" && !m.is_baby() => {
+                give = Some("minecraft:milk_bucket");
+                consume = true;
+                sound = Some(if m.extra.screaming {
+                    "entity.goat.screaming.milk"
+                } else {
+                    "entity.goat.milk"
+                });
+            }
             Species::Mooshroom if item == "minecraft:bowl" && !m.is_baby() => {
                 give = Some("minecraft:mushroom_stew");
                 consume = true;
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 8335cb745..e194d0132 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -301,6 +301,20 @@ fn generic(m: &mut Mob) {
         m.ai.targets.add(1, HurtByTarget::new());
         m.ai.targets.add(2, NearestTarget::player(true));
     } else {
+        if m.kind.species == Species::Goat {
+            // GoatAi's idle and core behaviours (the ram and long jump
+            // activities are not here): panic 2.0, AnimalMakeLove, tempting
+            // with goat_food and baby follow at 1.25, then stroll.
+            g.add(0, Float);
+            g.add(1, Panic::new(2.0));
+            g.add(2, Breed::new(1.0));
+            g.add(3, Tempt::new(1.25, m.kind.food.clone(), false));
+            g.add(4, FollowParent::new(1.25));
+            g.add(5, Stroll::avoiding_water(1.0));
+            g.add(6, LookAtPlayer::new(6.0));
+            g.add(7, RandomLookAround::default());
+            return;
+        }
         g.add(0, Float);
         let rabbit = m.kind.species == Species::Rabbit;
         g.add(1, Panic::new(if rabbit { 2.2 } else { 1.25 }));

From 06fb03567e4f124315872936eced832c6d47afde Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:15:11 +0100
Subject: [PATCH 094/475] Count the block interaction statistics

Eating a cake slice, using a cauldron (fill, use, clean armor, banner or shulker
box), tuning a note block, ringing a bell, opening an ender chest and putting a
record in a jukebox now add to their statistics, which stayed at 0 before.
---
 crates/horizon-client/src/cauldron.rs     | 31 +++++++++++++++++------
 crates/horizon-client/src/game.rs         | 21 +++++++++++++++
 crates/horizon-client/src/game/jukebox.rs |  1 +
 3 files changed, 45 insertions(+), 8 deletions(-)

diff --git a/crates/horizon-client/src/cauldron.rs b/crates/horizon-client/src/cauldron.rs
index 03fb0676d..25a709e26 100644
--- a/crates/horizon-client/src/cauldron.rs
+++ b/crates/horizon-client/src/cauldron.rs
@@ -40,6 +40,8 @@ pub struct Interaction {
     /// The cauldron's new state.
     pub block: Option<BlockState>,
     pub sound: Option<&'static str>,
+    /// The custom statistic the player earns (`use_cauldron`, ...).
+    pub stat: Option<&'static str>,
 }
 
 fn state(name: &str, level: Option<u8>) -> BlockState {
@@ -57,6 +59,7 @@ fn pass() -> Interaction {
         outcome: Outcome::Pass,
         block: None,
         sound: None,
+        stat: None,
     }
 }
 
@@ -117,11 +120,12 @@ fn lowered(cauldron: &BlockState) -> BlockState {
     }
 }
 
-fn changed(block: BlockState, sound: Option<&'static str>) -> Interaction {
+fn changed(block: BlockState, sound: Option<&'static str>, stat: &'static str) -> Interaction {
     Interaction {
         outcome: Outcome::Success,
         block: Some(block),
         sound,
+        stat: Some(stat),
     }
 }
 
@@ -179,18 +183,22 @@ pub fn interact(
             stack.data_mut().dyed_color = None;
             stack.tidy();
         }
-        return changed(lowered(cauldron), None);
+        return changed(lowered(cauldron), None, "clean_armor");
     }
     let fill_bucket = |player: &mut dyn Player, new: &str, can_fill: bool, sound| {
         if !can_fill {
             return pass();
         }
         filled(player, ItemStack::new(new, 1), true);
-        changed(state("minecraft:cauldron", None), Some(sound))
+        changed(
+            state("minecraft:cauldron", None),
+            Some(sound),
+            "use_cauldron",
+        )
     };
     let empty_bucket = |player: &mut dyn Player, block: BlockState, sound| {
         filled(player, ItemStack::new("minecraft:bucket", 1), true);
-        changed(block, Some(sound))
+        changed(block, Some(sound), "fill_cauldron")
     };
     match item {
         "minecraft:lava_bucket" => {
@@ -199,6 +207,7 @@ pub fn interact(
                     outcome: Outcome::Consume,
                     block: None,
                     sound: None,
+                    stat: None,
                 }
             } else {
                 empty_bucket(
@@ -221,6 +230,7 @@ pub fn interact(
                     outcome: Outcome::Consume,
                     block: None,
                     sound: None,
+                    stat: None,
                 }
             } else {
                 empty_bucket(
@@ -241,6 +251,7 @@ pub fn interact(
             changed(
                 state("minecraft:water_cauldron", Some(1)),
                 Some("minecraft:item.bottle.empty"),
+                "use_cauldron",
             )
         }
         ("water", "minecraft:bucket") => fill_bucket(
@@ -255,7 +266,11 @@ pub fn interact(
                 ItemStack::new("minecraft:potion", 1).with_potion("minecraft:water"),
                 true,
             );
-            changed(lowered(cauldron), Some("minecraft:item.bottle.fill"))
+            changed(
+                lowered(cauldron),
+                Some("minecraft:item.bottle.fill"),
+                "use_cauldron",
+            )
         }
         ("water", "minecraft:potion") => {
             if level == 3 || !water_potion {
@@ -266,7 +281,7 @@ pub fn interact(
             // BlockState.cycle on a 1..=3 property
             next.properties
                 .insert("level".into(), (level % 3 + 1).to_string());
-            changed(next, Some("minecraft:item.bottle.empty"))
+            changed(next, Some("minecraft:item.bottle.empty"), "use_cauldron")
         }
         ("water", name)
             if name
@@ -283,7 +298,7 @@ pub fn interact(
             cleaned.data_mut().banner_patterns.pop();
             cleaned.tidy();
             filled(player, cleaned, false);
-            changed(lowered(cauldron), None)
+            changed(lowered(cauldron), None, "clean_banner")
         }
         ("water", name)
             if name
@@ -292,7 +307,7 @@ pub fn interact(
                 .is_some_and(|c| COLORS.contains(&c)) =>
         {
             filled(player, held.transmute("minecraft:shulker_box", 1), false);
-            changed(lowered(cauldron), None)
+            changed(lowered(cauldron), None, "clean_shulker_box")
         }
         ("lava", "minecraft:bucket") => fill_bucket(
             player,
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..175c10447 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2915,6 +2915,8 @@ impl Game<'_> {
                     // Popped as the behaviour emits it (GameLevel::emit).
                     PlayerEffect::DropItem(_) => {}
                     PlayerEffect::EatCake => {
+                        // CakeBlock.eat
+                        self.stats.custom("eat_cake_slice", 1);
                         if let Some(p) = self.player.as_mut() {
                             let food = &mut p.health.food;
                             food.food = (food.food + 2).min(20);
@@ -3019,6 +3021,8 @@ impl Game<'_> {
             self.craft_table = Some(pos);
         } else if &*name == "minecraft:ender_chest" {
             self.open_ender_chest(key);
+            // EnderChestBlock.useWithoutItem
+            self.stats.custom("open_enderchest", 1);
             self.container_opener_event(key, true);
             let at = [
                 f64::from(key.0) + 0.5,
@@ -3574,6 +3578,20 @@ impl Game<'_> {
                     )
                 });
                 self.process_level_events()?;
+                // NoteBlock.useWithoutItem (tuned) and BellBlock.onHit (rung).
+                if result == horizon_world::level::InteractionResult::Success {
+                    let name = self
+                        .res
+                        .facts()
+                        .get(self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]))
+                        .name
+                        .clone();
+                    match &*name {
+                        "minecraft:note_block" => self.stats.custom("tune_noteblock", 1),
+                        "minecraft:bell" => self.stats.custom("bell_ring", 1),
+                        _ => {}
+                    }
+                }
                 if result.consumes_action() {
                     self.swing_arm();
                     return Ok(true);
@@ -8477,6 +8495,9 @@ impl Game<'_> {
         if result.outcome == Outcome::Pass {
             return Ok(false);
         }
+        if let Some(stat) = result.stat {
+            self.stats.custom(stat, 1);
+        }
         if let Some(block) = result.block
             && let Ok(new) = registry.resolve(&block)
         {
diff --git a/crates/horizon-client/src/game/jukebox.rs b/crates/horizon-client/src/game/jukebox.rs
index c3ed75ebb..61caea0c8 100644
--- a/crates/horizon-client/src/game/jukebox.rs
+++ b/crates/horizon-client/src/game/jukebox.rs
@@ -79,6 +79,7 @@ impl Game<'_> {
         if !self.creative {
             self.consume_held();
         }
+        self.stats.custom("play_record", 1);
         self.world.block_entities.insert(
             (pos[0], pos[1], pos[2]),
             BlockEntity::Jukebox(Jukebox {

From fd0f09d6f6530e8c442906a953d80414dc8dcb64 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:15:20 +0100
Subject: [PATCH 095/475] End the Absorption effect once the absorption is used
 up

The effect used to stay in the list until its timer ran out, even with no absorption hearts left.
---
 crates/horizon-client/src/effects.rs      | 15 +++++++++------
 crates/horizon-client/src/game/potions.rs |  4 +++-
 2 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/crates/horizon-client/src/effects.rs b/crates/horizon-client/src/effects.rs
index 17dce93ab..5f8649642 100644
--- a/crates/horizon-client/src/effects.rs
+++ b/crates/horizon-client/src/effects.rs
@@ -213,8 +213,9 @@ impl PlayerEffects {
     }
     /// `LivingEntity.tickEffects` (server part) with the omens' effect ticks:
     /// `omen` answers `BadOmenMobEffect` (every tick) and `RaidOmenMobEffect`
-    /// (on its last tick). Returns the actions to apply, in order, and
-    /// whether Raid Omen was newly added.
+    /// (on its last tick); `absorption_empty` is `AbsorptionMobEffect`'s
+    /// answer: the effect ends once the absorption is used up. Returns the
+    /// actions to apply, in order, and whether Raid Omen was newly added.
     ///
     /// Bad Omen turning into a new Raid Omen adds an entry to the map being
     /// iterated: vanilla's iterator then throws a
@@ -224,6 +225,7 @@ impl PlayerEffects {
     pub fn tick_with(
         &mut self,
         omen: &mut dyn FnMut(&EffectInstance) -> OmenTick,
+        absorption_empty: bool,
     ) -> (Vec<EffectAction>, bool) {
         self.tick_count = self.tick_count.wrapping_add(1);
         let mut actions = Vec::new();
@@ -246,6 +248,7 @@ impl PlayerEffects {
             let answer = match e.id {
                 "bad_omen" => omen(e),
                 "raid_omen" if t == 1 => omen(e),
+                "absorption" if absorption_empty => OmenTick::Remove,
                 _ => OmenTick::Continue,
             };
             match answer {
@@ -465,13 +468,13 @@ mod tests {
         };
         // The first tick adds Raid Omen and stops there (the iterator's
         // ConcurrentModificationException): Bad Omen and Speed stay as they were.
-        let (_, added) = fx.tick_with(&mut convert);
+        let (_, added) = fx.tick_with(&mut convert, false);
         assert!(added);
         assert_eq!(fx.get("bad_omen").unwrap().duration, 100);
         assert_eq!(fx.get("speed").unwrap().duration, 50);
         assert_eq!(fx.get("raid_omen").unwrap().duration, 600);
         // The second refreshes Raid Omen and drops Bad Omen.
-        let (_, added) = fx.tick_with(&mut convert);
+        let (_, added) = fx.tick_with(&mut convert, false);
         assert!(!added);
         assert!(fx.get("bad_omen").is_none());
         assert_eq!(fx.get("speed").unwrap().duration, 49);
@@ -486,9 +489,9 @@ mod tests {
             seen.push(e.duration);
             OmenTick::Remove
         };
-        fx.tick_with(&mut watch);
+        fx.tick_with(&mut watch, false);
         assert!(fx.get("raid_omen").is_some());
-        fx.tick_with(&mut watch);
+        fx.tick_with(&mut watch, false);
         assert!(fx.get("raid_omen").is_none());
         assert_eq!(seen, vec![1]);
     }
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index b28c2fb4d..e023ca4b2 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -381,8 +381,10 @@ impl Game<'_> {
         }
         // The omens act from inside the effect tick (BadOmenMobEffect,
         // RaidOmenMobEffect).
+        let absorption_empty = player.health.absorption() <= 0.0;
         let mut effects = std::mem::take(&mut self.potions.effects);
-        let (actions, raid_omen_added) = effects.tick_with(&mut |e| self.omen_tick(e));
+        let (actions, raid_omen_added) =
+            effects.tick_with(&mut |e| self.omen_tick(e), absorption_empty);
         self.potions.effects = effects;
         if raid_omen_added {
             self.raid_omen_added();

From 85a6ce09214e684be1810ee6530e85c4476407b3 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:15:30 +0100
Subject: [PATCH 096/475] Lightning scrapes oxidation off copper

A struck copper block goes back to unoxidized, and 3 to 5 random walks
take one step of oxidation off the weathering copper around it. Waxed
blocks stay as they are but still start the walks.
---
 crates/horizon-client/src/game/lightning.rs | 11 +++
 crates/horizon-world/src/level/tick.rs      | 83 +++++++++++++++++++++
 2 files changed, 94 insertions(+)

diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs
index 916bd2a0a..55e867f87 100644
--- a/crates/horizon-client/src/game/lightning.rs
+++ b/crates/horizon-client/src/game/lightning.rs
@@ -221,6 +221,7 @@ impl Game<'_> {
                 if !b.visual_only {
                     self.bolt_fire(b.at, 4);
                     self.strike_rod(b.at);
+                    self.bolt_clear_copper(b.at);
                 }
             }
             b.life -= 1;
@@ -278,6 +279,16 @@ impl Game<'_> {
             self.level_event_at(3002, p, axis);
         }
     }
+    /// `LightningBolt.clearCopperOnLightningStrike` at the block the bolt struck.
+    fn bolt_clear_copper(&mut self, at: [f64; 3]) {
+        let p = BlockPos::new(
+            at[0].floor() as i32,
+            (at[1] - 1.0e-6).floor() as i32,
+            at[2].floor() as i32,
+        );
+        self.with_level(|b, level, ticks| b.lightning_clear_copper(level, ticks, p));
+        let _ = self.process_level_events();
+    }
     /// `thunderHit` for entities within 3 blocks (up to 9 above).
     fn thunder_hit(&mut self, b: &mut Bolt) {
         let at = b.at;
diff --git a/crates/horizon-world/src/level/tick.rs b/crates/horizon-world/src/level/tick.rs
index 29f53e053..3cb8c2d2e 100644
--- a/crates/horizon-world/src/level/tick.rs
+++ b/crates/horizon-world/src/level/tick.rs
@@ -1479,6 +1479,80 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
         let block = b.table.block_by_name(&format!("minecraft:{next}"))?;
         Some(b.table.with_properties_of(block, state))
     }
+    /// `WeatheringCopper.getPrevious` (and `getFirst` by repeating it) by
+    /// registry naming: the block one oxidation step back.
+    fn copper_previous_name(path: &str) -> Option<String> {
+        if let Some(rest) = path.strip_prefix("oxidized_") {
+            Some(format!("weathered_{rest}"))
+        } else if let Some(rest) = path.strip_prefix("weathered_") {
+            Some(format!("exposed_{rest}"))
+        } else {
+            path.strip_prefix("exposed_").map(|rest| {
+                if rest == "copper" {
+                    "copper_block".to_owned()
+                } else {
+                    rest.to_owned()
+                }
+            })
+        }
+    }
+    fn copper_stepped(&self, state: BlockStateId, all_the_way: bool) -> Option<BlockStateId> {
+        let b = self.b;
+        let name = &*b.table.info(b.block(state)).name;
+        let mut path = Self::copper_previous_name(name.strip_prefix("minecraft:")?)?;
+        while all_the_way && let Some(earlier) = Self::copper_previous_name(&path) {
+            path = earlier;
+        }
+        let block = b.table.block_by_name(&format!("minecraft:{path}"))?;
+        Some(b.table.with_properties_of(block, state))
+    }
+    /// `LightningBolt.clearCopperOnLightningStrike`: the struck copper goes
+    /// back to unoxidized, then 3 to 5 random walks of up to 8 steps each
+    /// scrape one step of oxidation off the weathering copper they land on.
+    /// A waxed block is left as it is but still starts the walks.
+    pub(crate) fn lightning_clear_copper(&mut self, struck: BlockPos) {
+        let b = self.b;
+        let state = self.state(struck);
+        let weathering = b
+            .data(state)
+            .implements(super::classes::Interface::WeatheringCopper);
+        let waxed = b.table.name(state).starts_with("minecraft:waxed_");
+        if !(weathering || waxed) {
+            return;
+        }
+        if weathering && let Some(first) = self.copper_stepped(state, true) {
+            self.set_block_and_update(struck, first);
+        }
+        for _ in 0..self.rand_int(3) + 3 {
+            let mut at = struck;
+            for _ in 0..self.rand_int(8) + 1 {
+                // randomStepCleaningCopper: up to 10 random blocks in the
+                // 3x3x3 cube around the walk's position.
+                let mut next = None;
+                for _ in 0..10 {
+                    let x = at.x - 1 + self.rand_int(3);
+                    let y = at.y - 1 + self.rand_int(3);
+                    let z = at.z - 1 + self.rand_int(3);
+                    let candidate = BlockPos::new(x, y, z);
+                    let state = self.state(candidate);
+                    if b.data(state)
+                        .implements(super::classes::Interface::WeatheringCopper)
+                    {
+                        if let Some(previous) = self.copper_stepped(state, false) {
+                            self.set_block_and_update(candidate, previous);
+                        }
+                        self.level_event(3002, candidate, -1);
+                        next = Some(candidate);
+                        break;
+                    }
+                }
+                match next {
+                    Some(p) => at = p,
+                    None => break,
+                }
+            }
+        }
+    }
 }
 
 /// `Biome.Precipitation` at a position.
@@ -1662,6 +1736,15 @@ impl Behaviours {
     ) {
         self.sim(level, ticks).random_tick_at(pos);
     }
+    /// `LightningBolt.clearCopperOnLightningStrike` for the block at `struck`.
+    pub fn lightning_clear_copper<L: LevelAccess + ?Sized>(
+        &self,
+        level: &mut L,
+        ticks: &mut Ticks,
+        struck: BlockPos,
+    ) {
+        self.sim(level, ticks).lightning_clear_copper(struck);
+    }
     /// Run one scheduled block tick at `pos` immediately (no queue check).
     pub fn scheduled_block_tick<L: LevelAccess + ?Sized>(
         &self,

From 53501ab94ea4ad6e91003b14e2ae37106498ce2a Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:15:55 +0100
Subject: [PATCH 097/475] Merge a mob's repeated effects like vanilla

A stronger effect now replaces the old one with its own duration, instead of taking the longer duration and the higher level separately.
---
 crates/horizon-client/src/mobs.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..6a220d63d 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1854,8 +1854,15 @@ impl Mob {
     }
     pub fn add_effect(&mut self, effect: &'static str, ticks: i32, amplifier: i32) {
         if let Some(e) = self.extra.effects.iter_mut().find(|e| e.0 == effect) {
-            e.1 = e.1.max(ticks);
-            e.2 = e.2.max(amplifier);
+            // MobEffectInstance.update: a stronger effect replaces with its
+            // own duration, an equal one only extends it; a weaker one is
+            // ignored (vanilla keeps it hidden behind the active one).
+            if amplifier > e.2 {
+                e.1 = ticks;
+                e.2 = amplifier;
+            } else if amplifier == e.2 && e.1 != -1 && (ticks == -1 || e.1 < ticks) {
+                e.1 = ticks;
+            }
         } else {
             self.extra.effects.push((effect, ticks, amplifier));
         }

From 728bf14aa7db38211cd50d751f38486194d28de3 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:16:06 +0100
Subject: [PATCH 098/475] Use vanilla ambient sound intervals for guardians,
 hoglins, shulkers and allays

A happy ghast with a passenger waits six times as long.
---
 crates/horizon-client/src/mobs.rs         | 12 +++++++++++-
 crates/horizon-client/src/mobs/ai.rs      |  2 +-
 crates/horizon-client/src/mobs/species.rs |  6 ++++++
 3 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..b2028f964 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1778,7 +1778,7 @@ impl Mob {
             let dead = !self.alive();
             let sound = ai::voice_sounds(self)[if dead { 2 } else { 1 }];
             if !dead {
-                self.ambient_timer = -self.kind.ambient_interval;
+                self.ambient_timer = -self.ambient_interval();
             }
             if !sound.is_empty() {
                 let pitch = self.voice_pitch();
@@ -1874,6 +1874,16 @@ impl Mob {
         let at = [self.position.x, self.eye_y(), self.position.z];
         events.push(MobEvent::Sound(event, at, 1.0, 1.0));
     }
+    /// `Mob.getAmbientSoundInterval`; `HappyGhast` waits six times as long
+    /// while it carries a passenger.
+    pub fn ambient_interval(&self) -> i32 {
+        let ridden = self.rider.is_some() || self.extra.rider.is_some();
+        if self.species() == Species::HappyGhast && ridden {
+            self.kind.ambient_interval * 6
+        } else {
+            self.kind.ambient_interval
+        }
+    }
     /// LivingEntity.getVoicePitch.
     pub fn voice_pitch(&mut self) -> f32 {
         let pitch = (self.random.next_float() - self.random.next_float()) * 0.2
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 8335cb745..e6508b448 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -547,7 +547,7 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         let t = m.ambient_timer;
         m.ambient_timer += 1;
         if roll < t {
-            m.ambient_timer = -m.kind.ambient_interval;
+            m.ambient_timer = -m.ambient_interval();
             play_ambient(m, w, events);
         }
     }
diff --git a/crates/horizon-client/src/mobs/species.rs b/crates/horizon-client/src/mobs/species.rs
index f48a21fe9..6630ea4c5 100644
--- a/crates/horizon-client/src/mobs/species.rs
+++ b/crates/horizon-client/src/mobs/species.rs
@@ -1658,6 +1658,12 @@ impl Def {
             | S::Camel
             | S::CamelHusk => 400,
             S::Ocelot => 900,
+            // Guardian.getAmbientSoundInterval (the elder too).
+            S::Guardian | S::ElderGuardian => 160,
+            // Hoglin extends Animal; Shulker extends AbstractGolem.
+            S::Hoglin | S::Shulker => 120,
+            // Allay is a PathfinderMob: the Mob default.
+            S::Allay => 80,
             S::Squid
             | S::GlowSquid
             | S::Cod

From 273729aac8e7d6f6de6730688b900663efce2d8c Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:16:34 +0100
Subject: [PATCH 099/475] Count the combat statistics

damage_resisted, damage_absorbed and damage_blocked_by_shield now add up when
Resistance, absorption hearts or a shield take damage, and a player who lands
the killing blow on another player gets player_kills.
---
 crates/horizon-client/src/game/combat.rs  | 10 ++++++++++
 crates/horizon-client/src/game/lan_pvp.rs | 22 ++++++++++++++++++++++
 crates/horizon-client/src/game/shield.rs  |  7 +++++++
 3 files changed, 39 insertions(+)

diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs
index 106e0e1a1..197c77f17 100644
--- a/crates/horizon-client/src/game/combat.rs
+++ b/crates/horizon-client/src/game/combat.rs
@@ -73,6 +73,16 @@ impl Game<'_> {
         self.recheck_combat();
         for e in events {
             let (name, amount) = match e {
+                // LivingEntity.getDamageAfterMagicAbsorb (Resistance) and
+                // Player.actuallyHurt (absorption hearts), in tenths.
+                MotionEvent::Health(HealthEvent::Statistic { name, amount }) => {
+                    match *name {
+                        "resisted" => self.stats.custom("damage_resisted", *amount),
+                        "absorbed" => self.stats.custom("damage_absorbed", *amount),
+                        _ => {}
+                    }
+                    continue;
+                }
                 MotionEvent::Health(HealthEvent::RecordedDamage { source, amount }) => {
                     let Some(d) = self.motion.health.damage.definition(*source) else {
                         continue;
diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs
index c7c6b6525..a2ff13444 100644
--- a/crates/horizon-client/src/game/lan_pvp.rs
+++ b/crates/horizon-client/src/game/lan_pvp.rs
@@ -253,6 +253,28 @@ impl Game<'_> {
                 Victim::Host => land(self),
                 Victim::Guest(conn) => self.guest_struck_by(host, conn, land).unwrap_or(false),
             };
+        // ServerPlayer.awardKillScore: the blow that kills a player.
+        if hurt {
+            let died = match victim {
+                Victim::Host => self
+                    .player
+                    .as_ref()
+                    .is_some_and(|p| p.health.dead_or_dying()),
+                Victim::Guest(conn) => host
+                    .hub
+                    .guest(conn)
+                    .and_then(|g| g.motion.as_deref())
+                    .is_some_and(|p| p.health.dead_or_dying()),
+            };
+            if died {
+                match s.attacker {
+                    Some(conn) => {
+                        self.as_guest(host, conn, |g| g.stats.custom("player_kills", 1));
+                    }
+                    None => self.stats.custom("player_kills", 1),
+                }
+            }
+        }
         if hurt && s.crit {
             let target = match victim {
                 Victim::Host => self.player.as_ref().map(|p| (host.host_entity, p)),
diff --git a/crates/horizon-client/src/game/shield.rs b/crates/horizon-client/src/game/shield.rs
index c4f7f98d1..f4642f272 100644
--- a/crates/horizon-client/src/game/shield.rs
+++ b/crates/horizon-client/src/game/shield.rs
@@ -121,6 +121,13 @@ impl Game<'_> {
         attacker: Option<u32>,
         projectile: bool,
     ) {
+        // LivingEntity.hurtServer: the damage the shield took, in tenths.
+        if outcome.blocked > 0.0 {
+            self.stats.custom(
+                "damage_blocked_by_shield",
+                (outcome.blocked * 10.0).round() as i32,
+            );
+        }
         let Some((slot, _)) = self.using else { return };
         let Some(stack) = self.stack_in(slot).cloned() else {
             return;

From dd3697bb4d0f6acd161fc18aaa7eeab3bafbfea5 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:16:43 +0100
Subject: [PATCH 100/475] Hopper minecarts take from the container above, one
 item per tick

---
 crates/horizon-client/src/game/machines.rs  | 144 ++++++++++++++------
 crates/horizon-client/src/game/minecarts.rs |  48 +------
 2 files changed, 106 insertions(+), 86 deletions(-)

diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs
index 8742962e9..55e47aa67 100644
--- a/crates/horizon-client/src/game/machines.rs
+++ b/crates/horizon-client/src/game/machines.rs
@@ -624,46 +624,8 @@ impl Game<'_> {
     /// `HopperBlockEntity.suckInItems`: from the container above, or item entities.
     fn hopper_suck(&mut self, pos: Pos, hopper: &View) -> bool {
         let above = (pos.0, pos.1 + 1, pos.2);
-        let c = self.containers();
-        if let Some(source) = c.view(above, false) {
-            if let Kind::Composter(level) = source.kind {
-                if level != 8 {
-                    return false;
-                }
-                // tryTakeInItemFromSlot on the OutputContainer: removeItem calls
-                // its setChanged, which empties the composter, and so does the
-                // second setChanged after the move or, when the hopper has no
-                // room, the setItem putting the bone meal back into the detached
-                // container (whose bone meal is lost with it).
-                let bone_meal = c.bone_meal.clone();
-                let at = BlockPos::new(above.0, above.1, above.2);
-                self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at));
-                let moved = self.add_item(None, hopper, bone_meal, None).is_none();
-                self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at));
-                self.world.modified.insert((above.0 >> 4, above.2 >> 4));
-                return moved;
-            }
-            let source_hopper = (source.kind == Kind::Hopper).then_some(above);
-            for slot in source.slots_for_face(Some(Direction::Down)) {
-                let c = self.containers();
-                let Some(stack) = c.get(&source, slot) else {
-                    continue;
-                };
-                if !c.can_take(&source, slot, stack, Direction::Down) {
-                    continue;
-                }
-                let Some(one) = self.take_one(&source, slot) else {
-                    continue;
-                };
-                match self.add_item(source_hopper, hopper, one, None) {
-                    None => {
-                        self.view_changed(&source);
-                        return true;
-                    }
-                    Some(rest) => self.put_back(&source, slot, rest),
-                }
-            }
-            return false;
+        if let Some(took) = self.suck_from_container(above, hopper) {
+            return took;
         }
         let above_state = self.world.block(above.0, above.1, above.2);
         let blocked = self.res.facts().get(above_state).full_collision
@@ -693,6 +655,56 @@ impl Game<'_> {
         {
             return false;
         }
+        self.suck_item_entities(hopper, min, max)
+    }
+    /// The container half of `HopperBlockEntity.suckInItems`: one item from the
+    /// container at `above`, through its bottom face. `None` when there is no
+    /// container there.
+    fn suck_from_container(&mut self, above: Pos, hopper: &View) -> Option<bool> {
+        let c = self.containers();
+        let source = c.view(above, false)?;
+        if let Kind::Composter(level) = source.kind {
+            if level != 8 {
+                return Some(false);
+            }
+            // tryTakeInItemFromSlot on the OutputContainer: removeItem calls
+            // its setChanged, which empties the composter, and so does the
+            // second setChanged after the move or, when the hopper has no
+            // room, the setItem putting the bone meal back into the detached
+            // container (whose bone meal is lost with it).
+            let bone_meal = c.bone_meal.clone();
+            let at = BlockPos::new(above.0, above.1, above.2);
+            self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at));
+            let moved = self.add_item(None, hopper, bone_meal, None).is_none();
+            self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at));
+            self.world.modified.insert((above.0 >> 4, above.2 >> 4));
+            return Some(moved);
+        }
+        let source_hopper = (source.kind == Kind::Hopper).then_some(above);
+        for slot in source.slots_for_face(Some(Direction::Down)) {
+            let c = self.containers();
+            let Some(stack) = c.get(&source, slot) else {
+                continue;
+            };
+            if !c.can_take(&source, slot, stack, Direction::Down) {
+                continue;
+            }
+            let Some(one) = self.take_one(&source, slot) else {
+                continue;
+            };
+            match self.add_item(source_hopper, hopper, one, None) {
+                None => {
+                    self.view_changed(&source);
+                    return Some(true);
+                }
+                Some(rest) => self.put_back(&source, slot, rest),
+            }
+        }
+        Some(false)
+    }
+    /// The item half of `HopperBlockEntity.suckInItems` (`getItemsAtAndAbove`):
+    /// adds the item entities that meet the box, until one is taken whole.
+    fn suck_item_entities(&mut self, hopper: &View, min: [f64; 3], max: [f64; 3]) -> bool {
         let mut i = 0;
         while i < self.dropped.len() {
             let b = self.dropped[i].bounds();
@@ -717,6 +729,58 @@ impl Game<'_> {
         }
         false
     }
+    /// `MinecartHopper.tick`'s `tryConsumeItems` (`suckInItems`) for an enabled
+    /// hopper minecart: one item from the container above, else the item
+    /// entities over it or touching it, each tick without a cooldown.
+    pub(super) fn hopper_cart_suck(&mut self, cart: &mut super::minecarts::Minecart) {
+        // The cart's slots are edited as a container under the placeholder key
+        // its menu uses; when that menu is open the placeholder is the live copy.
+        let key = (i32::MAX - 15, super::minecarts::CART_KEY_Y, cart.id as i32);
+        let open = self.world.block_entities.contains_key(&key);
+        if !open {
+            let items = BlockEntity::Chest(std::mem::take(&mut cart.items));
+            self.world.block_entities.insert(key, items);
+        }
+        let size = self
+            .world
+            .block_entities
+            .get(&key)
+            .map_or(0, |e| e.slots().len());
+        let view = View {
+            parts: vec![(key, size)],
+            kind: Kind::Generic,
+        };
+        let p = cart.position;
+        // getLevelY is the cart's y + 0.5, so the container is the block at
+        // y + 1.5, and Hopper.SUCK_AABB (moved by getLevel - 0.5) starts 11/16
+        // above the cart.
+        let above = (
+            p.x.floor() as i32,
+            (p.y + 1.5).floor() as i32,
+            p.z.floor() as i32,
+        );
+        let took = match self.suck_from_container(above, &view) {
+            Some(took) => took,
+            None => self.suck_item_entities(
+                &view,
+                [p.x - 0.5, p.y + 11.0 / 16.0, p.z - 0.5],
+                [p.x + 0.5, p.y + 2.0, p.z + 0.5],
+            ),
+        };
+        if !took {
+            // The cart's own box, inflated by 0.25 sideways.
+            let b = cart.bounds();
+            let (lo, hi) = (b.min_position(), b.max_position());
+            self.suck_item_entities(
+                &view,
+                [lo.x - 0.25, lo.y, lo.z - 0.25],
+                [hi.x + 0.25, hi.y, hi.z + 0.25],
+            );
+        }
+        if !open && let Some(BlockEntity::Chest(items)) = self.world.block_entities.remove(&key) {
+            cart.items = items;
+        }
+    }
 
     // ---- dispensers and droppers ----
 
diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index a19b6df73..33e08a922 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -642,50 +642,6 @@ impl Game<'_> {
         self.carts.retain(|x| x.id != c.id);
         let _ = self.server_explode(at, power, BlockInteraction::Destroy, false);
     }
-    /// `MinecartHopper.suckInItems`: items above, into the five slots.
-    fn hopper_cart_pickup(&mut self, c: &mut Minecart) {
-        if !c.enabled {
-            return;
-        }
-        let p = c.position;
-        let zone = Aabb::new(
-            Vec3::new(p.x - 0.5, p.y - 0.5 + 0.0, p.z - 0.5),
-            Vec3::new(p.x + 0.5, p.y + 1.5, p.z + 0.5),
-        );
-        let mut i = 0;
-        while i < self.dropped.len() {
-            let e = &self.dropped[i];
-            if e.pickup_delay > 0 || !zone.contains(e.position) {
-                i += 1;
-                continue;
-            }
-            let mut stack = e.stack.clone();
-            for slot in c.items.iter_mut() {
-                match slot {
-                    None => {
-                        *slot = Some(stack.clone());
-                        stack.count = 0;
-                    }
-                    Some(s) if s.same_item_same_components(&stack) => {
-                        let max = self.res.items().get(&s.item).map_or(64, |i| i.max_stack);
-                        let moved = stack.count.min(max.saturating_sub(s.count));
-                        s.count += moved;
-                        stack.count -= moved;
-                    }
-                    _ => {}
-                }
-                if stack.count == 0 {
-                    break;
-                }
-            }
-            if stack.count == 0 {
-                self.dropped.remove(i);
-            } else {
-                self.dropped[i].stack = stack;
-                i += 1;
-            }
-        }
-    }
     /// `AbstractMinecart.push` from each player walking into a cart
     /// (`LivingEntity.pushEntities`): the window's player and every server
     /// player (single player's own on its server thread, LAN guests). A
@@ -823,8 +779,8 @@ impl Game<'_> {
             }
             let mut c = self.carts[i].clone();
             let alive = self.tick_cart(&mut c, [0.0; 2]);
-            if c.kind == CartKind::Hopper {
-                self.hopper_cart_pickup(&mut c);
+            if c.kind == CartKind::Hopper && c.enabled {
+                self.hopper_cart_suck(&mut c);
             }
             let Some(i) = self.carts.iter().position(|c| c.id == id) else {
                 continue;

From 601e7918a844884574222a26ec75d05169499386 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:16:43 +0100
Subject: [PATCH 101/475] Lightning scrapes one oxidation step off a copper
 golem

A copper golem hit by a bolt goes back one weathering step, and its
weathering timer (or wax) is reset.
---
 crates/horizon-client/src/game/lightning.rs | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs
index 916bd2a0a..b4e2c587c 100644
--- a/crates/horizon-client/src/game/lightning.rs
+++ b/crates/horizon-client/src/game/lightning.rs
@@ -16,7 +16,7 @@ pub(super) struct Bolt {
     flashes: i32,
     seed: i64,
     visual_only: bool,
-    /// Mooshrooms switch colour once per bolt.
+    /// Mooshrooms and copper golems change once per bolt.
     converted: Vec<u32>,
 }
 impl Game<'_> {
@@ -337,6 +337,17 @@ impl Game<'_> {
                     continue;
                 }
                 Species::Creeper => m.extra.charged = true,
+                // CopperGolem.thunderHit (after Entity.thunderHit's fire and
+                // damage): once per bolt, an oxidized golem goes back one step
+                // and its weathering timer (or wax, -2) is reset to -1.
+                Species::CopperGolem if !b.converted.contains(&m.id) => {
+                    b.converted.push(m.id);
+                    if m.extra.variant > 0 {
+                        m.extra.vector[0] = -1.0;
+                        m.extra.variant =
+                            horizon_client::mobs::copper_golem::weather_previous(m.extra.variant);
+                    }
+                }
                 _ => {}
             }
             // Entity.thunderHit: burning (8 seconds) and 5 lightning damage.

From ef711f8b1f356c1f1b6745b366a00c38f19076b4 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:16:44 +0100
Subject: [PATCH 102/475] Fire the brewed_potion trigger when a potion is taken
 from a brewing stand

---
 crates/horizon-client/src/game.rs             |  4 +++
 .../horizon-client/src/game/advancements.rs   | 19 +++++++++++
 .../horizon-client/src/game/lan_crafting.rs   |  9 ++++++
 crates/horizon-client/src/menu.rs             | 32 +++++++++++++------
 4 files changed, 55 insertions(+), 9 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..bb8d61f09 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -6176,6 +6176,7 @@ impl Game<'_> {
             self.player_menu_sound(sound);
         }
         let crafted = std::mem::take(&mut menu.crafted);
+        let brewed = std::mem::take(&mut menu.brewed);
         let equipped = std::mem::take(&mut menu.equipped);
         for (i, stack) in after.into_iter().enumerate() {
             if let Some(g) = game_of[i] {
@@ -6191,6 +6192,9 @@ impl Game<'_> {
                 self.player_drop(stack);
             }
             self.award_crafted(&crafted);
+            for stack in &brewed {
+                self.trigger_brewed_potion(stack);
+            }
             if furnace_before > furnace_after
                 && self.remote.is_none()
                 && let (Some(pos), Some(p)) = (self.container, self.player.as_ref())
diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs
index 0f76d0ca9..53fa282d4 100644
--- a/crates/horizon-client/src/game/advancements.rs
+++ b/crates/horizon-client/src/game/advancements.rs
@@ -708,6 +708,25 @@ impl Game<'_> {
         let it = item_view(stack);
         self.trigger(name, |c, w| adv::item_entity(c, &me, target, &it, w));
     }
+    /// `BrewedPotionTrigger`: the potion contents of a stack taken from a
+    /// brewing stand.
+    pub(super) fn trigger_brewed_potion(&mut self, stack: &ItemStack) {
+        let me = self.player_entity();
+        let potion = stack.potion().map(str::to_owned);
+        self.trigger("minecraft:brewed_potion", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            adv::conditions(&c["player"], &pctx, w)
+                && (c["potion"].is_null()
+                    || potion
+                        .as_deref()
+                        .is_some_and(|p| adv::id_matches(&c["potion"], "potion", p, w)))
+        });
+    }
     /// `EnterBlockTrigger`: the block, its state properties and the player.
     pub(super) fn trigger_enter_block(&mut self, state: horizon_world::registry::BlockStateId) {
         let Some(definition) = self.pack.assets.registry.state(state).cloned() else {
diff --git a/crates/horizon-client/src/game/lan_crafting.rs b/crates/horizon-client/src/game/lan_crafting.rs
index db6235c4d..f868bb957 100644
--- a/crates/horizon-client/src/game/lan_crafting.rs
+++ b/crates/horizon-client/src/game/lan_crafting.rs
@@ -127,9 +127,18 @@ impl Game<'_> {
         }
         let dropped = std::mem::take(&mut menu.dropped);
         let equipped = std::mem::take(&mut menu.equipped);
+        let brewed = std::mem::take(&mut menu.brewed);
         menu.drops.clear();
         menu.crafted.clear();
         store_player(menu, &mut host.hub.guests[gi]);
+        if !brewed.is_empty() {
+            let conn = host.hub.guests[gi].conn;
+            self.as_guest(host, conn, |g| {
+                for stack in &brewed {
+                    g.trigger_brewed_potion(stack);
+                }
+            });
+        }
         if !equipped.is_empty() {
             let conn = host.hub.guests[gi].conn;
             self.as_guest(host, conn, |g| {
diff --git a/crates/horizon-client/src/menu.rs b/crates/horizon-client/src/menu.rs
index 3b2b8fd31..50f90b280 100644
--- a/crates/horizon-client/src/menu.rs
+++ b/crates/horizon-client/src/menu.rs
@@ -288,6 +288,9 @@ pub struct Menu {
     pub player_sounds: Vec<&'static str>,
     /// Recipes whose result was taken (`awardUsedRecipes`), for the caller.
     pub crafted: Vec<String>,
+    /// Potions taken from a brewing stand's bottle slots
+    /// (`PotionSlot.onTake`), for the caller.
+    pub brewed: Vec<ItemStack>,
     /// `LivingEntity.onEquipItem` calls that change the item: the
     /// `EquipmentSlot` name and the new stack, in order, for the caller.
     pub equipped: Vec<(&'static str, Option<ItemStack>)>,
@@ -683,6 +686,7 @@ impl Menu {
             sounds: Vec::new(),
             player_sounds: Vec::new(),
             crafted: Vec::new(),
+            brewed: Vec::new(),
             equipped: Vec::new(),
             merchant: None,
             stone: Stonecutter::default(),
@@ -1504,7 +1508,17 @@ impl Menu {
     }
 
     /// `ResultSlot.onTake` and the other `Slot.onTake` overrides.
-    fn on_take(&mut self, env: &Env, s: usize) {
+    fn on_take(&mut self, env: &Env, s: usize, taken: &ItemStack) {
+        if self.slots[s].role == Role::Potion {
+            // BrewingStandMenu.PotionSlot.onTake: a stack with potion contents.
+            if matches!(
+                &*taken.item,
+                "minecraft:potion" | "minecraft:splash_potion" | "minecraft:lingering_potion"
+            ) {
+                self.brewed.push(taken.clone());
+            }
+            return;
+        }
         if self.slots[s].role == Role::MerchantResult {
             self.merchant_take(env);
             return;
@@ -1671,7 +1685,7 @@ impl Menu {
         max_amount: u32,
     ) -> Option<ItemStack> {
         let mut result = self.try_remove(env, s, amount, max_amount)?;
-        self.on_take(env, s);
+        self.on_take(env, s, &result);
         if self.slots[s].role == Role::CartoResult {
             Self::map_crafted(env, &mut result);
         }
@@ -2346,7 +2360,7 @@ impl Menu {
             return None;
         }
         if after_take || matches!(self.kind, Kind::Inventory | Kind::Crafting) {
-            self.on_take(env, index);
+            self.on_take(env, index, &clicked);
         }
         // What the result slot's move left over is dropped.
         if (index == 0 && matches!(self.kind, Kind::Inventory | Kind::Crafting))
@@ -2594,7 +2608,7 @@ impl Menu {
                     };
                     if let Some(mut taken) = self.try_remove(env, s, amount, u32::MAX) {
                         self.carried = Some(taken.clone());
-                        self.on_take(env, s);
+                        self.on_take(env, s, &taken);
                         if self.slots[s].role == Role::CartoResult {
                             // onTake's onCraftedBy edits the carried stack.
                             Self::map_crafted(env, &mut taken);
@@ -2628,7 +2642,7 @@ impl Menu {
                             if let Some(c) = self.carried.as_mut() {
                                 c.count += taken.count;
                             }
-                            self.on_take(env, s);
+                            self.on_take(env, s, &taken);
                             if self.slots[s].role == Role::CartoResult {
                                 // onCraftedBy edits the taken stack, not the carried one.
                                 Self::map_crafted(env, &mut taken);
@@ -2656,7 +2670,7 @@ impl Menu {
                 if self.may_pickup(env, target) {
                     self.containers[PLAYER][inv_slot] = Some(taken.clone());
                     self.set_by_player(env, target, None);
-                    self.on_take(env, target);
+                    self.on_take(env, target, &taken);
                     if self.slots[target].role == Role::CartoResult
                         && let Some(stack) = self.containers[PLAYER][inv_slot].as_mut()
                     {
@@ -2684,14 +2698,14 @@ impl Menu {
                         let part = split(&mut source, max);
                         self.containers[PLAYER][inv_slot] = Some(source);
                         self.set_by_player(env, target, Some(part));
-                        self.on_take(env, target);
+                        self.on_take(env, target, &taken);
                         if !self.inventory_add(env, &mut taken) {
                             self.drop_stack(&taken);
                         }
                     } else {
-                        self.containers[PLAYER][inv_slot] = Some(taken);
+                        self.containers[PLAYER][inv_slot] = Some(taken.clone());
                         self.set_by_player(env, target, Some(source));
-                        self.on_take(env, target);
+                        self.on_take(env, target, &taken);
                     }
                 }
             }

From 13144a82a15291da42e1449741ae15d63c33d4a9 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:13:28 +0100
Subject: [PATCH 103/475] Pull the third-person camera back further when riding
 a happy ghast

---
 crates/horizon-client/src/game/perspective.rs | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs
index caf49883b..2d5c6b05c 100644
--- a/crates/horizon-client/src/game/perspective.rs
+++ b/crates/horizon-client/src/game/perspective.rs
@@ -218,11 +218,20 @@ impl Game<'_> {
                 _ => None,
             })
         });
-        // A living mount at the default scale and camera distance.
+        // Camera.setup: the living mount's scale and camera distance
+        // attributes (the happy ghast's is 8, the default 4).
         let mount = self
             .riding
             .and_then(|id| self.mobs.iter().find(|m| m.id == id))
-            .map(|_| (1.0, 4.0));
+            .map(|m| {
+                let attribute = |name: &str, default: f64| {
+                    m.kind.attributes.get(name).copied().unwrap_or(default)
+                };
+                (
+                    attribute("minecraft:scale", 1.0) as f32,
+                    attribute("minecraft:camera_distance", 4.0),
+                )
+            });
         // AbstractBoat.positionRider turns a passenger by the boat's
         // deltaRotation after its yRotO was saved, and LocalPlayer.getViewYRot
         // interpolates a passenger's yaw: the boat's turn is spread over the

From 9c427dfae01619b5f02a863fe067990947d267ec Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:16:54 +0100
Subject: [PATCH 104/475] Mobs killed by a wither leave a wither rose

---
 crates/horizon-client/src/game/creatures.rs |  1 +
 crates/horizon-client/src/game/wither.rs    | 42 +++++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..cd211ec48 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -717,6 +717,7 @@ impl Game<'_> {
         self.villager_murdered(m, by_player);
         let pos = [m.position.x, m.position.y + 0.5, m.position.z];
         self.drop_death_loot(&mut dying, by_player, consumed, pos);
+        self.create_wither_rose(m);
         if m.species() == Species::CopperGolem {
             // CopperGolem.dropEquipment: the preserved equipment too.
             self.golem_drop_equipment(&mut dying);
diff --git a/crates/horizon-client/src/game/wither.rs b/crates/horizon-client/src/game/wither.rs
index 8084425ca..101818f68 100644
--- a/crates/horizon-client/src/game/wither.rs
+++ b/crates/horizon-client/src/game/wither.rs
@@ -2,11 +2,53 @@
 //! its boss bar, and its skulls hitting and exploding.
 use super::Game;
 use horizon_client::{
+    items::ItemStack,
     mobs::{Damage, DamageKind, Species, Who},
     projectiles::{Projectile, ProjectileKind},
 };
+use horizon_core::position::BlockPos;
 
 impl Game<'_> {
+    /// `LivingEntity.createWitherRose`: a mob a wither killed leaves a wither
+    /// rose where it stood (with mobGriefing, on air that can hold it), else
+    /// drops one.
+    pub(super) fn create_wither_rose(&mut self, m: &horizon_client::mobs::Mob) {
+        // getKillCredit: the player who last hurt it, else the last mob (kept
+        // for 100 ticks).
+        let by_wither = m.ai.last_hurt_by_player <= 0
+            && m.age as i32 - m.ai.last_hurt_by_time <= 100
+            && matches!(m.ai.last_hurt_by, Some(Who::Mob(id))
+                if self.mobs.iter().any(|o| o.id == id && o.alive() && o.species() == Species::Wither));
+        if !by_wither {
+            return;
+        }
+        let pos = [
+            m.position.x.floor() as i32,
+            m.position.y.floor() as i32,
+            m.position.z.floor() as i32,
+        ];
+        let registry = self.pack.assets.registry;
+        let rose = registry.default_state("minecraft:wither_rose");
+        if self.ui.rules.bool("mob_griefing")
+            && let Some(rose) = rose
+            && self
+                .res
+                .facts()
+                .is_air(self.world.block(pos[0], pos[1], pos[2]))
+            && self.with_level(|b, level, ticks| {
+                b.can_survive(level, ticks, BlockPos::new(pos[0], pos[1], pos[2]), rose)
+            })
+        {
+            let _ = self.level_set(pos, rose);
+            return;
+        }
+        self.spawn_item(
+            ItemStack::new("minecraft:wither_rose", 1),
+            [m.position.x, m.position.y, m.position.z],
+            super::dispenser::new_item_motion(),
+            0,
+        );
+    }
     fn is_wither_skull(&self, p: [i32; 3]) -> bool {
         let name = &*self
             .res

From 8c8f857313bd5fbe82cb47af8d339640460ac174 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:17:42 +0100
Subject: [PATCH 105/475] Fire item_used_on_block when an axe, honeycomb, disc
 or vault key is used on a block

---
 crates/horizon-client/src/game.rs         | 4 ++++
 crates/horizon-client/src/game/jukebox.rs | 2 ++
 crates/horizon-client/src/game/vault.rs   | 2 ++
 3 files changed, 8 insertions(+)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..fa7f0c133 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -8586,6 +8586,8 @@ impl Game<'_> {
         else {
             return Ok(false);
         };
+        // BlockTransformer.transformBlock: ITEM_USED_ON_BLOCK before the swap.
+        self.trigger_block("minecraft:item_used_on_block", pos, stack);
         self.level_set(pos, new)?;
         // BlockTransformer.TransformParticle.send.
         self.transform_particle(&particle, pos);
@@ -8832,6 +8834,8 @@ impl Game<'_> {
             if let Some(waxed) = old.and_then(|old| self.res.transformers().waxed(registry, &old))
                 && let Ok(state) = registry.resolve(&waxed)
             {
+                // HoneycombItem.useOn: ITEM_USED_ON_BLOCK before the swap.
+                self.trigger_block("minecraft:item_used_on_block", hit.pos, stack);
                 self.level_set(hit.pos, state)?;
                 self.level_event_at(3003, hit.pos, 0);
                 self.audio.play(
diff --git a/crates/horizon-client/src/game/jukebox.rs b/crates/horizon-client/src/game/jukebox.rs
index c3ed75ebb..bd130ce9b 100644
--- a/crates/horizon-client/src/game/jukebox.rs
+++ b/crates/horizon-client/src/game/jukebox.rs
@@ -90,6 +90,8 @@ impl Game<'_> {
         self.set_has_record(pos, true);
         self.start_song(pos, &song);
         self.jukebox_changed(pos);
+        // ServerPlayerGameMode.useItemOn: the action was consumed.
+        self.trigger_block("minecraft:item_used_on_block", pos, stack);
         true
     }
     /// Level event 1010: the song from the jukebox, and the "Now Playing" overlay.
diff --git a/crates/horizon-client/src/game/vault.rs b/crates/horizon-client/src/game/vault.rs
index f3edfddb3..18430daf6 100644
--- a/crates/horizon-client/src/game/vault.rs
+++ b/crates/horizon-client/src/game/vault.rs
@@ -169,6 +169,8 @@ impl Game<'_> {
                 self.consume_held();
             }
         }
+        // ServerPlayerGameMode.useItemOn: the action was consumed.
+        self.trigger_block("minecraft:item_used_on_block", pos, &stack);
         Ok(true)
     }
     fn vault_events(&mut self, key: Pos, events: Vec<VaultEvent>) -> Result<()> {

From b913dab5e52e179e73c3bdebe1ee77266e92a34f Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:17:53 +0100
Subject: [PATCH 106/475] Walk, follow and flee at the camel's real AI speeds

---
 crates/horizon-client/src/mobs/camel.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/mobs/camel.rs b/crates/horizon-client/src/mobs/camel.rs
index 21ebe9e16..703c8fa8f 100644
--- a/crates/horizon-client/src/mobs/camel.rs
+++ b/crates/horizon-client/src/mobs/camel.rs
@@ -24,12 +24,13 @@ pub fn register(m: &mut Mob) {
     m.extra.tame = true;
     let tempt = m.kind.tempt.clone();
     let g = &mut m.ai.goals;
+    // CamelAi speed modifiers (times the 0.09 movement speed attribute).
     g.add(0, Float);
-    g.add(1, CamelPanic(Panic::new(4.0 * 0.25)));
+    g.add(1, CamelPanic(Panic::new(4.0)));
     g.add(2, Breed::new(1.0));
-    g.add(3, Tempt::new(2.5 * 0.25, tempt, false));
-    g.add(4, FollowParent::new(2.5 * 0.25));
-    g.add(5, Stroll::new(2.0 * 0.25));
+    g.add(3, Tempt::new(2.5, tempt, false));
+    g.add(4, FollowParent::new(2.5));
+    g.add(5, Stroll::new(2.0));
     g.add(5, RandomSitting);
     g.add(6, LookAtPlayer::new(6.0));
     g.add(7, RandomLookAround::default());

From b3a499d85d720acf6d133f47f79806edfa485560 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:18:05 +0100
Subject: [PATCH 107/475] Play chest, barrel and shulker box sounds with a
 random pitch from the right spot

---
 crates/horizon-client/src/game.rs         | 22 ++------------
 crates/horizon-client/src/game/storage.rs | 35 +++++++++++++++++++++++
 2 files changed, 37 insertions(+), 20 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..147aefe36 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -3077,16 +3077,7 @@ impl Game<'_> {
                 None
             };
             if let Some(sound) = sound {
-                self.audio.play(
-                    sound,
-                    Some([
-                        f64::from(key.0) + 0.5,
-                        f64::from(key.1) + 0.5,
-                        f64::from(key.2) + 0.5,
-                    ]),
-                    0.5,
-                    1.0,
-                );
+                self.container_sound(sound, key, &name);
             }
         } else if self.open_station(pos, &name) {
             // Workstation menus: game/stations.rs.
@@ -5654,16 +5645,7 @@ impl Game<'_> {
                 None
             };
             if let Some(sound) = sound {
-                self.audio.play(
-                    sound,
-                    Some([
-                        f64::from(key.0) + 0.5,
-                        f64::from(key.1) + 0.5,
-                        f64::from(key.2) + 0.5,
-                    ]),
-                    0.5,
-                    1.0,
-                );
+                self.container_sound(sound, key, &name);
             }
             self.world.modified.insert((key.0 >> 4, key.2 >> 4));
         }
diff --git a/crates/horizon-client/src/game/storage.rs b/crates/horizon-client/src/game/storage.rs
index 1bcb6a524..3456c4ab0 100644
--- a/crates/horizon-client/src/game/storage.rs
+++ b/crates/horizon-client/src/game/storage.rs
@@ -3,6 +3,7 @@
 //! player's `PlayerEnderChestContainer`, saved as `EnderItems`).
 use super::Game;
 use horizon_client::{containers::BlockEntity, items::ItemStack, text::Text};
+use horizon_core::random::RandomSource;
 
 pub(super) fn is_shulker_box(name: &str) -> bool {
     name.ends_with("shulker_box")
@@ -107,6 +108,40 @@ impl Game<'_> {
             );
         paired.then_some((other, kind == "right"))
     }
+    /// The open or close sound of a container block (`ChestBlockEntity.playSound`,
+    /// `BarrelBlockEntity.playSound`, `ShulkerBoxBlockEntity.startOpen`): volume
+    /// 0.5 and pitch 0.9 to 1.0. A double chest sounds once from the middle of
+    /// both halves, a barrel from the face it opens on.
+    pub(super) fn container_sound(&mut self, sound: &str, key: (i32, i32, i32), name: &str) {
+        let mut at = [
+            f64::from(key.0) + 0.5,
+            f64::from(key.1) + 0.5,
+            f64::from(key.2) + 0.5,
+        ];
+        if let Some((other, _)) = self.chest_partner(key) {
+            at[0] = f64::from(key.0 + other.0) / 2.0 + 0.5;
+            at[2] = f64::from(key.2 + other.2) / 2.0 + 0.5;
+        } else if name == "minecraft:barrel"
+            && let Some(state) = self
+                .pack
+                .assets
+                .registry
+                .state(self.world.block(key.0, key.1, key.2))
+            && let Some(facing) = state.properties.get("facing")
+        {
+            let (dx, dy, dz) = match facing.as_str() {
+                "up" => (0.0, 0.5, 0.0),
+                "down" => (0.0, -0.5, 0.0),
+                f => {
+                    let (x, z) = facing_step(f);
+                    (f64::from(x) / 2.0, 0.0, f64::from(z) / 2.0)
+                }
+            };
+            at = [at[0] + dx, at[1] + dy, at[2] + dz];
+        }
+        let pitch = self.world.random.next_float() * 0.1 + 0.9;
+        self.audio.play(sound, Some(at), 0.5, pitch);
+    }
     /// The other half of a double chest at `key`, for neighbour updates.
     pub(super) fn chest_other_half(&self, key: (i32, i32, i32)) -> Option<(i32, i32, i32)> {
         self.chest_partner(key).map(|p| p.0)

From 147e5269c76430060007b13a1dc947a99062896c Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:19:20 +0100
Subject: [PATCH 108/475] Play the rain sound the way vanilla picks it

---
 crates/horizon-client/src/game.rs             | 35 +++----------------
 crates/horizon-client/src/game/render_tick.rs | 23 +++++++++++-
 2 files changed, 26 insertions(+), 32 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..f491b3f8f 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -1382,6 +1382,8 @@ struct Game<'a> {
     /// `ClientAvatarState`: walked distance and view bob.
     avatar: horizon_client::camera::AvatarBob,
     flash: u32,
+    /// `ClientLevel.rainSoundTime`: ticks of rain since the last rain sound.
+    rain_sound_time: i32,
     /// Bolts that struck here and sky flashes they made, in total (`status`).
     lightning_seen: [u32; 2],
     /// The head of the bed while sleeping; the visual timer also survives waking.
@@ -9497,37 +9499,7 @@ impl Game<'_> {
         if self.flash > 0 {
             self.flash -= 1;
         }
-        let (rain, _) = self.world.weather.levels(1.0);
-        let Some(eye) = self.eye_position() else {
-            return;
-        };
-        // WeatherEffectRenderer.tickRainParticles: occasional rain sounds.
-        if rain > 0.0 && self.world.random.next_int_bound(3).unwrap_or(1) < (rain * 3.0) as i32 {
-            let r = &mut self.world.random;
-            let (dx, dz) = (
-                r.next_int_bound(21).unwrap_or(10) - 10,
-                r.next_int_bound(21).unwrap_or(10) - 10,
-            );
-            let (x, z) = (eye[0].floor() as i32 + dx, eye[2].floor() as i32 + dz);
-            let top = self.rain_height(x, z);
-            if self.precipitation(x, top, z) == Some(false)
-                && (top - eye[1] as i32).abs() < 10
-                && self.world.random.next_int_bound(5).unwrap_or(1) == 0
-            {
-                let above = f64::from(top) > eye[1] + 1.0;
-                let (name, volume, pitch) = if above {
-                    ("minecraft:weather.rain.above", 0.1, 0.5)
-                } else {
-                    ("minecraft:weather.rain", 0.2, 1.0)
-                };
-                self.audio.play(
-                    name,
-                    Some([f64::from(x) + 0.5, f64::from(top), f64::from(z) + 0.5]),
-                    volume,
-                    pitch,
-                );
-            }
-        }
+        // The rain sounds come with the rain splashes (`tick_particles`).
     }
     /// WeatherEffectRenderer: rain and snow columns within the weather radius.
     fn weather_geometry(
@@ -12267,6 +12239,7 @@ impl<'a> Game<'a> {
             dragging: false,
             avatar: Default::default(),
             flash: 0,
+            rain_sound_time: 0,
             lightning_seen: [0; 2],
             sleeping: None,
             sleep_timer: 0,
diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs
index e013c8d29..2356fbffe 100644
--- a/crates/horizon-client/src/game/render_tick.rs
+++ b/crates/horizon-client/src/game/render_tick.rs
@@ -288,11 +288,13 @@ impl Game<'_> {
             ];
             animate_tick(self.res.animate(), &mut self.particles, &ctx, block);
             if rain > 0.0 {
-                // ClientLevel.tickWeatherEffects: rain splashes (weather radius 10).
+                // ClientLevel.tickWeatherEffects: rain splashes (weather radius 10)
+                // and the rain sound.
                 let mut random = LegacyRandom::new(self.world.game_time.wrapping_mul(312_987_231));
                 let radius = 10;
                 let diameter = 2 * radius + 1;
                 let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32;
+                let mut rain_position = None;
                 for _ in 0..count {
                     let x = block[0] + random.next_int_bound(diameter).unwrap_or(0) - radius;
                     let z = block[2] + random.next_int_bound(diameter).unwrap_or(0) - radius;
@@ -305,6 +307,7 @@ impl Game<'_> {
                         continue;
                     }
                     let below = top - 1;
+                    rain_position = Some([x, below, z]);
                     let (bx, bz) = (random.next_double(), random.next_double());
                     let state = world.block(x, below, z);
                     let f = facts.get(state);
@@ -336,6 +339,24 @@ impl Game<'_> {
                     self.particles
                         .add(&ParticleOptions::simple(ty), p, [0.0; 3]);
                 }
+                // The last rain column of the tick makes the sound, more often the
+                // longer it has been quiet; indoors it is the quieter one.
+                if let Some(at) = rain_position {
+                    let waited = self.rain_sound_time;
+                    self.rain_sound_time += 1;
+                    if random.next_int_bound(3).unwrap_or(0) < waited {
+                        self.rain_sound_time = 0;
+                        let roof =
+                            motion_blocking(world, facts, block[0], block[2], MIN_Y + HEIGHT);
+                        let (name, volume, pitch) = if at[1] > block[1] + 1 && roof > block[1] {
+                            ("minecraft:weather.rain.above", 0.1, 0.5)
+                        } else {
+                            ("minecraft:weather.rain", 0.2, 1.0)
+                        };
+                        let p = at.map(|c| f64::from(c) + 0.5);
+                        self.audio.play(name, Some(p), volume, pitch);
+                    }
+                }
             }
         }
         if let Some(r) = &self.renderer {

From 2e642857fc36d4b4d2e1148dc0fedf73aead5128 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:20:03 +0100
Subject: [PATCH 109/475] Fire the levitation and using_item advancement
 triggers

---
 crates/horizon-client/src/advancements.rs     | 47 +++++-----
 crates/horizon-client/src/game.rs             |  2 +
 .../horizon-client/src/game/advancements.rs   | 85 +++++++++++++++++++
 crates/horizon-client/src/game/lan_actions.rs |  7 ++
 4 files changed, 120 insertions(+), 21 deletions(-)

diff --git a/crates/horizon-client/src/advancements.rs b/crates/horizon-client/src/advancements.rs
index 6706532b7..187f88382 100644
--- a/crates/horizon-client/src/advancements.rs
+++ b/crates/horizon-client/src/advancements.rs
@@ -437,6 +437,8 @@ pub struct EntityView {
     /// mainhand, offhand, head, chest, legs, feet, body.
     pub equipment: [Option<ItemView>; 7],
     pub vehicle: Option<Box<EntityView>>,
+    /// Player: what it looks at within 100 blocks (`PlayerPredicate.lookingAt`).
+    pub looking_at: Option<Box<EntityView>>,
     pub effects: Vec<(String, i32, i32)>,
     /// Player: game mode name.
     pub gamemode: Option<String>,
@@ -458,7 +460,7 @@ fn range_f(v: &Value, x: f64) -> bool {
         _ => false,
     }
 }
-fn range_i(v: &Value, x: i64) -> bool {
+pub fn range_i(v: &Value, x: i64) -> bool {
     range_f(v, x as f64)
 }
 /// A registry id, `#tag`, or list matched against one id.
@@ -614,6 +616,18 @@ fn components(expected: &Value, have: &[(String, String)]) -> bool {
         })
     })
 }
+/// `DistancePredicate.matches` between two points.
+pub fn distance(v: &Value, a: [f64; 3], b: [f64; 3]) -> bool {
+    let d = [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+    range_f(&v["x"], d[0].abs())
+        && range_f(&v["y"], d[1].abs())
+        && range_f(&v["z"], d[2].abs())
+        && range_f(&v["horizontal"], (d[0] * d[0] + d[2] * d[2]).sqrt())
+        && range_f(
+            &v["absolute"],
+            (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt(),
+        )
+}
 /// `EntityPredicate` (26.x keyed sub-predicates).
 pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> bool {
     if v.is_null() {
@@ -629,21 +643,7 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo
             "minecraft:stepping_on" => {
                 location(p, [e.position[0], e.position[1] - 0.5, e.position[2]], w)
             }
-            "minecraft:distance" | "distance" => {
-                let d = [
-                    e.position[0] - origin[0],
-                    e.position[1] - origin[1],
-                    e.position[2] - origin[2],
-                ];
-                range_f(&p["x"], d[0].abs())
-                    && range_f(&p["y"], d[1].abs())
-                    && range_f(&p["z"], d[2].abs())
-                    && range_f(&p["horizontal"], (d[0] * d[0] + d[2] * d[2]).sqrt())
-                    && range_f(
-                        &p["absolute"],
-                        (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt(),
-                    )
-            }
+            "minecraft:distance" | "distance" => distance(p, e.position, origin),
             "minecraft:flags" | "flags" => {
                 let f = |k: &str, have: bool| p[k].as_bool().is_none_or(|want| want == have);
                 f("is_on_fire", e.on_fire)
@@ -678,11 +678,16 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo
                     })
                 })
             }),
-            "minecraft:type_specific/player" => p["gamemode"].as_array().is_none_or(|modes| {
-                e.gamemode
-                    .as_deref()
-                    .is_some_and(|g| modes.iter().any(|m| m.as_str() == Some(g)))
-            }),
+            "minecraft:type_specific/player" => {
+                p["gamemode"].as_array().is_none_or(|modes| {
+                    e.gamemode
+                        .as_deref()
+                        .is_some_and(|g| modes.iter().any(|m| m.as_str() == Some(g)))
+                }) && (p["looking_at"].is_null()
+                    || e.looking_at
+                        .as_ref()
+                        .is_some_and(|t| entity(&p["looking_at"], t, w, origin)))
+            }
             "minecraft:type_specific/lightning" => {
                 range_i(&p["blocks_set_on_fire"], 0)
                     && (p["entity_struck"].is_null()
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..ae29abe8f 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -3875,6 +3875,8 @@ impl Game<'_> {
             self.release_used_item(&stack, ticks, hand_changed);
             return;
         }
+        // ServerPlayer.updateUsingItem: USING_ITEM every tick of the use.
+        self.trigger_using_item(&stack);
         let Some(info) = self.res.items().get(&stack.item).cloned() else {
             self.using = None;
             return;
diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs
index 0f76d0ca9..67615b628 100644
--- a/crates/horizon-client/src/game/advancements.rs
+++ b/crates/horizon-client/src/game/advancements.rs
@@ -82,6 +82,8 @@ pub(super) struct AdvState {
     pub(super) quiet: bool,
     /// The inventory last seen by `inventory_changed`.
     pub(super) last_inventory: u64,
+    /// `ServerPlayer.levitationStartPos` and `levitationStartTime`.
+    pub(super) levitation: Option<([f64; 3], u64)>,
     /// While the game acts for a network player (`as_guest`): the
     /// advancements whose progress changed (`progressChanged`), the recipes
     /// unlocked and the announcements, for their client and everyone's.
@@ -647,6 +649,28 @@ impl Game<'_> {
             };
             adv::conditions(&c["player"], &ctx, w)
         });
+        // ServerPlayer.onEffectAdded and onEffectsRemoved keep the start of a
+        // levitation; tick fires LEVITATION while there is one.
+        let levitating = self
+            .potions
+            .effects
+            .list
+            .iter()
+            .any(|e| e.id == "levitation");
+        match (levitating, self.adv.levitation) {
+            (true, None) => {
+                let at = self
+                    .player
+                    .as_ref()
+                    .map(|p| [p.position.x, p.position.y, p.position.z]);
+                self.adv.levitation = at.map(|at| (at, self.ticks));
+            }
+            (false, Some(_)) => self.adv.levitation = None,
+            _ => {}
+        }
+        if let Some((start, since)) = self.adv.levitation {
+            self.trigger_levitation(start, (self.ticks - since) as i64);
+        }
         if self.ticks.is_multiple_of(20) {
             let me = self.player_entity();
             self.trigger("minecraft:location", |c, w| {
@@ -681,6 +705,67 @@ impl Game<'_> {
             adv::conditions(&c["player"], &pctx, w) && adv::conditions(&c[&key], &ectx, w)
         });
     }
+    /// `LevitationTrigger`: how far the player rose from where it started
+    /// levitating, and for how long.
+    fn trigger_levitation(&mut self, start: [f64; 3], duration: i64) {
+        let me = self.player_entity();
+        self.trigger("minecraft:levitation", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            adv::conditions(&c["player"], &pctx, w)
+                && (c["distance"].is_null() || adv::distance(&c["distance"], start, me.position))
+                && adv::range_i(&c["duration"], duration)
+        });
+    }
+    /// `ServerPlayer.updateUsingItem`: USING_ITEM for the item in use, with
+    /// what the player looks at (`PlayerPredicate.lookingAt`).
+    pub(super) fn trigger_using_item(&mut self, stack: &ItemStack) {
+        if self.remote.is_some() || self.no_player_here() {
+            return;
+        }
+        let mut me = self.player_entity();
+        me.looking_at = self.looking_at_entity().map(Box::new);
+        let it = item_view(stack);
+        self.trigger("minecraft:using_item", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            adv::conditions(&c["player"], &pctx, w) && adv::item(&c["item"], &it, w)
+        });
+    }
+    /// The mob a 100 block ray from the eyes meets first, if no block is in
+    /// the way (`ProjectileUtil.getEntityHitResult` and `hasLineOfSight`).
+    fn looking_at_entity(&self) -> Option<EntityView> {
+        let eye = self.eye_position()?;
+        let dir = super::view_vector(self.yaw, self.pitch);
+        let (m, _) = self
+            .mobs
+            .iter()
+            .filter(|m| m.alive())
+            .filter_map(|m| Some((m, super::ray_box(eye, dir, 100.0, m.bounds())?)))
+            .min_by(|a, b| a.1.total_cmp(&b.1))?;
+        // Eye to the target's centre, two samples per block.
+        let to = m.center();
+        let reach = (0..3).map(|i| (to[i] - eye[i]).powi(2)).sum::<f64>().sqrt();
+        let steps = (reach * 2.0).ceil().max(1.0) as i32;
+        let clear = (1..steps).all(|i| {
+            let f = f64::from(i) / f64::from(steps);
+            let p = [0, 1, 2].map(|a| (eye[a] + (to[a] - eye[a]) * f).floor() as i32);
+            !self
+                .res
+                .facts()
+                .get(self.world.block(p[0], p[1], p[2]))
+                .full_collision
+        });
+        clear.then(|| self.mob_entity(m))
+    }
     /// A player condition plus one item (`item` key).
     pub(super) fn trigger_item(&mut self, name: &str, stack: &ItemStack) {
         let me = self.player_entity();
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 0ad14bbcc..d1696d19a 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -75,6 +75,8 @@ pub(super) struct GuestPlay {
     /// `ServerPlayer.getStats` and the inventory `inventory_changed` last saw.
     pub(super) stats: super::stats::Stats,
     last_inventory: u64,
+    /// `ServerPlayer.levitationStartPos` and `levitationStartTime`.
+    levitation: Option<([f64; 3], u64)>,
     /// `Entity.portalProcess` and `portalCooldown` (game/server_travel.rs).
     pub(super) portal: horizon_client::nether_portal::PortalState,
     /// `Player.takeXpDelay`: ticks until the next orb can be taken.
@@ -154,6 +156,7 @@ pub(super) struct GuestSwap {
     host_ender: Option<(i32, i32, i32)>,
     adv_loaded: bool,
     last_inventory: u64,
+    levitation: Option<([f64; 3], u64)>,
     death_cause: Option<String>,
     /// The guest's own damage record, in place while they act.
     combat: super::combat::CombatTracker,
@@ -378,6 +381,7 @@ impl Game<'_> {
         std::mem::swap(&mut self.hook, &mut play.hook);
         let adv_loaded = std::mem::replace(&mut self.adv.loaded, true);
         let last_inventory = std::mem::replace(&mut self.adv.last_inventory, play.last_inventory);
+        let levitation = std::mem::replace(&mut self.adv.levitation, play.levitation);
         let death_cause = std::mem::replace(&mut self.ui.death_cause, play.death_cause.take());
         let acting = (
             self.lan_acting.replace(conn),
@@ -442,6 +446,7 @@ impl Game<'_> {
             host_ender,
             adv_loaded,
             last_inventory,
+            levitation,
             death_cause,
             acting,
             packets,
@@ -500,6 +505,7 @@ impl Game<'_> {
             host_ender,
             adv_loaded,
             last_inventory,
+            levitation,
             death_cause,
             combat,
             acting,
@@ -610,6 +616,7 @@ impl Game<'_> {
         std::mem::swap(&mut self.hook, &mut play.hook);
         self.adv.loaded = adv_loaded;
         play.last_inventory = std::mem::replace(&mut self.adv.last_inventory, last_inventory);
+        play.levitation = std::mem::replace(&mut self.adv.levitation, levitation);
         let stat_events = std::mem::take(&mut play.stats.events);
         let name = g.name.clone();
         self.potions.swap_player(&mut g.effects, &mut play.potions);

From aff673a08dbec0ababc2e70c51abe1706cd32c5e Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:20:10 +0100
Subject: [PATCH 110/475] Give the Ender Dragon its ambient sound

---
 crates/horizon-client/src/game/dragon.rs | 25 ++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index f28049fd5..96c8ef478 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -26,6 +26,8 @@ pub(super) const SPECIAL: u32 = u32::MAX - 4096;
 const CRYSTAL_IDS: u32 = SPECIAL + 16;
 const FIGHT_FILE: &str = "data/minecraft/ender_dragon_fight.dat";
 const MAX_HEALTH: f32 = 200.0;
+/// `Mob.getAmbientSoundInterval`.
+const AMBIENT_INTERVAL: i32 = 80;
 
 #[derive(Default)]
 pub(super) struct Fight {
@@ -269,6 +271,8 @@ pub(super) struct Dragon {
     flame_count: i32,
     sitting_damage: f32,
     growl: i32,
+    /// `Mob.ambientSoundTime`.
+    ambient_time: i32,
     ticks: i32,
     /// DragonFlightHistory: (y, yRot) samples, newest at `head`.
     history: [(f64, f32); 64],
@@ -396,6 +400,7 @@ impl Dragon {
             flame_count: 0,
             sitting_damage: 0.0,
             growl: 100,
+            ambient_time: 0,
             ticks: 0,
             history: [(position.y, yaw); 64],
             head: 0,
@@ -986,6 +991,8 @@ impl Game<'_> {
         };
         let hurt = d.hurt(part, damage, counts, arrow);
         if hurt == (Hurt::Landed { full: true }) {
+            // Mob.playHurtSound: the ambient sound clock starts again.
+            d.ambient_time = -AMBIENT_INTERVAL;
             let at = [d.position.x, d.position.y, d.position.z];
             let pitch = 0.8 + self.world.random.next_float() * 0.3;
             self.audio
@@ -1656,6 +1663,24 @@ impl Game<'_> {
             self.tick_dragon_death();
             return;
         }
+        // Mob.baseTick: the ambient sound, rarer right after one.
+        let roll = d.random.next_int_bound(1000).unwrap_or(999);
+        let waited = d.ambient_time;
+        d.ambient_time += 1;
+        if roll < waited {
+            d.ambient_time = -AMBIENT_INTERVAL;
+            let at = [d.position.x, d.position.y, d.position.z];
+            // LivingEntity.getVoicePitch.
+            let r = &mut self.world.random;
+            let pitch = (r.next_float() - r.next_float()) * 0.2 + 1.0;
+            self.audio.play(
+                "minecraft:entity.ender_dragon.ambient",
+                Some(at),
+                5.0,
+                pitch,
+            );
+        }
+        let d = self.dragon.as_mut().expect("dragon");
         // Flapping, growls and the flap sound.
         let flap_was = (d.old_flap * std::f32::consts::TAU).cos();
         let v = d.velocity;

From 70868f32087fda64a976ff027af6658e6725f69c Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:20:34 +0100
Subject: [PATCH 111/475] Give Oozing, Infested, Weaving and Wind Charged their
 effects

These four 26.x effects only existed as potion entries. Oozing spawns two slimes, Weaving places cobwebs and Wind Charged makes a gust when the bearer dies. Infested sometimes releases silverfish when the bearer is hurt.
---
 crates/horizon-client/src/game/combat.rs    |   4 +
 crates/horizon-client/src/game/creatures.rs |  26 ++++
 crates/horizon-client/src/game/potions.rs   | 156 +++++++++++++++++++-
 crates/horizon-client/src/mobs.rs           |   7 +
 4 files changed, 191 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs
index 106e0e1a1..1af22fe48 100644
--- a/crates/horizon-client/src/game/combat.rs
+++ b/crates/horizon-client/src/game/combat.rs
@@ -109,6 +109,10 @@ impl Game<'_> {
                 attacker,
             });
             self.combat.last_damage = now;
+            // InfestedMobEffect.onMobHurt.
+            if self.potions.effects.get("infested").is_some() {
+                self.player_infested();
+            }
         }
         self.combat.pending.clear();
         self.combat.fall_before = self.player.as_ref().map_or(0.0, |p| p.fall_distance);
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..de1cd1bee 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -501,6 +501,7 @@ impl Game<'_> {
         let mut events = Vec::new();
         let mut mobs = std::mem::take(&mut self.mobs);
         let mut dead = Vec::new();
+        let mut corpses = Vec::new();
         let mut died = std::mem::take(&mut self.died);
         let ticking = self.entity_ticking_area();
         // With guests on, each mob sees its nearest player (game/lan_mobs.rs).
@@ -593,6 +594,11 @@ impl Game<'_> {
                 horizon_client::mobs::apply_mob_pushes(m, &mut pushes);
                 let from = events.len();
                 let kept = m.tick(&w, &mut scratch, &mut events);
+                // A killed mob's body is removed: its effects that act on
+                // death run (`LivingEntity.remove` with KILLED).
+                if !kept && !m.alive() && !m.removed && !m.extra.effects.is_empty() {
+                    corpses.push(m.clone());
+                }
                 horizon_client::mobs::take_mob_pushes(&mut events, from, &mut pushes);
                 if let Some(conn) = seen_guest {
                     // ShulkerBullet.finalTarget is the guest's entity: the
@@ -661,6 +667,15 @@ impl Game<'_> {
         for m in dead {
             self.mob_died(&m);
         }
+        for m in corpses {
+            let names: Vec<&'static str> = m
+                .extra
+                .effects
+                .iter()
+                .map(|e| e.0.trim_start_matches("minecraft:"))
+                .collect();
+            self.effects_on_death(&names, m.bounds(), false, Some(m.id));
+        }
         self.handle_mob_events(events)?;
         self.lan_guest_mob_events(guest_events);
         self.tick_projectiles()?;
@@ -990,6 +1005,17 @@ impl Game<'_> {
                 }
                 MobEvent::BecomeStatue { mob } => self.golem_become_statue(mob),
                 MobEvent::EnterHive { mob, hive } => self.bee_enter_hive(mob, hive),
+                MobEvent::Infested { mob } => {
+                    if let Some(m) = self.mobs.iter().find(|m| m.id == mob) {
+                        let at = [
+                            m.position.x,
+                            m.position.y + f64::from(m.height()) / 2.0,
+                            m.position.z,
+                        ];
+                        let look = m.view_vector();
+                        self.infested_hurt(at, look);
+                    }
+                }
                 MobEvent::Gift { target, item } => {
                     if let Some(m) = self.mobs.iter_mut().find(|m| m.id == target)
                         && m.saddle_item().is_none()
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index b28c2fb4d..360ed0612 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -13,7 +13,10 @@ use horizon_client::{
     items::ItemStack,
     mesher::Vertex,
 };
-use horizon_core::{geometry::Vec3, random::RandomSource};
+use horizon_core::{
+    geometry::{Aabb, Direction, Vec3},
+    random::RandomSource,
+};
 
 /// A thrown splash or lingering potion in flight.
 #[derive(Clone, Debug)]
@@ -45,6 +48,136 @@ fn mob_effect_id(id: &str) -> Option<&'static str> {
     .copied()
 }
 impl Game<'_> {
+    /// `LivingEntity.triggerOnDeathMobEffects` (`onMobRemoved` with the reason
+    /// KILLED) for what Oozing, Weaving and Wind Charged do when their bearer
+    /// dies. `bearer` is the dying mob's id, `player` whether it is a player.
+    pub(super) fn effects_on_death(
+        &mut self,
+        effects: &[&str],
+        bounds: Aabb,
+        player: bool,
+        bearer: Option<u32>,
+    ) {
+        let feet = bounds.bottom_center();
+        if effects.contains(&"oozing") {
+            // OozingMobEffect.numberOfSlimesToSpawn: two, fewer when the
+            // slimes close by already fill the cramming limit.
+            let limit = self.ui.rules.int("max_entity_cramming");
+            let mut count = 2;
+            if limit >= 1 {
+                let near = bounds.inflate(Vec3::new(2.0, 2.0, 2.0));
+                let nearby = self
+                    .mobs
+                    .iter()
+                    .filter(|m| {
+                        m.species() == horizon_client::mobs::Species::Slime
+                            && Some(m.id) != bearer
+                            && m.bounds().intersects(near)
+                    })
+                    .count()
+                    .min(limit as usize) as i32;
+                count = (limit - nearby).clamp(0, count);
+            }
+            for _ in 0..count {
+                // spawnSlimeOffspring: a size 2 slime half a block up.
+                if let Some(id) = self.spawn_mob_for(
+                    "minecraft:slime",
+                    [feet.x, feet.y + 0.5, feet.z],
+                    false,
+                    true,
+                ) && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
+                {
+                    horizon_client::mobs::cube::set_size(m, 2);
+                }
+            }
+        }
+        if effects.contains(&"weaving") && (player || self.ui.rules.bool("mob_griefing")) {
+            self.spawn_cobwebs_around([
+                feet.x.floor() as i32,
+                feet.y.floor() as i32,
+                feet.z.floor() as i32,
+            ]);
+        }
+        if effects.contains(&"wind_charged") {
+            // A burst centred at half the height, radius 3 to 5.
+            let center = [feet.x, feet.y + bounds.size().y / 2.0, feet.z];
+            let radius = 3.0 + self.world.random.next_float() * 2.0;
+            let _ = self.wind_burst(center, radius, 1.0, false, false);
+        }
+    }
+    /// `WeavingMobEffect.spawnCobwebsRandomlyAround`: two or three cobwebs in
+    /// free spaces with a solid floor, picked among 15 random blocks within one
+    /// block of `pos`.
+    fn spawn_cobwebs_around(&mut self, pos: [i32; 3]) {
+        let wanted = 2 + self.world.random.next_int_bound(2).unwrap_or(0) as usize;
+        let mut chosen: Vec<[i32; 3]> = Vec::new();
+        for _ in 0..15 {
+            let r = &mut self.world.random;
+            let at = [
+                pos[0] - 1 + r.next_int_bound(3).unwrap_or(0),
+                pos[1] - 1 + r.next_int_bound(3).unwrap_or(0),
+                pos[2] - 1 + r.next_int_bound(3).unwrap_or(0),
+            ];
+            let facts = self.res.facts();
+            let here = facts.get(self.world.block(at[0], at[1], at[2]));
+            let below = facts.get(self.world.block(at[0], at[1] - 1, at[2]));
+            if !chosen.contains(&at)
+                && here.replaceable
+                && below.sturdy_full & (1 << Direction::Up as u8) != 0
+            {
+                chosen.push(at);
+                if chosen.len() >= wanted {
+                    break;
+                }
+            }
+        }
+        for at in chosen {
+            if self.set_state_named(at, "minecraft:cobweb", &[]).is_ok() {
+                self.level_event_at(3018, at, 0);
+            }
+        }
+    }
+    /// `InfestedMobEffect.onMobHurt` for the player: from half its height up,
+    /// along where it looks.
+    pub(super) fn player_infested(&mut self) {
+        if let Some(p) = self.player.as_ref() {
+            let at = [
+                p.position.x,
+                p.position.y + f64::from(p.dimensions.height) / 2.0,
+                p.position.z,
+            ];
+            let look = super::view_vector(self.yaw, self.pitch);
+            self.infested_hurt(at, look);
+        }
+    }
+    /// `InfestedMobEffect.onMobHurt`: a 10% chance of one or two silverfish at
+    /// `at` (half the bearer's height up), thrown along its look direction.
+    pub(super) fn infested_hurt(&mut self, at: [f64; 3], look: [f64; 3]) {
+        if self.world.random.next_float() > 0.1 {
+            return;
+        }
+        let count = 1 + self.world.random.next_int_bound(2).unwrap_or(0);
+        for _ in 0..count {
+            // Mth.randomBetween(-PI / 2, PI / 2), then the look direction
+            // scaled by (0.3, 0.45, 0.3) and turned about the y axis.
+            let half = std::f32::consts::FRAC_PI_2;
+            let angle = self.world.random.next_float() * (2.0 * half) - half;
+            let (sin, cos) = angle.sin_cos();
+            let (x, z) = (look[0] * 0.3, look[2] * 0.3);
+            let velocity = Vec3::new(
+                f64::from(x as f32 * cos + z as f32 * sin),
+                look[1] * 0.3 * 1.5,
+                f64::from(-x as f32 * sin + z as f32 * cos),
+            );
+            if let Some(id) = self.spawn_mob_for("minecraft:silverfish", at, false, true)
+                && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
+            {
+                m.velocity = velocity;
+            }
+            self.audio
+                .play("minecraft:entity.silverfish.hurt", Some(at), 1.0, 1.0);
+        }
+    }
     /// A splash potion, lingering potion or experience bottle in flight (the
     /// player's throws and dispensers both end up here).
     pub(super) fn launch_thrown(&mut self, stack: ItemStack, position: Vec3, velocity: Vec3) {
@@ -376,8 +509,27 @@ impl Game<'_> {
             return;
         };
         if player.health.dead_or_dying() {
-            // LivingEntity.die → removeAllEffects.
+            // LivingEntity.die → removeAllEffects. Vanilla runs the effects
+            // that act on death (`onMobRemoved`) when the dead player is
+            // removed, up to 20 ticks later; here it is as the effects go.
+            let w = f64::from(player.dimensions.width) / 2.0;
+            let bounds = Aabb::new(
+                Vec3::new(
+                    player.position.x - w,
+                    player.position.y,
+                    player.position.z - w,
+                ),
+                Vec3::new(
+                    player.position.x + w,
+                    player.position.y + f64::from(player.dimensions.height),
+                    player.position.z + w,
+                ),
+            );
+            let ids: Vec<&'static str> = self.potions.effects.list.iter().map(|e| e.id).collect();
             self.potions.effects.clear();
+            if !ids.is_empty() {
+                self.effects_on_death(&ids, bounds, true, None);
+            }
         }
         // The omens act from inside the effect tick (BadOmenMobEffect,
         // RaidOmenMobEffect).
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..e4132e799 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -896,6 +896,10 @@ pub enum MobEvent {
         slot: usize,
         stack: Option<crate::items::ItemStack>,
     },
+    /// `InfestedMobEffect.onMobHurt`: the mob was hurt while infested.
+    Infested {
+        mob: u32,
+    },
     /// `OfferFlowerGoal.stop`: the item goes to the target's antenna (saddle)
     /// slot if it is empty, as a guaranteed drop.
     Gift {
@@ -1789,6 +1793,9 @@ impl Mob {
                 }
             }
         }
+        if self.has_effect("minecraft:infested") {
+            self.outbox.push(MobEvent::Infested { mob: self.id });
+        }
         true
     }
     /// LivingEntity.knockback(power, xd, zd) towards the negative direction.

From 7102727197458311255f1c8ccf9f903cdb611d50 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:24:26 +0100
Subject: [PATCH 112/475] Play the container close sound when a server-thread
 player closes it

---
 crates/horizon-client/src/game.rs             | 21 +------------------
 crates/horizon-client/src/game/lan_actions.rs |  5 ++++-
 crates/horizon-client/src/game/storage.rs     | 21 +++++++++++++++++++
 3 files changed, 26 insertions(+), 21 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 147aefe36..d0e060c13 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -5627,26 +5627,7 @@ impl Game<'_> {
                 Some(horizon_client::mobs::Who::Player),
                 None,
             );
-            let name = self
-                .res
-                .facts()
-                .get(self.world.block(key.0, key.1, key.2))
-                .name
-                .clone();
-            let sound = if storage::is_shulker_box(&name) {
-                Some("minecraft:block.shulker_box.close")
-            } else if &*name == "minecraft:ender_chest" {
-                Some("minecraft:block.ender_chest.close")
-            } else if name.contains("chest") {
-                Some("minecraft:block.chest.close")
-            } else if &*name == "minecraft:barrel" {
-                Some("minecraft:block.barrel.close")
-            } else {
-                None
-            };
-            if let Some(sound) = sound {
-                self.container_sound(sound, key, &name);
-            }
+            self.container_close_sound(key);
             self.world.modified.insert((key.0 >> 4, key.2 >> 4));
         }
         self.close_ender_chest();
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 0ad14bbcc..41ada973c 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -854,13 +854,16 @@ impl Game<'_> {
     }
 
     /// The guest's open container is closing (`AbstractContainerMenu.removed`):
-    /// it no longer counts among the openers of the lid.
+    /// it no longer counts among the openers of the lid, and the lid's close
+    /// sound is played for everyone around (`ChestBlockEntity.onClose`, a
+    /// `playSound` with no player), the guest included.
     pub(super) fn guest_container_closed(&mut self, host: &mut LanHost, conn: u32) {
         if let Some(g) = host.hub.guest(conn)
             && let Some(pos) = g.menu.as_ref().and_then(|m| m.pos)
             && !g.spectator()
         {
             self.container_openers_changed(pos, false);
+            self.container_close_sound(pos);
         }
     }
 
diff --git a/crates/horizon-client/src/game/storage.rs b/crates/horizon-client/src/game/storage.rs
index 3456c4ab0..d733f1cca 100644
--- a/crates/horizon-client/src/game/storage.rs
+++ b/crates/horizon-client/src/game/storage.rs
@@ -142,6 +142,27 @@ impl Game<'_> {
         let pitch = self.world.random.next_float() * 0.1 + 0.9;
         self.audio.play(sound, Some(at), 0.5, pitch);
     }
+    /// The close sound of the container block at `key`, if it has one.
+    pub(super) fn container_close_sound(&mut self, key: (i32, i32, i32)) {
+        let name = self
+            .res
+            .facts()
+            .get(self.world.block(key.0, key.1, key.2))
+            .name
+            .clone();
+        let sound = if is_shulker_box(&name) {
+            "minecraft:block.shulker_box.close"
+        } else if &*name == "minecraft:ender_chest" {
+            "minecraft:block.ender_chest.close"
+        } else if name.contains("chest") {
+            "minecraft:block.chest.close"
+        } else if &*name == "minecraft:barrel" {
+            "minecraft:block.barrel.close"
+        } else {
+            return;
+        };
+        self.container_sound(sound, key, &name);
+    }
     /// The other half of a double chest at `key`, for neighbour updates.
     pub(super) fn chest_other_half(&self, key: (i32, i32, i32)) -> Option<(i32, i32, i32)> {
         self.chest_partner(key).map(|p| p.0)

From 6bdf5fe3683dc20f1c0fe2e8ceb87bae17b58526 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 15:26:32 +0100
Subject: [PATCH 113/475] Sweep: hit mobs within 3 blocks in creative too

Player.doSweepAttack keeps nearby entities with distanceToSqr < 9.0; it
doesn't use the entity interaction range.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 4e795c3c5..72d087d1c 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -7467,7 +7467,8 @@ impl Game<'_> {
     }
     /// The damage and knockback part of `Player.doSweepAttack` after a sweep
     /// hit on the mob at `target`: every other living mob in its box grown by
-    /// (1, 0.25, 1) and within the player's reach, but the player's allies
+    /// (1, 0.25, 1) and closer than 3 blocks (`distanceToSqr < 9`, in creative
+    /// too), but the player's allies
     /// (`isAlliedTo`), takes `1 + sweeping_damage_ratio * baseDamage` with the
     /// weapon's enchantments, scaled by the attack strength, and is pushed 0.4
     /// along the player's yaw.
@@ -7495,7 +7496,6 @@ impl Game<'_> {
         let hit_box = self.mobs[target]
             .bounds()
             .inflate(horizon_core::geometry::Vec3::new(1.0, 0.25, 1.0));
-        let reach = if self.creative { 5.0 } else { 3.0 };
         let (uuid, allies) = (
             self.level.player_uuid.or(Some([0, 0, 0, 1])),
             self.player_allies(),
@@ -7511,7 +7511,7 @@ impl Game<'_> {
                     && !allies.contains(&m.id)
                     && !mace::ally_of_player(m, uuid)
                     && m.bounds().intersects(hit_box)
-                    && m.position.distance_squared(p.position) < reach * reach
+                    && m.position.distance_squared(p.position) < 9.0
             })
             .map(|(i, _)| i)
             .collect();

From 7fbfbb5e2b16640613c14601caaeb367676c1216 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 15:27:12 +0100
Subject: [PATCH 114/475] Shulker bullet split: draw the failure chance from
 the level's random

Shulker.hitByShulkerBullet tests level().getRandom().nextFloat() against
the crowding chance, not the shulker's own random.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/mobs/ai.rs      | 11 ++++++++---
 crates/horizon-client/src/mobs/shulker.rs | 21 ++++++++++++++++-----
 2 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 8335cb745..5fce47b37 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -746,7 +746,7 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &
     if m.kind.flags.burns_in_day && m.alive() && sun_burn_tick(m, w) && m.extra.head.is_none() {
         m.ignite_for_ticks(160);
     }
-    species_ai_step(m, w, events);
+    species_ai_step(m, w, level_random, events);
 }
 impl Mob {
     /// LivingEntity.isPushable (and the push it takes from `Entity.push(Entity)`):
@@ -955,7 +955,12 @@ fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) {
         _ => {}
     }
 }
-fn species_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
+fn species_ai_step(
+    m: &mut Mob,
+    w: &MobWorld,
+    level_random: &mut LegacyRandom,
+    events: &mut Vec<MobEvent>,
+) {
     if family(m.species()) == Family::Aquatic {
         aquatic::ai_step(m, w, events);
     }
@@ -988,7 +993,7 @@ fn species_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         }
         Species::Shulker => {
             super::shulker::tick(m, w, events);
-            super::shulker::ai_step(m, w, events);
+            super::shulker::ai_step(m, w, level_random, events);
         }
         Species::SnowGolem => super::golem::snow_ai_step(m, w, events),
         Species::CopperGolem => super::copper_golem::ai_step(m, w, events),
diff --git a/crates/horizon-client/src/mobs/shulker.rs b/crates/horizon-client/src/mobs/shulker.rs
index ccb33fd24..124d1b299 100644
--- a/crates/horizon-client/src/mobs/shulker.rs
+++ b/crates/horizon-client/src/mobs/shulker.rs
@@ -14,7 +14,7 @@ use crate::projectiles::{Projectile, ProjectileWorld, STEPS};
 use horizon_core::geometry::trig::Mth;
 use horizon_core::{
     geometry::{Aabb, Vec3},
-    random::RandomSource,
+    random::{LegacyRandom, RandomSource},
 };
 use std::f32::consts::PI;
 
@@ -173,20 +173,30 @@ pub fn hit_by_bullet(m: &mut Mob) {
     }
 }
 /// The deferred teleport of `after_hurt` and `hitByShulkerBullet`.
-pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
+pub fn ai_step(
+    m: &mut Mob,
+    w: &MobWorld,
+    level_random: &mut LegacyRandom,
+    events: &mut Vec<MobEvent>,
+) {
     if m.extra.flag {
         m.extra.flag = false;
         teleport(m, w, events);
     }
     if m.extra.flag2 {
         m.extra.flag2 = false;
-        hit_by_shulker_bullet(m, w, events);
+        hit_by_shulker_bullet(m, w, level_random, events);
     }
 }
 /// `Shulker.hitByShulkerBullet`: an open shulker teleports, and leaves a
 /// new one of its colour behind unless shulkers crowd the place (one in
 /// five fewer chances for every other shulker within 8 blocks).
-fn hit_by_shulker_bullet(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
+fn hit_by_shulker_bullet(
+    m: &mut Mob,
+    w: &MobWorld,
+    level_random: &mut LegacyRandom,
+    events: &mut Vec<MobEvent>,
+) {
     let old_position = m.position;
     let old_box = m.bounds();
     if m.extra.counter == 0 || !teleport(m, w, events) {
@@ -201,7 +211,8 @@ fn hit_by_shulker_bullet(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>)
         })
         .count();
     let failure_chance = others as f32 / 5.0;
-    if m.random.next_float() < failure_chance {
+    // The level's random, not the shulker's.
+    if level_random.next_float() < failure_chance {
         return;
     }
     let mut baby = Mob::new(0, m.kind.clone(), old_position, 0.0);

From 26626e8c2759f6cd7fef2535dd7ae915168af805 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 15:45:51 +0100
Subject: [PATCH 115/475] Give frogs vanilla's smooth swimming move control

---
 crates/horizon-client/src/mobs/ai.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 8335cb745..50f1f335b 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -183,6 +183,18 @@ pub fn register(m: &mut Mob) {
             if m.species() == Species::Rabbit {
                 super::rabbit::register(m);
             }
+            if m.species() == Species::Frog {
+                // `Frog()`: SmoothSwimmingMoveControl(85, 10, 0.02, 0.1, true).
+                // The speed attribute is 1.0, so the controller's scaling is
+                // what keeps a frog at a walking pace on land.
+                m.ai.mov.kind = super::control::MoveKind::SmoothSwimming {
+                    max_turn_x: 85.0,
+                    max_turn_y: 10.0,
+                    in_water: 0.02,
+                    outside: 0.1,
+                    gravity: true,
+                };
+            }
         }
         Family::Inert => {}
         Family::Witch => super::witch::register(m),

From 5eef2bea0c1ed8ea945ce84fff9d391f97d45329 Mon Sep 17 00:00:00 2001
From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com>
Date: Mon, 26 Oct 2026 14:45:59 +0000
Subject: [PATCH 116/475] Clean up evoker summons after fang integration check

Remove the test arena's surviving vexes so later checks receive no stray attacks.

Co-Authored-By: OpenCode GPT-6.1 Sol <noreply@openai.com>
---
 tools/lan_e2e.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index 816fe9b82..1b2a7219b 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -6977,6 +6977,8 @@ def check_fangs(host, guest, out):
     finally:
         host('command', command='tick unfreeze')
         host('command', command=f'kill @e[tag={tag}]')
+        # The evoker can summon vexes before fangs; killing it leaves those summons alive.
+        host('command', command=f'kill @e[type=minecraft:vex,x={x},y={y},z={z},distance=..32]')
         guest('command', command='effect clear @s')
         face_each_other(host, guest)
     return {'fangs': len(paths['host']), 'warmup': warmup, 'drawn': drawn, 'removed': True}

From 7d8b6f3b90d1dd7f44ea9e89b7929dc925cac6e0 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 15:47:37 +0100
Subject: [PATCH 117/475] Composter: keep addLayer's doc on composter_add_layer

The extracted composter_extract_produce took the doc comment of the
function below it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-world/src/level/interact.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-world/src/level/interact.rs b/crates/horizon-world/src/level/interact.rs
index a1f786184..6bed21440 100644
--- a/crates/horizon-world/src/level/interact.rs
+++ b/crates/horizon-world/src/level/interact.rs
@@ -423,8 +423,6 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
         InteractionResult::Success
     }
 
-    /// `ComposterBlock.addLayer` once its `compostable` provider gave
-    /// `layers`: the new state (the old one when no layer is added).
     /// `ComposterBlock.extractProduce`: the bone meal pops out, the composter
     /// empties and its sound plays.
     fn composter_extract_produce(&mut self, pos: BlockPos, state: BlockStateId) {
@@ -444,6 +442,8 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
         });
     }
 
+    /// `ComposterBlock.addLayer` once its `compostable` provider gave
+    /// `layers`: the new state (the old one when no layer is added).
     fn composter_add_layer(&mut self, pos: BlockPos, layers: i32) -> BlockStateId {
         let b = self.b;
         let state = self.state(pos);

From 1d51f9d873b7ec024f9ceba69b57c9e2b3178977 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 15:48:30 +0100
Subject: [PATCH 118/475] Soul Speed: draw the random chances in vanilla's
 order

Both random_chance terms come first in their all_of conditions, so the
level random is drawn before the block and movement checks: the boots'
4% on every location change, and the sound's 35% on every tick the
boots are worn.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/game/enchant_effects.rs               | 32 ++++++++++++-------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs
index 6550ba9d5..8ae54dba7 100644
--- a/crates/horizon-client/src/game/enchant_effects.rs
+++ b/crates/horizon-client/src/game/enchant_effects.rs
@@ -505,7 +505,10 @@ impl Game<'_> {
             let riding = self.riding.is_some();
             let wanted = !riding && !flying && (on_soul || (active && !on_ground));
             active = wanted;
-            wear = on_ground && on_soul && self.world.random.next_float() < 0.04;
+            // `random_chance` is the first term of the wear's `all_of`: it
+            // draws from the level random before the block is looked at.
+            let roll = self.world.random.next_float() < 0.04;
+            wear = roll && on_ground && on_soul;
         }
         fx.applied_level = if active { level } else { 0 };
         // `Entity.getKnownMovement` horizontal speed of at least 1.0E-5.
@@ -529,10 +532,13 @@ impl Game<'_> {
         if wear && !self.creative {
             self.wear_boots(1);
         }
+        if level == 0 {
+            return;
+        }
+        let r = &mut self.world.random;
         if tick_effects {
             // `spawn_particles`: in the bounding box, 0.1 above the feet, thrown
             // back against the movement (-0.2) and up (0.1).
-            let r = &mut self.world.random;
             let x = position.x + (r.next_double() - 0.5) * f64::from(width);
             let z = position.z + (r.next_double() - 0.5) * f64::from(width);
             self.particles.send_particles(
@@ -542,16 +548,18 @@ impl Game<'_> {
                 1.0,
                 0,
             );
-            // `play_sound`: 35% chance, volume 0.6, pitch 0.6 to 1.0.
-            if r.next_float() < 0.35 {
-                let pitch = r.next_float() * 0.4 + 0.6;
-                self.audio.play(
-                    "minecraft:particle.soul_escape",
-                    Some([position.x, position.y, position.z]),
-                    0.6,
-                    pitch,
-                );
-            }
+        }
+        // `play_sound`: its `random_chance` (35%) comes first in its `all_of`,
+        // so the level random is drawn every tick the boots are worn; volume
+        // 0.6, pitch 0.6 to 1.0.
+        if r.next_float() < 0.35 && tick_effects {
+            let pitch = r.next_float() * 0.4 + 0.6;
+            self.audio.play(
+                "minecraft:particle.soul_escape",
+                Some([position.x, position.y, position.z]),
+                0.6,
+                pitch,
+            );
         }
     }
     /// `ItemStack.hurtAndBreak` on the worn boots (`change_item_damage`):

From 75f7029d016b0ff1109f030d20c28471242ce5e1 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 15:48:37 +0100
Subject: [PATCH 119/475] Squid ink: draw the squirt's voice pitch even when
 silent

Mob.makeSound calls getVoicePitch before Entity.playSound checks
isSilent, so the squid's random advances either way.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/mobs/aquatic.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/mobs/aquatic.rs b/crates/horizon-client/src/mobs/aquatic.rs
index 9603d5e58..f09f7c3b3 100644
--- a/crates/horizon-client/src/mobs/aquatic.rs
+++ b/crates/horizon-client/src/mobs/aquatic.rs
@@ -37,8 +37,9 @@ pub fn spawn_ink(m: &mut Mob) {
     } else {
         "squid_ink"
     };
+    // makeSound draws the voice pitch even for a silent squid.
+    let pitch = m.voice_pitch();
     if !m.silent {
-        let pitch = m.voice_pitch();
         let at = [m.position.x, m.position.y, m.position.z];
         m.outbox.push(MobEvent::Sound(
             sound,

From 608a6d9bee44680bb640777663d2c3258e5590b4 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 15:50:47 +0100
Subject: [PATCH 120/475] Turtles: a fixed home from spawn or load, one
 breeding orb

Turtle.finalizeSpawn sets homePos to where it spawns, and loading falls
back to the block it stands on; the home no longer moves with a turtle
that had none, which let it lay eggs anywhere. TurtleBreedGoal.breed adds
one ExperienceOrb of 1 to 7 drawn from the mother's random.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/entity_nbt.rs     | 12 ++++++++----
 crates/horizon-client/src/game/creatures.rs | 10 +++++++---
 crates/horizon-client/src/mobs/spawning.rs  |  8 ++++++++
 crates/horizon-client/src/mobs/turtle.rs    |  4 ++--
 4 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index f7c843264..73bc580bc 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -856,10 +856,14 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     if m.species() == crate::mobs::Species::Turtle {
         // Turtle.readAdditionalSaveData: `home_pos` (else where it stands) and `has_egg`.
         m.extra.flag = flag(tag, "has_egg");
-        m.extra.home = match tag.get("home_pos") {
-            Some(Tag::IntArray(home)) if home.len() == 3 => Some([home[0], home[1], home[2]]),
-            _ => None,
-        };
+        m.extra.home = Some(match tag.get("home_pos") {
+            Some(Tag::IntArray(home)) if home.len() == 3 => [home[0], home[1], home[2]],
+            _ => [
+                m.position.x.floor() as i32,
+                m.position.y.floor() as i32,
+                m.position.z.floor() as i32,
+            ],
+        });
     }
     if m.species() == crate::mobs::Species::Wither {
         m.extra.counter = number(tag.get("Invul")).unwrap_or(0) as i32;
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 03911ffda..d9764288b 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1360,9 +1360,13 @@ impl Game<'_> {
         // TurtleBreedGoal.breed: the goal gave the mother her egg; only the
         // experience is left, and only with mob loot on.
         if p.species() == Species::Turtle {
-            if self.ui.rules.bool("mob_drops") {
-                let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
-                self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+            // One `new ExperienceOrb` of 1 to 7 from the mother's random (not
+            // split up as `ExperienceOrb.award` does).
+            if self.ui.rules.bool("mob_drops")
+                && let Some(m) = self.mobs.iter_mut().find(|m| m.id == parent)
+            {
+                let xp = 1 + m.random.next_int_bound(7).unwrap_or(0) as u32;
+                self.add_orb([p.position.x, p.position.y, p.position.z], xp);
             }
             return;
         }
diff --git a/crates/horizon-client/src/mobs/spawning.rs b/crates/horizon-client/src/mobs/spawning.rs
index 93e3fe119..d58fa35c3 100644
--- a/crates/horizon-client/src/mobs/spawning.rs
+++ b/crates/horizon-client/src/mobs/spawning.rs
@@ -148,6 +148,14 @@ pub fn finalize(m: &mut Mob, biome: &BiomeFacts, difficulty: &LocalDifficulty) {
         S::Pig | S::Cow | S::Chicken => m.extra.variant = climate_index,
         S::Sheep => m.extra.color = super::farm::sheep_color(biome.climate, &mut m.random),
         S::Mooshroom => m.extra.variant = 0,
+        // Turtle.finalizeSpawn: home is where it spawned.
+        S::Turtle => {
+            m.extra.home = Some([
+                m.position.x.floor() as i32,
+                m.position.y.floor() as i32,
+                m.position.z.floor() as i32,
+            ])
+        }
         S::Frog => m.extra.variant = biome.frog,
         S::Wolf => m.extra.variant = biome.wolf,
         S::Cat => m.extra.variant = super::tame::cat_variant(m, biome.full_moon),
diff --git a/crates/horizon-client/src/mobs/turtle.rs b/crates/horizon-client/src/mobs/turtle.rs
index 0596adfdf..98dd5b558 100644
--- a/crates/horizon-client/src/mobs/turtle.rs
+++ b/crates/horizon-client/src/mobs/turtle.rs
@@ -23,8 +23,8 @@ fn set_laying_egg(m: &mut Mob, on: bool) {
     m.extra.counter = i32::from(on);
     m.extra.flag2 = on;
 }
-/// `homePos.closerToCenterThan(position, distance)`; a turtle that never
-/// had a home is at home where it stands.
+/// `homePos.closerToCenterThan(position, distance)`. Spawning, hatching and
+/// loading all set a home; one made any other way is at home where it stands.
 fn close_to_home(m: &Mob, distance: f64) -> bool {
     let home = m.extra.home.unwrap_or([
         m.position.x.floor() as i32,

From 9e71837df99a26c8ec77922d2718e8daeb46b2bd Mon Sep 17 00:00:00 2001
From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com>
Date: Mon, 26 Oct 2026 14:56:15 +0000
Subject: [PATCH 121/475] Keep server logging from panicking on a closed stdout
 pipe

Co-Authored-By: OpenAI GPT-6.1 Sol <noreply@openai.com>
---
 crates/horizon-client/src/game/dedicated.rs | 112 +++++++++++++++++++-
 1 file changed, 111 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/dedicated.rs b/crates/horizon-client/src/game/dedicated.rs
index fa5365195..4a3b5b4ca 100644
--- a/crates/horizon-client/src/game/dedicated.rs
+++ b/crates/horizon-client/src/game/dedicated.rs
@@ -24,6 +24,7 @@ use horizon_client::{
 use horizon_protocol::text::translatable;
 use horizon_world::nbt::{JavaString, Tag};
 use std::{
+    io::Write,
     path::PathBuf,
     sync::{Arc, Mutex, OnceLock, mpsc},
     time::{Duration, Instant},
@@ -89,7 +90,9 @@ fn log_from(thread: &str, level: &str, message: &str) {
         }
     });
     // Log4j's %d{HH:mm:ss}: the local time, as in logs/latest.log.
-    println!(
+    // The launcher can close its stdout pipe while the server keeps running.
+    let _ = writeln!(
+        std::io::stdout().lock(),
         "[{}] [{thread}/{level}]: {message}",
         chrono::Local::now().format("%H:%M:%S")
     );
@@ -1308,3 +1311,110 @@ fn png_size(bytes: &[u8]) -> Option<(u32, u32)> {
     let h = u32::from_be_bytes(bytes[20..24].try_into().ok()?);
     Some((w, h))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{capture_log, log, log_from};
+    use std::{
+        fs,
+        io::{self, BufRead, BufReader, Read, Write},
+        process::{Command, Stdio},
+        time::{SystemTime, UNIX_EPOCH},
+    };
+
+    const LOGIN: &str = "Player[/127.0.0.1:0] logged in with entity id 2 at (0.5, 115.0, 0.5)";
+    const WARNING: &str = "Authentication warning";
+    const READY: &str = "horizon-console-log-ready\n";
+    const CHILD_HOME: &str = "HORIZON_TEST_CONSOLE_LOG_HOME";
+
+    fn assert_log_lines(text: &str) {
+        let expected = [
+            format!("] [Server thread/INFO]: {LOGIN}"),
+            format!("] [User Authenticator #1/WARN]: {WARNING}"),
+        ];
+        assert_eq!(text.lines().count(), expected.len());
+        for (line, suffix) in text.lines().zip(expected) {
+            assert!(line.starts_with('['));
+            assert!(chrono::NaiveTime::parse_from_str(&line[1..9], "%H:%M:%S").is_ok());
+            assert_eq!(&line[9..], suffix);
+        }
+    }
+
+    #[test]
+    fn console_logging_survives_closed_stdout() {
+        if let Some(home) = std::env::var_os(CHILD_HOME) {
+            horizon_client::logging::init(std::path::Path::new(&home), "Server thread");
+            // Let the parent close the real stdout pipe only after libtest's startup output.
+            io::stdout().write_all(READY.as_bytes()).unwrap();
+            io::stdout().flush().unwrap();
+            io::stdin().read_exact(&mut [0]).unwrap();
+            std::thread::Builder::new()
+                .name("Server thread".into())
+                .spawn(|| {
+                    let captured = capture_log(|| {
+                        log("INFO", LOGIN);
+                        log_from("User Authenticator #1", "WARN", WARNING);
+                    });
+                    assert_eq!(captured, [LOGIN, WARNING]);
+                    horizon_client::logging::flush();
+                })
+                .unwrap()
+                .join()
+                .unwrap();
+            // Libtest's final status also writes to stdout; only the game logger is under test.
+            std::process::exit(0);
+        }
+
+        for closed_stdout in [false, true] {
+            let unique = SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .unwrap()
+                .as_nanos();
+            let home = std::env::temp_dir().join(format!(
+                "horizon-console-log-test-{}-{unique}",
+                std::process::id()
+            ));
+            fs::create_dir(&home).unwrap();
+            let mut child = Command::new(std::env::current_exe().unwrap())
+                .args([
+                    "--exact",
+                    "game::dedicated::tests::console_logging_survives_closed_stdout",
+                    "--nocapture",
+                ])
+                .env(CHILD_HOME, &home)
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .spawn()
+                .unwrap();
+            let mut stdout = BufReader::new(child.stdout.take().unwrap());
+            loop {
+                let mut line = String::new();
+                assert!(
+                    stdout.read_line(&mut line).unwrap() > 0,
+                    "child was not ready"
+                );
+                if line.ends_with(READY) {
+                    break;
+                }
+            }
+            if closed_stdout {
+                drop(stdout); // No reader remains: the next console write gets EPIPE.
+            } else {
+                child.stdout = Some(stdout.into_inner());
+            }
+            child.stdin.take().unwrap().write_all(&[1]).unwrap();
+            let output = child.wait_with_output().unwrap();
+            assert!(
+                output.status.success(),
+                "closed_stdout={closed_stdout}: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+            if !closed_stdout {
+                assert_log_lines(std::str::from_utf8(&output.stdout).unwrap());
+            }
+            assert_log_lines(&fs::read_to_string(home.join("logs/latest.log")).unwrap());
+            fs::remove_dir_all(home).unwrap();
+        }
+    }
+}

From e71d4281acce0741804c2120bbcc6ed57dbe66d2 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:04:35 +0100
Subject: [PATCH 122/475] Spawn a baby when a spawn egg is used on its own mob
 kind

Mob.checkAndHandleImportantInteractions: a spawn egg of the clicked mob's
kind spawns a baby at the mob's position (SpawnEggItem.spawnOffspringFromSpawnEgg),
inheriting the parent's variant, and uses one egg outside creative.

Fixes #2269.
---
 crates/horizon-client/src/game/creatures.rs | 40 +++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 194256040..3ebf9ef49 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2447,6 +2447,10 @@ impl Game<'_> {
         if self.name_mob(index) {
             return Ok(true);
         }
+        if self.spawn_egg_offspring(index) {
+            self.swing_arm();
+            return Ok(true);
+        }
         {
             let item = self.held().map(|h| h.item.to_string()).unwrap_or_default();
             if self.interact_leash(index, &item) {
@@ -2953,6 +2957,42 @@ impl Game<'_> {
         }
         Ok(true)
     }
+    /// `Mob.checkAndHandleImportantInteractions` with a spawn egg of mob
+    /// `index`'s own kind (`SpawnEggItem.spawnOffspringFromSpawnEgg`): a baby
+    /// at the mob's feet, taking the parent's variant as `getBreedOffspring`
+    /// does, and one egg used. False (PASS) when the mob has no baby form.
+    fn spawn_egg_offspring(&mut self, index: usize) -> bool {
+        let Some(stack) = self.held().cloned() else {
+            return false;
+        };
+        let parent = &self.mobs[index];
+        if !parent.alive()
+            || stack.item.strip_suffix("_spawn_egg") != Some(parent.kind.id.as_str())
+            || !horizon_client::mobs::drops::can_be_baby(parent.species())
+        {
+            return false;
+        }
+        let (kind, at) = (
+            parent.kind.id.clone(),
+            [parent.position.x, parent.position.y, parent.position.z],
+        );
+        let (species, variant, color) =
+            (parent.species(), parent.extra.variant, parent.extra.color);
+        let target = self.mob_entity(&self.mobs[index]);
+        let Some(id) = self.spawn_mob(&kind, at, true) else {
+            return false;
+        };
+        if let Some(child) = self.mobs.iter_mut().find(|m| m.id == id) {
+            horizon_client::mobs::finalize::set_baby(child, true);
+            child.extra.variant = variant;
+            if species == Species::Sheep {
+                child.extra.color = color;
+            }
+        }
+        self.trigger_item_entity("minecraft:player_interacted_with_entity", &stack, &target);
+        self.consume_held();
+        true
+    }
     fn use_spawn_egg(&mut self, stack: &ItemStack) -> Result<bool> {
         let Some(hit) = self.pick() else {
             return Ok(false);

From af6faa88e51f6d7632191124b6e49f5a9ceaff8f Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:06:30 +0100
Subject: [PATCH 123/475] Report the hook's open-water flag to the
 fishing_rod_hooked trigger

---
 crates/horizon-client/src/game/fishing.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs
index 33d93fb82..a2c3dcf1d 100644
--- a/crates/horizon-client/src/game/fishing.rs
+++ b/crates/horizon-client/src/game/fishing.rs
@@ -241,6 +241,7 @@ impl Game<'_> {
                 kind: "minecraft:fishing_bobber".into(),
                 position: [hook.position.x, hook.position.y, hook.position.z],
                 on_ground: hook.on_ground,
+                fishing_open_water: Some(hook.open_water),
                 ..Default::default()
             };
             self.trigger_fishing_rod_hooked(rod, &bobber, &caught);

From c75854a9683fc63045dc8b16fbd0f6d345c6262b Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:07:11 +0100
Subject: [PATCH 124/475] Send mob door cracks to nearby players

---
 crates/horizon-client/src/game/creatures.rs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 4613ad5f7..8e11f3103 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1056,6 +1056,25 @@ impl Game<'_> {
                 }
                 MobEvent::DestroyProgress { mob, pos, progress } => {
                     self.destroy_block_progress(mob as i32, pos, progress);
+                    // ServerLevel.destroyBlockProgress: every player nearby sees it.
+                    if let Some(host) = self.lan.as_ref() {
+                        host.hub.broadcast_near(
+                            [f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])],
+                            64.0,
+                            &horizon_protocol::packets::play::Clientbound::BlockDestruction(
+                                horizon_protocol::packets::play::BlockDestruction {
+                                    id: mob as i32,
+                                    pos,
+                                    progress: if (0..10).contains(&progress) {
+                                        progress as u8
+                                    } else {
+                                        255
+                                    },
+                                },
+                            ),
+                            None,
+                        );
+                    }
                 }
                 MobEvent::LevelEvent { id, pos, data } => self.level_event_at(id, pos, data),
                 MobEvent::SetBlockName { pos, name, effect } => {

From af49fd7dc3b7248f47b7f2cf066df183abee353e Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:07:14 +0100
Subject: [PATCH 125/475] Use a collision-shape raycast for the spyglass
 line-of-sight check

---
 .../horizon-client/src/game/advancements.rs   | 20 +++++++------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs
index 67615b628..5908926a1 100644
--- a/crates/horizon-client/src/game/advancements.rs
+++ b/crates/horizon-client/src/game/advancements.rs
@@ -9,6 +9,7 @@ use horizon_client::{
     text::{self, Style, Text},
     toasts::Slide,
 };
+use horizon_core::geometry::Vec3;
 use serde_json::Value;
 use std::{
     collections::{BTreeMap, BTreeSet, VecDeque},
@@ -751,19 +752,12 @@ impl Game<'_> {
             .filter(|m| m.alive())
             .filter_map(|m| Some((m, super::ray_box(eye, dir, 100.0, m.bounds())?)))
             .min_by(|a, b| a.1.total_cmp(&b.1))?;
-        // Eye to the target's centre, two samples per block.
-        let to = m.center();
-        let reach = (0..3).map(|i| (to[i] - eye[i]).powi(2)).sum::<f64>().sqrt();
-        let steps = (reach * 2.0).ceil().max(1.0) as i32;
-        let clear = (1..steps).all(|i| {
-            let f = f64::from(i) / f64::from(steps);
-            let p = [0, 1, 2].map(|a| (eye[a] + (to[a] - eye[a]) * f).floor() as i32);
-            !self
-                .res
-                .facts()
-                .get(self.world.block(p[0], p[1], p[2]))
-                .full_collision
-        });
+        // `LivingEntity.hasLineOfSight`: eye to the target's eye height,
+        // `ClipContext.Block.COLLIDER`, no fluids, within 128 blocks.
+        let from = Vec3::new(eye[0], eye[1], eye[2]);
+        let to = Vec3::new(m.position.x, m.eye_y(), m.position.z);
+        let world = self.mob_world_base(&[]);
+        let clear = to.distance(from) <= 128.0 && world.clear_between(from, to, false);
         clear.then(|| self.mob_entity(m))
     }
     /// A player condition plus one item (`item` key).

From 92e59024f250df66bb7e0daf54beb33b38891b52 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:07:23 +0100
Subject: [PATCH 126/475] Give merged orbs their value once per count for LAN
 guests and dedicated players

---
 crates/horizon-client/src/game/lan_actions.rs | 8 +++++++-
 crates/horizon-client/src/game/remote.rs      | 5 ++++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index bbb0c37c0..72e364a46 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -2591,7 +2591,13 @@ impl Game<'_> {
             .random
             .next_int_bound(touching.len() as i32)
             .unwrap_or(0) as usize;
-        let orb = self.orbs.remove(touching[pick]);
+        // A merged orb gives its value once per count and goes at zero.
+        let orb = self.orbs[touching[pick]].clone();
+        if orb.count <= 1 {
+            self.orbs.remove(touching[pick]);
+        } else {
+            self.orbs[touching[pick]].count -= 1;
+        }
         play.xp_delay = 2;
         host.hub.take_item(orb.id as i32, id, 1, at);
         // ClientPacketListener.handleTakeItemEntity's sound, at the orb.
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3293b0690..40ab50c88 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -2018,7 +2018,10 @@ impl Game<'_> {
                 {
                     self.add_pickup(super::pickups::Taken::Orb(Box::new(orb)), collector);
                 }
-                self.remove_entity(p.item);
+                // An orb stays: the server may still hold merged ones in it.
+                if !orb {
+                    self.remove_entity(p.item);
+                }
             }
             // ClientPacketListener.handleSetEntityMotion: knockback on this player.
             C::SetEntityMotion(p) if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) => {

From e157c5a0a5043b74ccb36e7320d5b3a4bfcb12e8 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:07:31 +0100
Subject: [PATCH 127/475] Tick conduits on the server without a renderer

---
 .../horizon-client/src/block_entity_anim.rs   |  2 -
 .../src/game/block_entity_anims.rs            | 64 +++++++++++++++++--
 2 files changed, 57 insertions(+), 9 deletions(-)

diff --git a/crates/horizon-client/src/block_entity_anim.rs b/crates/horizon-client/src/block_entity_anim.rs
index 53884e5ec..fd91051fa 100644
--- a/crates/horizon-client/src/block_entity_anim.rs
+++ b/crates/horizon-client/src/block_entity_anim.rs
@@ -950,8 +950,6 @@ impl BlockEntityAnims {
         self.bells.retain(|p, _| is(p, |t| *t == Ticker::Bell));
         self.conduits
             .retain(|p, _| is(p, |t| *t == Ticker::Conduit));
-        self.conduit_servers
-            .retain(|p, _| is(p, |t| *t == Ticker::Conduit));
         self.skulls
             .retain(|p, _| is(p, |t| matches!(t, Ticker::Skull { .. })));
         self.pots.retain(|p, _| is(p, |t| *t == Ticker::Pot));
diff --git a/crates/horizon-client/src/game/block_entity_anims.rs b/crates/horizon-client/src/game/block_entity_anims.rs
index daec3523a..6f92d7f55 100644
--- a/crates/horizon-client/src/game/block_entity_anims.rs
+++ b/crates/horizon-client/src/game/block_entity_anims.rs
@@ -223,9 +223,12 @@ impl Game<'_> {
     /// The client tickers of the loaded animated block entities, once per
     /// client tick (`ClientLevel.tickBlockEntities`).
     pub(super) fn tick_block_entity_anims(&mut self) {
+        // A server has no window, but its gateways and conduits still run
+        // their server tickers; a client of one only animates what it is sent.
+        if self.remote.is_none() {
+            self.tick_conduit_servers();
+        }
         let Some(r) = &self.renderer else {
-            // A server has no window, but its gateways still run their
-            // server ticker.
             if self.remote.is_none() {
                 self.tick_gateway_servers();
             }
@@ -342,11 +345,6 @@ impl Game<'_> {
                     }
                 }
                 Ticker::Conduit => {
-                    // A server runs the effects and the attack; a client of
-                    // one only animates what it is sent.
-                    if self.remote.is_none() {
-                        self.tick_conduit_server(pos);
-                    }
                     let target = self.conduit_target(pos);
                     let world = &self.world;
                     let facts = self.res.facts();
@@ -394,11 +392,63 @@ impl Game<'_> {
         }
         self.be_anims.present = positions;
     }
+    /// `ConduitBlockEntity.serverTick` of every conduit in the chunks that
+    /// tick blocks, with or without a renderer. The conduits are looked for
+    /// when the shape is checked, every 40 ticks (they have no block entity
+    /// of their own here).
+    fn tick_conduit_servers(&mut self) {
+        if self.world.game_time % 40 == 0 {
+            self.find_conduits();
+        }
+        let mut positions: Vec<[i32; 3]> = self.be_anims.conduit_servers.keys().copied().collect();
+        positions.sort_unstable();
+        for pos in positions {
+            self.tick_conduit_server(pos);
+        }
+    }
+    /// Sets `be_anims.conduit_servers` to the conduits in the
+    /// chunks that tick blocks, keeping the state of those already known.
+    fn find_conduits(&mut self) {
+        let levels = self.tickets.levels();
+        let kinds = &self.be_anims.kinds;
+        let is_conduit = |id: u32| matches!(kinds.get(id as usize), Some(Some(Ticker::Conduit)));
+        let mut found = Vec::new();
+        for (&(cx, cz), chunk) in &self.world.chunks {
+            if !levels.block_ticking_at(cx * 16, cz * 16) {
+                continue;
+            }
+            for (si, section) in chunk.sections.iter().enumerate() {
+                if !section.blocks.maybe_has(is_conduit) {
+                    continue;
+                }
+                for i in 0..4096 {
+                    if is_conduit(section.get(i)) {
+                        found.push([
+                            cx * 16 + (i & 15) as i32,
+                            horizon_client::chunk::MIN_Y + si as i32 * 16 + (i >> 8) as i32,
+                            cz * 16 + ((i >> 4) & 15) as i32,
+                        ]);
+                    }
+                }
+            }
+        }
+        let mut old = std::mem::take(&mut self.be_anims.conduit_servers);
+        for pos in found {
+            let known = old.remove(&pos).unwrap_or_default();
+            self.be_anims.conduit_servers.insert(pos, known);
+        }
+    }
     /// `ConduitBlockEntity.serverTick` of the conduit at `pos`, in a chunk
     /// that ticks blocks: the shape check every 40 ticks with its sounds, the
     /// power for players in range, the hurt for an enemy, then the ambient
     /// sounds.
     fn tick_conduit_server(&mut self, pos: [i32; 3]) {
+        let state = self.world.block(pos[0], pos[1], pos[2]).0;
+        if self.be_anims.ticker(state) != Some(Ticker::Conduit) {
+            // Broken since the chunks were searched.
+            self.be_anims.conduit_servers.remove(&pos);
+            return;
+        }
         if !self.tickets.levels().block_ticking_at(pos[0], pos[2])
             || !self.border.contains(f64::from(pos[0]), f64::from(pos[2]))
         {

From 409a8281283d7776dbb25e8c2f42863cc083971e Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 16:11:29 +0100
Subject: [PATCH 128/475] mods: capability recipes (API level 4), the game's
 items and recipes for recipe viewers

recipes.items() lists every item in registry order, with its name in the
player's language and its tags. recipes.all() lists every recipe: crafting
and furnace ones from the recipe book's own entries (vanilla's displays and
display ids), then campfire, stonecutting, smithing and brewing (display
only). Stacks point into the item table by index. recipes.known() gives the
book ids the player's recipe book holds, from the client book in every mode,
so on a server it follows the server's book.

The game builds the tables once, the first time a running mod reads them.
Experimental, new functions only. Smithing::Transform now keeps its recipe
id.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game.rs             |   2 +
 crates/horizon-client/src/game/mod_recipes.rs | 252 ++++++++++++++++++
 crates/horizon-client/src/game/mods.rs        |  11 +
 crates/horizon-client/src/game/recipe_book.rs |  19 ++
 crates/horizon-client/src/stations.rs         |   3 +
 crates/horizon-mod-sdk/src/lib.rs             |   2 +-
 crates/horizon-mod-sdk/wit/horizon.wit        |  76 ++++++
 crates/horizon-mods/src/api_level.rs          |   7 +-
 crates/horizon-mods/src/manifest.rs           |  11 +-
 crates/horizon-mods/src/runtime.rs            |  54 ++++
 crates/horizon-mods/tests/sandbox.rs          |  90 ++++++-
 crates/horizon-mods/tests/ui_guest/src/lib.rs |  40 ++-
 docs/api/mods-reference.md                    |  72 ++++-
 docs/api/stability.md                         |   2 +-
 docs/mods.md                                  |   2 +-
 15 files changed, 630 insertions(+), 13 deletions(-)
 create mode 100644 crates/horizon-client/src/game/mod_recipes.rs

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 9bb6602fd..826ea73c1 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -100,6 +100,8 @@ mod minecarts;
 mod mob_blocks;
 mod mob_gear;
 mod mod_input;
+#[cfg(feature = "mods")]
+mod mod_recipes;
 mod mod_render;
 mod mods;
 mod mount_menu;
diff --git a/crates/horizon-client/src/game/mod_recipes.rs b/crates/horizon-client/src/game/mod_recipes.rs
new file mode 100644
index 000000000..0d57e1f94
--- /dev/null
+++ b/crates/horizon-client/src/game/mod_recipes.rs
@@ -0,0 +1,252 @@
+//! Capability `recipes` (docs/mods.md): every item and recipe the game
+//! knows, made once for the mods that read them, and the recipe book's
+//! known displays. The recipes are the window's own data: the world's in
+//! single player, vanilla's on a server (a client is sent no others), while
+//! the known displays follow the server's book as the recipe book does.
+use super::Game;
+use horizon_client::{
+    crafting::Ingredient,
+    items::ItemStack,
+    recipe_book::{Category, Display},
+    stations::Smithing,
+};
+use horizon_mods::{Recipe, RecipeItem, RecipeKind, RecipeStack, Recipes};
+use std::{collections::HashMap, sync::Arc};
+
+/// Item id -> its index in [`Recipes::items`].
+struct Index(HashMap<Arc<str>, u32>);
+impl Index {
+    fn stack(&self, item: &str, count: u32, components: String) -> Option<RecipeStack> {
+        Some(RecipeStack {
+            item: *self.0.get(item)?,
+            count,
+            components,
+        })
+    }
+    fn of(&self, s: &ItemStack) -> Option<RecipeStack> {
+        self.stack(&s.item, s.count, components(s))
+    }
+    fn any(&self, i: &Ingredient) -> Vec<RecipeStack> {
+        i.1.iter()
+            .filter_map(|id| self.stack(id, 1, String::new()))
+            .collect()
+    }
+}
+
+/// A stack's components beyond its item's, as vanilla's item syntax writes
+/// them (`[minecraft:potion_contents={potion:"minecraft:swiftness"}]`), or "".
+fn components(s: &ItemStack) -> String {
+    use horizon_world::nbt::Tag;
+    let Some(Tag::Compound(entries)) = horizon_client::item_data::encode_components(s) else {
+        return String::new();
+    };
+    let parts: Vec<String> = entries
+        .iter()
+        .map(|(k, v)| {
+            format!(
+                "{}={}",
+                k.to_string_lossy(),
+                horizon_client::snbt::to_snbt(v)
+            )
+        })
+        .collect();
+    format!("[{}]", parts.join(","))
+}
+
+fn recipe(id: String, kind: RecipeKind) -> Recipe {
+    Recipe {
+        id,
+        kind,
+        category: String::new(),
+        group: String::new(),
+        width: 0,
+        height: 0,
+        slots: Vec::new(),
+        results: Vec::new(),
+        cooking_time: 0,
+        experience: 0.0,
+        book_id: -1,
+    }
+}
+
+impl Game<'_> {
+    /// Capability `recipes`'s tables and known displays for this tick's
+    /// snapshot; nothing while no running mod reads them.
+    pub(super) fn mod_recipes(&mut self) -> (Option<Arc<Recipes>>, Arc<[i32]>) {
+        if !self.mods.mods.wants_recipes() {
+            return (None, Arc::from([]));
+        }
+        if self.mods.recipes.is_none() {
+            self.mods.recipes = Some(Arc::new(self.make_mod_recipes()));
+        }
+        let (version, known) = self.recipe_book_displays();
+        if self.mods.known_recipes.0 != Some(version) {
+            self.mods.known_recipes = (Some(version), known.into());
+        }
+        (self.mods.recipes.clone(), self.mods.known_recipes.1.clone())
+    }
+
+    fn make_mod_recipes(&mut self) -> Recipes {
+        let names = &self.pack.names;
+        let items = self.res.items();
+        let mut tags: HashMap<&str, Vec<String>> = HashMap::new();
+        for (tag, members) in &items.item_tags {
+            for m in members {
+                tags.entry(m).or_default().push(tag.clone());
+            }
+        }
+        let table: Vec<RecipeItem> = items
+            .registry_order
+            .iter()
+            .map(|id| RecipeItem {
+                id: id.to_string(),
+                name: names.display_item(id),
+                tags: tags.remove(&**id).map_or_else(Vec::new, |mut t| {
+                    t.sort();
+                    t
+                }),
+            })
+            .collect();
+        let index = Index(
+            items
+                .registry_order
+                .iter()
+                .enumerate()
+                .map(|(i, id)| (id.clone(), i as u32))
+                .collect(),
+        );
+        let mut out = Vec::new();
+        let cooking: HashMap<String, (u32, f32)> = self
+            .res
+            .recipes()
+            .cooking
+            .iter()
+            .map(|c| (format!("minecraft:{}", c.id), (c.time, c.experience)))
+            .collect();
+        for e in self.recipe_book_entries() {
+            let furnace = |c: Category| match c.name().split('_').next() {
+                Some("blast") => RecipeKind::Blasting,
+                Some("smoker") => RecipeKind::Smoking,
+                _ => RecipeKind::Smelting,
+            };
+            let kind = match &e.display {
+                Display::Shaped { .. } => RecipeKind::CraftingShaped,
+                Display::Shapeless(_) => RecipeKind::CraftingShapeless,
+                Display::Furnace(_) => furnace(e.category),
+            };
+            let mut r = recipe(e.id.clone(), kind);
+            r.category = e.category.name().to_owned();
+            r.group = e.group.clone().unwrap_or_default();
+            r.book_id = e.display_id;
+            r.slots = match &e.display {
+                Display::Shaped {
+                    width,
+                    height,
+                    cells,
+                } => {
+                    (r.width, r.height) = (*width as u32, *height as u32);
+                    cells
+                        .iter()
+                        .map(|c| c.as_ref().map_or_else(Vec::new, |i| index.any(i)))
+                        .collect()
+                }
+                Display::Shapeless(list) => list.iter().map(|i| index.any(i)).collect(),
+                Display::Furnace(i) => vec![index.any(i)],
+            };
+            // Requirements shown as other stacks (an arrow's potions): the
+            // requirement's index counts the filled slots only.
+            let filled: Vec<usize> = (0..r.slots.len())
+                .filter(
+                    |&k| !matches!(&e.display, Display::Shaped { cells, .. } if cells[k].is_none()),
+                )
+                .collect();
+            for (req, stacks) in &e.stacks {
+                if let Some(&k) = filled.get(*req) {
+                    r.slots[k] = stacks.iter().filter_map(|s| index.of(s)).collect();
+                }
+            }
+            r.results = e.results().iter().filter_map(|s| index.of(s)).collect();
+            if let Some(&(time, xp)) = cooking.get(&e.id) {
+                (r.cooking_time, r.experience) = (time, xp);
+            }
+            out.push(r);
+        }
+        for c in &self.res.recipes().cooking {
+            if c.kind == "minecraft:campfire_cooking" {
+                let mut r = recipe(format!("minecraft:{}", c.id), RecipeKind::Campfire);
+                r.group = c.group.clone();
+                r.slots = vec![index.any(&c.ingredient)];
+                r.results = index.of(&c.result).into_iter().collect();
+                (r.cooking_time, r.experience) = (c.time, c.experience);
+                out.push(r);
+            }
+        }
+        let stations = self.res.stations();
+        for s in &stations.recipes.stonecutting {
+            let mut r = recipe(s.id.clone(), RecipeKind::Stonecutting);
+            r.slots = vec![index.any(&s.input)];
+            r.results = index.of(&s.result).into_iter().collect();
+            out.push(r);
+        }
+        for s in &stations.recipes.smithing {
+            let (id, template, base, addition, results) = match s {
+                Smithing::Transform {
+                    id,
+                    template,
+                    base,
+                    addition,
+                    result,
+                } => (
+                    id,
+                    template,
+                    base,
+                    addition,
+                    index.stack(result, 1, String::new()).into_iter().collect(),
+                ),
+                Smithing::Trim {
+                    id,
+                    template,
+                    base,
+                    addition,
+                    ..
+                } => (id, template, base, addition, index.any(base)),
+            };
+            let mut r = recipe(id.clone(), RecipeKind::Smithing);
+            r.slots = vec![index.any(template), index.any(base), index.any(addition)];
+            r.results = results;
+            out.push(r);
+        }
+        for b in &stations.brewing.recipes {
+            let potion = |p: &horizon_client::brewing::PotionIngredient| -> Vec<RecipeStack> {
+                let mut item_ids: Vec<&String> = p.items.iter().collect();
+                item_ids.sort();
+                let mut potions: Vec<&String> = p.potions.iter().flatten().collect();
+                potions.sort();
+                item_ids
+                    .into_iter()
+                    .flat_map(|item| {
+                        let one = |c: String| index.stack(item, 1, c);
+                        if potions.is_empty() {
+                            one(String::new()).into_iter().collect::<Vec<_>>()
+                        } else {
+                            potions
+                                .iter()
+                                .filter_map(|p| {
+                                    one(format!("[minecraft:potion_contents={{potion:\"{p}\"}}]"))
+                                })
+                                .collect()
+                        }
+                    })
+                    .collect()
+            };
+            let mut r = recipe(b.id.clone(), RecipeKind::Brewing);
+            r.slots = vec![potion(&b.input), potion(&b.reagent)];
+            r.results = index.of(&b.output).into_iter().collect();
+            out.push(r);
+        }
+        Recipes {
+            items: table,
+            recipes: out,
+        }
+    }
+}
diff --git a/crates/horizon-client/src/game/mods.rs b/crates/horizon-client/src/game/mods.rs
index 12deb61fc..156467e7a 100644
--- a/crates/horizon-client/src/game/mods.rs
+++ b/crates/horizon-client/src/game/mods.rs
@@ -70,6 +70,12 @@ pub(super) struct ModsState {
     /// The HUD font's advances for `render.text-width`, made once.
     #[cfg(feature = "mods")]
     font_widths: std::sync::Arc<[f32]>,
+    /// Capability `recipes`'s tables, made once a mod reads them.
+    #[cfg(feature = "mods")]
+    pub(super) recipes: Option<std::sync::Arc<horizon_mods::Recipes>>,
+    /// The recipe book's known displays, and the book's version they are of.
+    #[cfg(feature = "mods")]
+    pub(super) known_recipes: (Option<u64>, std::sync::Arc<[i32]>),
     /// Extras that are official mods now, being installed.
     #[cfg(feature = "mods")]
     pub(super) moved: super::moved_extras::MovedState,
@@ -282,6 +288,8 @@ impl Game<'_> {
         self.mods.mods.set_bindings(|id| chosen.keys_of(id));
         // Entries were replaced wholesale: a screen's owner index is stale.
         self.mods.screen = None;
+        // Content mods may have changed the items: remade on the next read.
+        self.mods.recipes = None;
         self.list_mods();
         self.sync_mod_commands();
         self.show_mod_output();
@@ -409,6 +417,7 @@ impl Game<'_> {
                 .map(|c| char::from_u32(c).map_or(6.0, |c| atlas.glyph_cell(c).1))
                 .collect();
         }
+        let (recipes, known_recipes) = self.mod_recipes();
         Snapshot {
             player,
             clock,
@@ -420,6 +429,8 @@ impl Game<'_> {
             font_widths: self.mods.font_widths.clone(),
             players: Vec::new(),
             view_hit: self.mod_view_hit(),
+            recipes,
+            known_recipes,
         }
     }
     /// The first block along the player's view within
diff --git a/crates/horizon-client/src/game/recipe_book.rs b/crates/horizon-client/src/game/recipe_book.rs
index 96e12d79b..045abeb6f 100644
--- a/crates/horizon-client/src/game/recipe_book.rs
+++ b/crates/horizon-client/src/game/recipe_book.rs
@@ -338,6 +338,25 @@ impl Game<'_> {
         ui.client_known = Some(known.clone());
         ui.client_version += 1;
     }
+    /// Every entry of the book, in its order (capability `recipes`).
+    #[cfg(feature = "mods")]
+    pub(super) fn recipe_book_entries(&mut self) -> Vec<Entry> {
+        self.ensure_book();
+        self.recipe_ui
+            .book
+            .as_ref()
+            .map_or_else(Vec::new, |b| b.entries.clone())
+    }
+    /// The display ids the player's book holds, and a number that changes
+    /// whenever they do (capability `recipes`).
+    #[cfg(feature = "mods")]
+    pub(super) fn recipe_book_displays(&mut self) -> (u64, Vec<i32>) {
+        self.sync_client_book();
+        (
+            self.recipe_ui.client_version,
+            self.recipe_ui.client.displays(),
+        )
+    }
     fn ensure_book(&mut self) {
         if self.recipe_ui.book.is_none() {
             let mut book = Book::build(self.res.recipes(), self.res.items());
diff --git a/crates/horizon-client/src/stations.rs b/crates/horizon-client/src/stations.rs
index 715c2663e..bd157843a 100644
--- a/crates/horizon-client/src/stations.rs
+++ b/crates/horizon-client/src/stations.rs
@@ -445,6 +445,7 @@ pub fn grindstone_experience(
 #[derive(Clone, Debug)]
 pub enum Smithing {
     Transform {
+        id: String,
         template: Ingredient,
         base: Ingredient,
         addition: Ingredient,
@@ -524,6 +525,7 @@ impl StationRecipes {
             );
             match v["type"].as_str().unwrap_or("") {
                 "minecraft:smithing_transform" => smithing.push(Smithing::Transform {
+                    id,
                     template: ingredient(&v["template"], items),
                     base: ingredient(&v["base"], items),
                     addition: ingredient(&v["addition"], items),
@@ -627,6 +629,7 @@ impl StationRecipes {
                     base: b,
                     addition: a,
                     result,
+                    ..
                 } => {
                     if t.test(template) && b.test(base) && a.test(addition) {
                         // SmithingTransformRecipe: transmute the base keeping its components.
diff --git a/crates/horizon-mod-sdk/src/lib.rs b/crates/horizon-mod-sdk/src/lib.rs
index 679fdc7b8..b00d06ecf 100644
--- a/crates/horizon-mod-sdk/src/lib.rs
+++ b/crates/horizon-mod-sdk/src/lib.rs
@@ -39,7 +39,7 @@ wit_bindgen::generate!({
 
 pub use exports::horizon::mods::events::{Guest as __Guest, Registration};
 pub use exports::horizon::mods::ui_events::Guest as __UiEventsGuest;
-pub use horizon::mods::{chat, command, game, hud, input, log, render, storage, ui};
+pub use horizon::mods::{chat, command, game, hud, input, log, recipes, render, storage, ui};
 
 /// The game's calls into a mod. Only the hooks [`Registration`] asks for
 /// are called; the others may stay as their defaults.
diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit
index d9bb9f5c2..7d7adaa0d 100644
--- a/crates/horizon-mod-sdk/wit/horizon.wit
+++ b/crates/horizon-mod-sdk/wit/horizon.wit
@@ -439,6 +439,76 @@ interface events {
     chat: func(text: string);
 }
 
+/// Capability `recipes` (experimental): the recipes and items the game
+/// knows, for recipe viewers. In single player and on Horizon's servers
+/// they are the world's; on any other server they are vanilla 26.3's (a
+/// client is sent no others), while `known` follows that server's book.
+interface recipes {
+    /// An item of `items`, by its index there, with a count and the
+    /// components it has beyond the item's own, in vanilla's item syntax
+    /// (`[potion_contents={potion:"minecraft:swiftness"}]`), or "".
+    record stack {
+        item: u32,
+        count: u32,
+        components: string,
+    }
+    /// The station a recipe is made at.
+    enum kind {
+        crafting-shaped,
+        crafting-shapeless,
+        smelting,
+        blasting,
+        smoking,
+        campfire,
+        stonecutting,
+        smithing,
+        brewing,
+    }
+    record recipe {
+        /// `minecraft:oak_planks`.
+        id: string,
+        kind: kind,
+        /// The recipe book's tab (`crafting_building_blocks`,
+        /// `furnace_food`), or "".
+        category: string,
+        /// Recipes the book shows on one button share a group, or "".
+        group: string,
+        /// A shaped recipe's grid: `slots` holds its cells row by row.
+        /// 0 for the other kinds.
+        width: u32,
+        height: u32,
+        /// Each slot's stacks, any one of which fits; an empty list is an
+        /// empty cell. Cooking and stonecutting: the input. Smithing: the
+        /// template, the base, the addition. Brewing: the bottle, the
+        /// reagent.
+        slots: list<list<stack>>,
+        /// What it makes; several when that varies (a trim on any armour).
+        results: list<stack>,
+        /// Cooking: game ticks and experience; 0 for the other kinds.
+        cooking-time: u32,
+        experience: f32,
+        /// The recipe book's id for it (one per way the book shows it), as
+        /// `known` lists them; -1 for the kinds the book doesn't show
+        /// (campfire, stonecutting, smithing, brewing).
+        book-id: s32,
+    }
+    record item {
+        /// `minecraft:diamond`, `<mod>:<path>`.
+        id: string,
+        /// In the player's language.
+        name: string,
+        /// Its item tags, without the `#`.
+        tags: list<string>,
+    }
+    /// Every item, in the registry's order: `stack.item` indexes this list.
+    items: func() -> list<item>;
+    /// Every recipe: the book's in its order, then campfire, stonecutting,
+    /// smithing and brewing. They don't change while a world is open.
+    all: func() -> list<recipe>;
+    /// The `book-id`s of the recipes the player's recipe book holds now.
+    known: func() -> list<s32>;
+}
+
 /// Capability `players`, server mods only (manifest `api = "0.3"`,
 /// experimental): the players on the server, and messages to them.
 interface players {
@@ -545,6 +615,7 @@ world horizon-ui-mod {
     import ui;
     import render;
     import input;
+    import recipes;
     export ui-events;
 }
 
@@ -559,3 +630,8 @@ world render-host {
     import render;
     import input;
 }
+
+/// The game's side of capability `recipes` (imports only).
+world recipes-host {
+    import recipes;
+}
diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs
index bf87d0cfa..ff06a94ae 100644
--- a/crates/horizon-mods/src/api_level.rs
+++ b/crates/horizon-mods/src/api_level.rs
@@ -7,13 +7,13 @@
 //! version's level so the launcher can tell before it installs.
 
 /// The newest level this Horizon serves.
-pub const LEVEL: u32 = 3;
+pub const LEVEL: u32 = 4;
 
 /// Every function the game offers mods, as `interface.function`, with its
 /// level. Level 0 is the contract of Horizon 0.2.67 to 0.2.69. A new
 /// function takes the next level and raises [`LEVEL`] (the `api_reference`
 /// test fails until it is listed here).
-pub const FUNCTIONS: [(&str, u32); 34] = [
+pub const FUNCTIONS: [(&str, u32); 37] = [
     ("log.write", 0),
     ("game.get-player", 0),
     ("game.get-clock", 0),
@@ -48,6 +48,9 @@ pub const FUNCTIONS: [(&str, u32); 34] = [
     ("players.broadcast", 1),
     ("game.raycast", 2),
     ("command.run-quiet", 3),
+    ("recipes.items", 4),
+    ("recipes.all", 4),
+    ("recipes.known", 4),
 ];
 
 /// What the game's program carries so the launcher can read its level
diff --git a/crates/horizon-mods/src/manifest.rs b/crates/horizon-mods/src/manifest.rs
index 5ad7823aa..05cf96447 100644
--- a/crates/horizon-mods/src/manifest.rs
+++ b/crates/horizon-mods/src/manifest.rs
@@ -97,9 +97,12 @@ pub enum Capability {
     Input,
     /// The players on the server and messages to them (server mods).
     Players,
+    /// The recipes and items the game knows, for recipe viewers
+    /// (interface `recipes`).
+    Recipes,
 }
 impl Capability {
-    pub const ALL: [Capability; 10] = [
+    pub const ALL: [Capability; 11] = [
         Capability::GameRead,
         Capability::Chat,
         Capability::Hud,
@@ -110,6 +113,7 @@ impl Capability {
         Capability::Render,
         Capability::Input,
         Capability::Players,
+        Capability::Recipes,
     ];
     /// Whether a server mod may have it: the others act on a local player.
     pub fn on_server(self) -> bool {
@@ -128,6 +132,7 @@ impl Capability {
             Capability::Render => "render",
             Capability::Input => "input",
             Capability::Players => "players",
+            Capability::Recipes => "recipes",
         }
     }
     /// May change in any release: a mod uses it only with
@@ -135,7 +140,7 @@ impl Capability {
     pub fn is_experimental(self) -> bool {
         matches!(
             self,
-            Capability::Ui | Capability::Render | Capability::Input
+            Capability::Ui | Capability::Render | Capability::Input | Capability::Recipes
         )
     }
     /// What the player reads before turning the mod on: "May <this>".
@@ -153,6 +158,7 @@ impl Capability {
                 "see the keys you hold and your clicks, take over the use button on its own items and the mouse wheel, and add keys"
             }
             Capability::Players => "see who is on the server and message them",
+            Capability::Recipes => "read the game's recipes and items, and which recipes you know",
         }
     }
     /// The capability a component import needs, `Ok(None)` for one every
@@ -188,6 +194,7 @@ impl fmt::Display for Capability {
             Capability::Render => "render",
             Capability::Input => "input",
             Capability::Players => "players",
+            Capability::Recipes => "recipes",
         };
         f.write_str(name)
     }
diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs
index ce48f2317..ebce03944 100644
--- a/crates/horizon-mods/src/runtime.rs
+++ b/crates/horizon-mods/src/runtime.rs
@@ -78,6 +78,18 @@ pub use render_bindings::horizon::mods::render::{
     Zoom as ModZoom,
 };
 use render_bindings::{RenderHost, horizon::mods::render};
+/// Capability `recipes`'s imports (docs/mods.md): the game's recipes and items.
+mod recipes_bindings {
+    wasmtime::component::bindgen!({
+        path: "../horizon-mod-sdk/wit",
+        world: "recipes-host",
+    });
+}
+/// What capability `recipes` reads (WIT `interface recipes`).
+pub use recipes_bindings::horizon::mods::recipes::{
+    Item as RecipeItem, Kind as RecipeKind, Recipe, Stack as RecipeStack,
+};
+use recipes_bindings::{RecipesHost, horizon::mods::recipes};
 
 /// A mod's linear memory cap.
 const MEMORY: usize = 64 << 20;
@@ -133,6 +145,19 @@ pub struct Snapshot {
     /// its distance from the eye, for `game.raycast`; the game works it out
     /// only while a mod calls it ([`Mods::wants_raycast`]).
     pub view_hit: Option<(f32, Hit)>,
+    /// Every item and recipe, for capability `recipes`; the game makes them
+    /// once, and only while a mod reads them ([`Mods::wants_recipes`]).
+    pub recipes: Option<Arc<Recipes>>,
+    /// The `book-id`s of the recipes the player's book holds.
+    pub known_recipes: Arc<[i32]>,
+}
+
+/// Capability `recipes`'s tables: `items` in the registry's order, which
+/// each [`RecipeStack::item`] indexes.
+#[derive(Clone, Debug, Default)]
+pub struct Recipes {
+    pub items: Vec<RecipeItem>,
+    pub recipes: Vec<Recipe>,
 }
 
 /// Which mods a game starts: the window's game the client mods, the game
@@ -241,6 +266,8 @@ struct Running {
     hooks: Hooks,
     /// It imports `game.raycast`.
     raycasts: bool,
+    /// It imports capability `recipes`.
+    reads_recipes: bool,
 }
 
 /// A running mod's exports and the hooks its `init` asked for.
@@ -392,6 +419,8 @@ impl Mods {
                 .map_err(|e| e.to_string())?;
             RenderHost::add_to_linker::<State, HasSelf<State>>(&mut linker, |s| s)
                 .map_err(|e| e.to_string())?;
+            RecipesHost::add_to_linker::<State, HasSelf<State>>(&mut linker, |s| s)
+                .map_err(|e| e.to_string())?;
             self.engine = Some((engine, linker));
         }
         Ok(self.engine.as_ref().expect("made above"))
@@ -509,6 +538,7 @@ impl Mods {
             ui,
             hooks,
             raycasts: functions.iter().any(|f| f == "game.raycast"),
+            reads_recipes: functions.iter().any(|f| f.starts_with("recipes.")),
         }))
     }
 
@@ -769,6 +799,13 @@ impl Mods {
             .iter()
             .any(|e| e.run.as_ref().is_some_and(|r| r.raycasts))
     }
+    /// Some running mod reads capability `recipes`: the snapshot needs
+    /// [`Snapshot::recipes`] and [`Snapshot::known_recipes`].
+    pub fn wants_recipes(&self) -> bool {
+        self.entries
+            .iter()
+            .any(|e| e.run.as_ref().is_some_and(|r| r.reads_recipes))
+    }
     /// Some running mod has a `frame` hook: the game refreshes the snapshot
     /// every frame for it.
     pub fn wants_frames(&self) -> bool {
@@ -1125,6 +1162,23 @@ impl game::Host for State {
         (*at <= distance.min(RAYCAST_MAX) && !distance.is_nan()).then(|| hit.clone())
     }
 }
+impl recipes::Host for State {
+    fn items(&mut self) -> Vec<RecipeItem> {
+        self.snapshot
+            .recipes
+            .as_ref()
+            .map_or_else(Vec::new, |r| r.items.clone())
+    }
+    fn all(&mut self) -> Vec<Recipe> {
+        self.snapshot
+            .recipes
+            .as_ref()
+            .map_or_else(Vec::new, |r| r.recipes.clone())
+    }
+    fn known(&mut self) -> Vec<i32> {
+        self.snapshot.known_recipes.to_vec()
+    }
+}
 impl State {
     /// Queues a chat line unless the call already sent [`CHAT_PER_CALL`].
     fn say(&mut self, line: impl FnOnce(String) -> Output) -> bool {
diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs
index c6b835f10..06a8e6aa2 100644
--- a/crates/horizon-mods/tests/sandbox.rs
+++ b/crates/horizon-mods/tests/sandbox.rs
@@ -26,8 +26,8 @@ id = "test_ui_guest"
 name = "Test UI Guest"
 version = "0.1.0"
 api = "0.1"
-capabilities = ["game-read", "chat", "command", "ui", "render", "input"]
-experimental = ["ui", "render", "input"]
+capabilities = ["game-read", "chat", "command", "ui", "render", "input", "recipes"]
+experimental = ["ui", "render", "input", "recipes"]
 "#;
 
 /// Builds the mods once and writes their `.hmod` files; returns the folder.
@@ -238,8 +238,8 @@ id = "too_new"
 name = "Too New"
 version = "0.1.0"
 api = "0.1"
-capabilities = ["game-read", "chat", "hud", "storage", "command", "ui", "render", "input"]
-experimental = ["ui", "render", "input"]
+capabilities = ["game-read", "chat", "hud", "storage", "command", "ui", "render", "input", "recipes"]
+experimental = ["ui", "render", "input", "recipes"]
 "#;
     std::fs::write(dir.join("horizon-mod.toml"), manifest).unwrap();
     std::fs::write(dir.join("mod.wasm"), wasm).unwrap();
@@ -1016,3 +1016,85 @@ fn a_server_mod_runs_only_where_the_world_does() {
         "a server command isn't the window's"
     );
 }
+
+/// Capability `recipes`: the guest reads tables as big as vanilla's (1,500
+/// items, 1,600 recipes of nine five-item slots) within one command's fuel.
+#[test]
+fn recipes_reads_the_tables() {
+    use horizon_mods::{Recipe, RecipeItem, RecipeKind, RecipeStack, Recipes};
+    let mut mods = load("horizon_mods_test_ui_guest.hmod");
+    let stack = |item| RecipeStack {
+        item,
+        count: 1,
+        components: String::new(),
+    };
+    let items = (0..1500)
+        .map(|i| RecipeItem {
+            id: format!("minecraft:item_{i}"),
+            name: format!("Item {i}"),
+            tags: vec!["planks".into(), "logs".into()],
+        })
+        .collect();
+    let mut recipes: Vec<Recipe> = (0..1600)
+        .map(|i| Recipe {
+            id: format!("minecraft:recipe_{i}"),
+            kind: RecipeKind::CraftingShaped,
+            category: "crafting_misc".into(),
+            group: String::new(),
+            width: 3,
+            height: 3,
+            slots: (0..9)
+                .map(|k| (0..5).map(|j| stack((i + k + j) % 1500)).collect())
+                .collect(),
+            results: vec![RecipeStack {
+                item: 7,
+                count: 4,
+                components: String::new(),
+            }],
+            cooking_time: 0,
+            experience: 0.0,
+            book_id: i as i32,
+        })
+        .collect();
+    recipes[1].kind = RecipeKind::Brewing;
+    recipes[1].results[0].components =
+        "[minecraft:potion_contents={potion:\"minecraft:swiftness\"}]".into();
+    mods.set_snapshot(Snapshot {
+        recipes: Some(std::sync::Arc::new(Recipes { items, recipes })),
+        known_recipes: vec![1, 5, 9].into(),
+        ..Snapshot::default()
+    });
+    let said = |mods: &mut Mods, command: &str| {
+        assert!(mods.command(command));
+        mods.drain()
+            .into_iter()
+            .filter_map(|o| match o {
+                Output::Chat { text, .. } => Some(text),
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+    };
+    assert_eq!(
+        said(&mut mods, "recipes"),
+        ["1500 items, 1600 recipes, 3 known, 1 brewing"]
+    );
+    assert_eq!(
+        said(&mut mods, "recipes minecraft:recipe_1"),
+        [
+            "minecraft:recipe_1 Kind::Brewing 3x3 0t slots 9, the first 1 minecraft:item_1 -> \
+          4 minecraft:item_7[minecraft:potion_contents={potion:\"minecraft:swiftness\"}] known true"
+        ]
+    );
+    assert!(
+        mods.entries()
+            .iter()
+            .all(|e| e.status == horizon_mods::Status::Running),
+        "it ran out of fuel"
+    );
+    // Without the game's tables (no mod read them yet): empty, not a trap.
+    mods.set_snapshot(Snapshot::default());
+    assert_eq!(
+        said(&mut mods, "recipes"),
+        ["0 items, 0 recipes, 0 known, 0 brewing"]
+    );
+}
diff --git a/crates/horizon-mods/tests/ui_guest/src/lib.rs b/crates/horizon-mods/tests/ui_guest/src/lib.rs
index 74fb64350..2fd835d3c 100644
--- a/crates/horizon-mods/tests/ui_guest/src/lib.rs
+++ b/crates/horizon-mods/tests/ui_guest/src/lib.rs
@@ -6,10 +6,12 @@
 //! `input`; `/zoom FACTOR SMOOTH TURN` tests `render.set-zoom`;
 //! `/corner` and `/readings` the calls the official extras mods use;
 //! `/raycast DISTANCE` says what `game.raycast` sees; `/quiet A;B` runs
-//! lines with `command.run-quiet` (`/quiet_many N`: N of them).
+//! lines with `command.run-quiet` (`/quiet_many N`: N of them). `/recipes`
+//! counts what `recipes` reads; `/recipes ID` describes that recipe.
 use horizon_mod_sdk::{
     Mod, Registration, chat, command, game,
     input::{self, Event},
+    recipes,
     render::{self, FillShape, ItemShape, Point, QuadShape, Rect, Shape, SpriteShape, TextShape},
     ui::{self, ItemWidget, ListWidget, Screen, TextWidget, Widget},
 };
@@ -102,6 +104,7 @@ impl Mod for Guest {
             "raycast",
             "quiet",
             "quiet_many",
+            "recipes",
             "corner",
             "readings",
         ]
@@ -241,6 +244,41 @@ impl Mod for Guest {
                     None => "no hit".into(),
                 });
             }
+            "recipes" => {
+                let items = recipes::items();
+                let all = recipes::all();
+                let known = recipes::known();
+                let name = |s: &recipes::Stack| {
+                    let id = items.get(s.item as usize).map_or("?", |i| i.id.as_str());
+                    format!("{} {id}{}", s.count, s.components)
+                };
+                chat::show(&match all.iter().find(|r| r.id == args) {
+                    Some(r) => format!(
+                        "{} {:?} {}x{} {}t slots {}, the first {} -> {} known {}",
+                        r.id,
+                        r.kind,
+                        r.width,
+                        r.height,
+                        r.cooking_time,
+                        r.slots.len(),
+                        r.slots
+                            .first()
+                            .and_then(|s| s.first())
+                            .map_or("-".into(), name),
+                        r.results.first().map_or("-".into(), name),
+                        known.contains(&r.book_id)
+                    ),
+                    None => format!(
+                        "{} items, {} recipes, {} known, {} brewing",
+                        items.len(),
+                        all.len(),
+                        known.len(),
+                        all.iter()
+                            .filter(|r| r.kind == recipes::Kind::Brewing)
+                            .count()
+                    ),
+                });
+            }
             // Clamped to (1, 10); the two after it shake nothing.
             "render_shake" => {
                 render::shake(2.0, 99.0);
diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md
index c44f27576..1ee54e70f 100644
--- a/docs/api/mods-reference.md
+++ b/docs/api/mods-reference.md
@@ -17,6 +17,7 @@ The contract between Horizon and its mods: the WIT package `horizon:mods@0.1.0`,
 | `render` | [`render`](#render) | draw on your screen, shake and zoom the camera |
 | `input` | [`input`](#input) | see the keys you hold and your clicks, take over the use button on its own items and the mouse wheel, and add keys |
 | `players` | [`players`](#players) | see who is on the server and message them |
+| `recipes` | [`recipes`](#recipes) | read the game's recipes and items, and which recipes you know |
 
 ## World `horizon-mod`
 
@@ -36,7 +37,7 @@ A server mod (manifest `side = "server"`, `api = "0.3"`, experimental): runs whe
 
 A mod with widgets (capability `ui`): the SDK builds every mod against this world. Mods built for `horizon-mod` alone (no `ui-events` export) still load and simply hear nothing of their widgets.
 
-- Imports (what the game offers): `ui`, `render`, `input`, `log`, `game`, `chat`, `hud`, `storage`, `command`
+- Imports (what the game offers): `ui`, `render`, `input`, `recipes`, `log`, `game`, `chat`, `hud`, `storage`, `command`
 - Exports (what the mod provides): `ui-events`, `events`
 
 ## World `ui-host`
@@ -53,6 +54,13 @@ The game's side of capability `render` (imports only).
 - Imports (what the game offers): `render`, `input`
 - Exports (what the mod provides): 
 
+## World `recipes-host`
+
+The game's side of capability `recipes` (imports only).
+
+- Imports (what the game offers): `recipes`
+- Exports (what the mod provides): 
+
 ## `log`
 
 Access: always granted.
@@ -461,6 +469,68 @@ What the game calls. Only the hooks `init` asks for are ever called.
 | `command` | `func(name: string, args: string) -> result<option<string>, string>` | `/name args`: ok(some(text)) is shown as feedback, err(text) in red. |
 | `chat` | `func(text: string)` | Each chat line the player receives, as plain text. |
 
+## `recipes`
+
+Access: capability `recipes`.
+
+Capability `recipes` (experimental): the recipes and items the game knows, for recipe viewers. In single player and on Horizon's servers they are the world's; on any other server they are vanilla 26.3's (a client is sent no others), while `known` follows that server's book.
+
+### record `stack`
+
+An item of `items`, by its index there, with a count and the components it has beyond the item's own, in vanilla's item syntax (`[potion_contents={potion:"minecraft:swiftness"}]`), or "".
+
+| Field | Type | |
+| --- | --- | --- |
+| `item` | `u32` |  |
+| `count` | `u32` |  |
+| `components` | `string` |  |
+
+### enum `kind`
+
+The station a recipe is made at.
+
+| Case | |
+| --- | --- |
+| `crafting-shaped` |  |
+| `crafting-shapeless` |  |
+| `smelting` |  |
+| `blasting` |  |
+| `smoking` |  |
+| `campfire` |  |
+| `stonecutting` |  |
+| `smithing` |  |
+| `brewing` |  |
+
+### record `recipe`
+
+| Field | Type | |
+| --- | --- | --- |
+| `id` | `string` | `minecraft:oak_planks`. |
+| `kind` | `kind` |  |
+| `category` | `string` | The recipe book's tab (`crafting_building_blocks`, `furnace_food`), or "". |
+| `group` | `string` | Recipes the book shows on one button share a group, or "". |
+| `width` | `u32` | A shaped recipe's grid: `slots` holds its cells row by row. 0 for the other kinds. |
+| `height` | `u32` |  |
+| `slots` | `list<list<stack>>` | Each slot's stacks, any one of which fits; an empty list is an empty cell. Cooking and stonecutting: the input. Smithing: the template, the base, the addition. Brewing: the bottle, the reagent. |
+| `results` | `list<stack>` | What it makes; several when that varies (a trim on any armour). |
+| `cooking-time` | `u32` | Cooking: game ticks and experience; 0 for the other kinds. |
+| `experience` | `f32` |  |
+| `book-id` | `s32` | The recipe book's id for it (one per way the book shows it), as `known` lists them; -1 for the kinds the book doesn't show (campfire, stonecutting, smithing, brewing). |
+
+### record `item`
+
+| Field | Type | |
+| --- | --- | --- |
+| `id` | `string` | `minecraft:diamond`, `<mod>:<path>`. |
+| `name` | `string` | In the player's language. |
+| `tags` | `list<string>` | Its item tags, without the `#`. |
+
+| Function | Signature | What it does |
+| --- | --- | --- |
+| `items` | `func() -> list<item>` | Every item, in the registry's order: `stack.item` indexes this list. |
+| `all` | `func() -> list<recipe>` | Every recipe: the book's in its order, then campfire, stonecutting, smithing and brewing. They don't change while a world is open. |
+| `known` | `func() -> list<s32>` | The `book-id`s of the recipes the player's recipe book holds now. |
+
 ## `players`
 
 Access: capability `players`.
diff --git a/docs/api/stability.md b/docs/api/stability.md
index df2c1aeb3..00b5541a9 100644
--- a/docs/api/stability.md
+++ b/docs/api/stability.md
@@ -38,7 +38,7 @@ don't import it); faster, or fixing behaviour to what the reference already says
 
 A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every
 function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`):
-level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`, level 3 `command.run-quiet`. A mod needs the level of
+level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`, level 3 `command.run-quiet`, level 4 `recipes` (`items`, `all`, `known`). A mod needs the level of
 the newest function it imports (a component imports only the functions it calls). The level is read from the file,
 never declared:
 
diff --git a/docs/mods.md b/docs/mods.md
index 28415d28f..73ecfb9a5 100644
--- a/docs/mods.md
+++ b/docs/mods.md
@@ -91,6 +91,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3.
 | `ui` | `ui` | `open-screen`, `close-screen`, `set-settings`: a screen the mod owns and a page in Options > Mods, of text, button, item and list widgets the game lays out and draws with its own menus' code. **Experimental:** the manifest needs `experimental = ["ui"]` |
 | `render` | `render` | `set-hud(shapes)`: up to 1024 fills, four-cornered shapes, GUI sprites, items and text, kept on the HUD (over the hotbar, under chat and screens, hidden with F1) until replaced; `set-corner(corner, w, h, shapes)`: a box the game places in a corner, stacked with its overlays and other panels, as `hud`'s panels are; `text-width(text)`; `frame-stats()`: the game's FPS, min and 1% low; `gui-size()`; `shake(strength, seconds)`: the view turns, the player doesn't, scaled by Distortion Effects; `set-zoom(zoom)`: the field of view divided by up to 10, eased or at once, with slower turning, while playing and not through a spyglass (the strongest of several mods' zooms counts); `set-minimap(minimap)`: a map of the world around the player in a corner, as a map item colours it (the floor underground and under roofs), square or round, turning with the player or north up, with the player's arrow; the game keeps its tiles within its own frame budget (one map at a time, the first loaded mod's). The game's own HUD renderer draws them: a mod never supplies shader code. **Experimental:** `experimental = ["render"]` |
 | `input` | `input` | `claim-items(ids)`: the use button on those items is the mod's (`use-start`, `use-stop` with the ticks held; the game doesn't place, eat or swing); `register-key(name, label, key)`: up to 16 keys (`key.keyboard.r`), heard while playing as `key-down` / `key-up` (the game's own mapping on that key still runs; a screen opening lets held keys up), mouse buttons as `key.mouse.4`. The player rebinds them on the mod's page in Options > Mods, where the game lists them first as Key Binds rows (click, then press a key or mouse button; Esc binds none), even for a mod without `ui`; the choice is kept in `horizon-mods.txt` (`key.<mod>.<name>:key.keyboard.z`) and wins over `register-key`'s default; `claim-wheel(on)`: the wheel's steps become `wheel` events and the hotbar doesn't move (the one input a mod takes from the game; a mod's keys never do); `held()`; `mapping(name)`: a movement or click mapping's key label and whether it is held; `clicks-per-second()`; `poll()` returns the events, at most 256 kept. **Experimental:** `experimental = ["input"]` |
+| `recipes` | `recipes` | `items()`: every item in the registry's order, with its name in the player's language and its tags; `all()`: every recipe (crafting, smelting, blasting, smoking, campfire, stonecutting, smithing, brewing), its slots as the stacks that fit each, its results, cooking time and experience, and the recipe book's id for it; `known()`: the book ids the player's recipe book holds. The recipes are the world's in single player and on Horizon's servers, vanilla 26.3's on any other server (a client is sent no others), while `known` follows that server's book. The game makes the tables once, when a mod first reads them. **Experimental:** `experimental = ["recipes"]` |
 
 | Hook (export) | When |
 |---|---|
@@ -116,7 +117,6 @@ loading. Ordered by what the first native ports need:
 | `keys` | keybinds | registered binds appear in Controls; press/release events |
 | `target` | the crosshair's block or entity, with its state and NBT summary | Jade/WTHIT-style tooltips |
 | `inventory-read` | the player's inventory, held item, open container | AppleSkin, recipe viewers |
-| `recipes` | the recipe registry and lookups | JEI/EMI-style viewers |
 | `world-read` | blocks and biomes around the player, within the render distance | minimaps, schematics |
 | `render` (world) | world-space lines, boxes and billboards, beside the HUD shapes `render` has | Litematica-style placement, waypoints |
 | `registries` | new blocks, items, entities and recipes, mostly data: JSON models, textures, loot and recipes in the `.hmod`'s `assets/` and `data/` | server side; see [Multiplayer](#multiplayer) |

From bf2c8679660a72f3377e809ece12eb6aeaac32b9 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 15:49:55 +0100
Subject: [PATCH 129/475] Zombies: roll canBreakDoors when the game spawns them

Zombie.finalizeSpawn calls setCanBreakDoors(nextFloat() < special * 0.1)
after the baby roll; the game's spawn finalize never rolled it, so only
the finalize probe's zombies could break doors.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/mobs/spawning.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/horizon-client/src/mobs/spawning.rs b/crates/horizon-client/src/mobs/spawning.rs
index f4e55e7d0..f362139cd 100644
--- a/crates/horizon-client/src/mobs/spawning.rs
+++ b/crates/horizon-client/src/mobs/spawning.rs
@@ -163,6 +163,9 @@ pub fn finalize(m: &mut Mob, biome: &BiomeFacts, difficulty: &LocalDifficulty) {
             if m.random.next_float() < 0.05 {
                 m.extra.age = i32::MIN / 2;
             }
+            // setCanBreakDoors(nextFloat() < special * 0.1), before the gear.
+            let can_break_doors = m.random.next_float() < difficulty.special() * 0.1;
+            super::doors::set_can_break_doors(m, can_break_doors);
             if m.species() != S::Drowned {
                 populate_armor(m, difficulty);
             }
@@ -196,6 +199,9 @@ pub fn finalize(m: &mut Mob, biome: &BiomeFacts, difficulty: &LocalDifficulty) {
         // ZombifiedPiglin.populateDefaultEquipmentSlots: a golden sword, or
         // one time in 20 a golden spear.
         S::ZombifiedPiglin => {
+            // Zombie.finalizeSpawn's setCanBreakDoors.
+            let can_break_doors = m.random.next_float() < difficulty.special() * 0.1;
+            super::doors::set_can_break_doors(m, can_break_doors);
             let spear = m.random.next_int_bound(20).unwrap_or(1) == 0;
             m.extra.main_hand = Some(
                 if spear {

From 6f4c2cfbbc9dad4ef51e695c08a1d086fd88cf0d Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:16:19 +0100
Subject: [PATCH 130/475] Count the hurt tilt down while the player is dead or
 riding

---
 crates/horizon-client/src/game/remote.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 857f955da..54659e0f9 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3219,6 +3219,11 @@ impl Game<'_> {
                 resources: self.motion,
             }
             .controlled_simulation_tick(keys)?;
+        } else {
+            // LivingEntity.baseTick counts hurtTime down for a dead or riding
+            // player too (controlled_simulation_tick does it otherwise): left
+            // at 10, the hurt tilt restarted every frame and shook the camera.
+            player.health.advance_clock();
         }
         // LocalPlayer.onUpdateAbilities: flight turned on or off (a double
         // jump, a spectator, landing) is sent to the server.

From 2f3dade42ffd73511b597f8993b3f94b564ca310 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:19:53 +0100
Subject: [PATCH 131/475] Show the firework trail on a boosting rocket and hide
 its sprite

On a server-thread client an elytra boost rocket drew no spark trail and
showed up as a static item sprite. The client now follows the entity the
rocket is attached to, spawns the trail each tick like
FireworkRocketEntity.tick, and does not draw an attached rocket.
---
 crates/horizon-client/src/game/fireworks.rs   |  9 ++-
 .../src/game/remote_projectiles.rs            | 61 +++++++++++++------
 2 files changed, 50 insertions(+), 20 deletions(-)

diff --git a/crates/horizon-client/src/game/fireworks.rs b/crates/horizon-client/src/game/fireworks.rs
index e6b4eb136..4f61d728a 100644
--- a/crates/horizon-client/src/game/fireworks.rs
+++ b/crates/horizon-client/src/game/fireworks.rs
@@ -21,7 +21,7 @@ pub(super) struct Rocket {
     /// The entity id a server tracks it by (0 until it is tracked).
     pub id: u32,
     pub(super) position: Vec3,
-    previous: Vec3,
+    pub(super) previous: Vec3,
     pub(super) velocity: Vec3,
     life: i32,
     lifetime: i32,
@@ -369,7 +369,12 @@ impl Game<'_> {
     /// lit at the rocket's light probe.
     pub(super) fn rocket_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec<Vertex>) {
         let orientation = glam::Mat4::from_quat(self.camera_orientation());
-        for r in self.rockets.iter().filter(|r| !r.attached) {
+        // shouldRender: not while attached to an entity (`isAttachedToEntity`).
+        for r in self
+            .rockets
+            .iter()
+            .filter(|r| !r.attached && r.attached_to.is_none())
+        {
             // FireworkRocketEntity.shouldRenderAtSqrDistance: within 64 blocks;
             // EntityRenderer.shouldRender: its 0.25 box in the view.
             if !self.standing_entity_in_view(
diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs
index a117b1b7c..41631c4f1 100644
--- a/crates/horizon-client/src/game/remote_projectiles.rs
+++ b/crates/horizon-client/src/game/remote_projectiles.rs
@@ -3,8 +3,11 @@
 //! and `handleSetEntityData`): the server simulates them, the client draws
 //! them where it says and interpolates their moves.
 use super::{FallStep, FallingBlock, Game, fireworks::fireworks_of, view_vector};
-use horizon_client::projectiles::{Projectile, ProjectileKind};
-use horizon_core::{geometry::Vec3, position::BlockPos};
+use horizon_client::{
+    particles::{ParticleOptions, ParticleType},
+    projectiles::{Projectile, ProjectileKind},
+};
+use horizon_core::{geometry::Vec3, position::BlockPos, random::RandomSource};
 use horizon_protocol::entity_data::Value;
 use horizon_world::registry::BlockStateId;
 
@@ -273,8 +276,9 @@ impl Game<'_> {
             let id = t.id;
             t.remote_step(|at| step(id, at));
         }
-        // FireworkRocketEntity.tick: a rocket attached to the gliding local
-        // player boosts it client-side too (attachedToEntity.isFallFlying).
+        // FireworkRocketEntity.tick: a rocket attached to an entity follows it
+        // and boosts it client-side too (attachedToEntity.isFallFlying), and
+        // every rocket leaves its spark trail on a client.
         let me = self
             .remote
             .as_ref()
@@ -282,21 +286,42 @@ impl Game<'_> {
         for r in &mut self.rockets {
             let id = r.id;
             r.remote_step(|at| step(id, at));
-            if me.is_some()
-                && r.attached_to == me
-                && let Some(p) = self.player.as_mut()
-                && p.fall_flying
-            {
-                let look = view_vector(self.yaw, self.pitch);
-                let m = p.velocity;
-                p.velocity = Vec3::new(
-                    m.x + look[0] * 0.1 + (look[0] * 1.5 - m.x) * 0.5,
-                    m.y + look[1] * 0.1 + (look[1] * 1.5 - m.y) * 0.5,
-                    m.z + look[2] * 0.1 + (look[2] * 1.5 - m.z) * 0.5,
-                );
-                r.position = p.position;
-                r.velocity = p.velocity;
+            if let Some(target) = r.attached_to {
+                if me == Some(target) {
+                    if let Some(p) = self.player.as_mut() {
+                        if p.fall_flying {
+                            let look = view_vector(self.yaw, self.pitch);
+                            let m = p.velocity;
+                            p.velocity = Vec3::new(
+                                m.x + look[0] * 0.1 + (look[0] * 1.5 - m.x) * 0.5,
+                                m.y + look[1] * 0.1 + (look[1] * 1.5 - m.y) * 0.5,
+                                m.z + look[2] * 0.1 + (look[2] * 1.5 - m.z) * 0.5,
+                            );
+                        }
+                        r.position = p.position;
+                        r.velocity = p.velocity;
+                    }
+                } else if let Some(m) = self.mobs.iter().find(|m| m.id == target) {
+                    // Another player's motion is not known here: its step.
+                    r.velocity = Vec3::new(
+                        m.position.x - r.previous.x,
+                        m.position.y - r.previous.y,
+                        m.position.z - r.previous.z,
+                    );
+                    r.position = m.position;
+                }
             }
+            let g = |g: &mut horizon_core::random::LegacyRandom| g.next_gaussian() * 0.05;
+            let v = [
+                g(&mut self.world.random),
+                -r.velocity.y * 0.5,
+                g(&mut self.world.random),
+            ];
+            self.particles.add(
+                &ParticleOptions::simple(ParticleType::Firework),
+                [r.position.x, r.position.y, r.position.z],
+                v,
+            );
         }
         for c in &mut self.crystals {
             c.time += 1;

From 37825b750a8908d8682dc2d63b751c3d712dd608 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 16:23:06 +0100
Subject: [PATCH 132/475] Piglin AI: name the piglin repellent finder for its
 mob

#2191 and #2192 each add a `find_repellent` to piglin.rs, one for
hoglins and one for piglins; merged together they would collide.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/mobs/piglin.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs
index 59c0a9344..51cef4c6c 100644
--- a/crates/horizon-client/src/mobs/piglin.rs
+++ b/crates/horizon-client/src/mobs/piglin.rs
@@ -270,13 +270,13 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     }
     // PiglinSpecificSensor (every 20 ticks): the nearest repelling block.
     if m.species() == Species::Piglin && m.alive() && m.age.wrapping_add(m.id).is_multiple_of(20) {
-        m.extra.repellent = find_repellent(m, w);
+        m.extra.repellent = find_piglin_repellent(m, w);
     }
 }
 /// `PiglinSpecificSensor.findNearestRepellent`: the nearest `#piglin_repellents`
 /// block within 8 blocks sideways and 4 up or down; a soul campfire only
 /// counts while lit.
-fn find_repellent(m: &Mob, w: &MobWorld) -> Option<[i32; 3]> {
+fn find_piglin_repellent(m: &Mob, w: &MobWorld) -> Option<[i32; 3]> {
     let tag = w.block_tags.get("minecraft:piglin_repellents")?;
     let at = [
         m.position.x.floor() as i32,

From 47654b62a3b3f64ff163590ec1c29d16c341d50d Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:24:26 +0100
Subject: [PATCH 133/475] Save the armadillo scute timer and reset it only when
 a scute can drop

---
 .../examples/probe/mob_ai_probe.rs            |  1 +
 crates/horizon-client/src/entity_nbt.rs       | 10 +++++++
 crates/horizon-client/src/game/creatures.rs   | 29 +++++++++----------
 crates/horizon-client/src/mobs.rs             |  2 ++
 crates/horizon-client/src/mobs/ai.rs          | 27 ++++++++---------
 5 files changed, 41 insertions(+), 28 deletions(-)

diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs
index ecdf02901..81c739464 100644
--- a/crates/horizon-client/examples/probe/mob_ai_probe.rs
+++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs
@@ -1097,6 +1097,7 @@ pub fn main() -> horizon_client::Result<()> {
                     block_tags: &items.block_tags,
                     biomes: &biomes,
                     mob_griefing: true,
+                    mob_drops: true,
                     difficulty: LocalDifficulty::new(s.difficulty, world.day_time, 0, 0.0),
                     end: false,
                     world_seed: 0,
diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 00576ea02..91ede9110 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -445,6 +445,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
                 map.insert("anger".into(), Tag::compound(Vec::<(&str, Tag)>::new()));
             }
         }
+        // Armadillo.addAdditionalSaveData: the time left to the next scute.
+        "minecraft:armadillo" => {
+            map.insert("scute_time".into(), Tag::Int(m.extra.egg_time));
+        }
         "minecraft:ravager" => {
             map.insert("AttackTick".into(), Tag::Int(m.extra.counter));
             map.insert("StunTick".into(), Tag::Int(m.extra.counter2));
@@ -876,6 +880,12 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
             st.vibration = crate::sculk::Data::from_nbt(listener);
         }
     }
+    // Armadillo.readAdditionalSaveData: keeps the constructor's time when absent.
+    if m.species() == crate::mobs::Species::Armadillo
+        && let Some(t) = number(tag.get("scute_time"))
+    {
+        m.extra.egg_time = t as i32;
+    }
     if m.species() == crate::mobs::Species::Ravager {
         m.extra.counter = number(tag.get("AttackTick")).unwrap_or(0) as i32;
         m.extra.counter2 = number(tag.get("StunTick")).unwrap_or(0) as i32;
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 9a78bc2e5..56215fe9c 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -416,6 +416,7 @@ impl Game<'_> {
             block_tags: &self.res.items().block_tags,
             biomes: self.res.biomes(),
             mob_griefing: self.ui.rules.bool("mob_griefing"),
+            mob_drops: self.ui.rules.bool("mob_drops"),
             end: self.dim == Dim::End,
             world_seed: self.level.seed,
             sea_level: if self.dim == Dim::Nether { 32 } else { 63 },
@@ -1222,22 +1223,20 @@ impl Game<'_> {
                     }
                 }
                 MobEvent::ShedScute { mob, at, pitch } => {
-                    // shouldDropLoot: the `mob_drops` rule.
-                    if self.ui.rules.bool("mob_drops") {
-                        let table = "minecraft:gameplay/armadillo_shed";
-                        let drops = self.sequence_loot(table, table, None);
-                        for d in drops {
-                            self.spawn_at_location(Vec3::new(at[0], at[1], at[2]), 0.0, d);
-                        }
-                        self.audio.play(
-                            "minecraft:entity.armadillo.scute_drop",
-                            Some(at),
-                            1.0,
-                            pitch,
-                        );
-                        let ctx = self.who_context(Some(Who::Mob(mob)), None);
-                        self.post_game_event("minecraft:entity_place", at, ctx);
+                    // The mob already checked `shouldDropLoot` (a baby, `mob_drops`).
+                    let table = "minecraft:gameplay/armadillo_shed";
+                    let drops = self.sequence_loot(table, table, None);
+                    for d in drops {
+                        self.spawn_at_location(Vec3::new(at[0], at[1], at[2]), 0.0, d);
                     }
+                    self.audio.play(
+                        "minecraft:entity.armadillo.scute_drop",
+                        Some(at),
+                        1.0,
+                        pitch,
+                    );
+                    let ctx = self.who_context(Some(Who::Mob(mob)), None);
+                    self.post_game_event("minecraft:entity_place", at, ctx);
                 }
                 MobEvent::GiftLoot { table, at } => {
                     let drops =
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 315bfdce2..c276c1e66 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1501,6 +1501,8 @@ pub struct MobWorld<'a> {
     pub biomes: &'a crate::biome::Biomes,
     /// The `mob_griefing` game rule.
     pub mob_griefing: bool,
+    /// The `mob_drops` game rule (`shouldDropLoot`).
+    pub mob_drops: bool,
     /// `getCurrentDifficultyAt` near the player.
     pub difficulty: spawning::LocalDifficulty,
     /// The End (its dimension type's monster spawn light rules).
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 8259ddccb..90337e416 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -938,26 +938,27 @@ fn server_ai_step(
 fn next_scute_time(m: &mut Mob) -> i32 {
     m.random.next_int_bound(20 * 60 * 5).unwrap_or(0) + 20 * 60 * 5
 }
-/// `Armadillo.customServerAiStep`: the scute timer. A baby only resets it
-/// (`shouldDropLoot`); the game checks the `mob_drops` rule.
-fn armadillo_server_ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
+/// `Armadillo.customServerAiStep`: the scute timer keeps counting down and is
+/// only reset once `shouldDropLoot` (not a baby, `mob_drops` on) lets it shed.
+fn armadillo_server_ai_step(m: &mut Mob, mob_drops: bool, events: &mut Vec<MobEvent>) {
+    if !m.alive() {
+        return;
+    }
     m.extra.egg_time -= 1;
-    if m.alive() && m.extra.egg_time <= 0 {
-        if !m.is_baby() {
-            let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0;
-            events.push(MobEvent::ShedScute {
-                mob: m.id,
-                at: [m.position.x, m.position.y, m.position.z],
-                pitch,
-            });
-        }
+    if m.extra.egg_time <= 0 && !m.is_baby() && mob_drops {
+        let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0;
+        events.push(MobEvent::ShedScute {
+            mob: m.id,
+            at: [m.position.x, m.position.y, m.position.z],
+            pitch,
+        });
         m.extra.egg_time = next_scute_time(m);
     }
 }
 fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) {
     match m.species() {
         Species::Rabbit => super::rabbit::server_ai_step(m),
-        Species::Armadillo => armadillo_server_ai_step(m, cx.events),
+        Species::Armadillo => armadillo_server_ai_step(m, cx.w.mob_drops, cx.events),
         Species::Sheep => {}
         Species::Zombie
         | Species::Husk

From 18f4dd92aea541b501a154f341b36135210ac4d1 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:24:42 +0100
Subject: [PATCH 134/475] Play container open and close sounds only when the
 opener count crosses zero

---
 crates/horizon-client/src/game.rs             | 33 ++++++------------
 .../src/game/block_entity_anims.rs            | 34 +++++++++++--------
 crates/horizon-client/src/game/lan_actions.rs |  7 ++--
 crates/horizon-client/src/game/storage.rs     | 30 ++++++++++++----
 4 files changed, 58 insertions(+), 46 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index d0e060c13..73dcfc455 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -3019,15 +3019,9 @@ impl Game<'_> {
             self.craft_table = Some(pos);
         } else if &*name == "minecraft:ender_chest" {
             self.open_ender_chest(key);
-            self.container_opener_event(key, true);
-            let at = [
-                f64::from(key.0) + 0.5,
-                f64::from(key.1) + 0.5,
-                f64::from(key.2) + 0.5,
-            ];
-            let pitch = self.world.random.next_float() * 0.1 + 0.9;
-            self.audio
-                .play("minecraft:block.ender_chest.open", Some(at), 0.5, pitch);
+            if self.container_opener_event(key, true) {
+                self.container_edge_sound(key, true);
+            }
         } else if &*name == "minecraft:beacon" && self.open_station(pos, &name) {
             self.world.block_entities.get_or_insert_with(key, || {
                 BlockEntity::for_block(&name).unwrap_or(BlockEntity::Chest(Vec::new()))
@@ -3043,7 +3037,7 @@ impl Game<'_> {
             ];
             self.resolve_container_maps(key, centre);
             self.container = Some(key);
-            self.container_opener_event(key, true);
+            let first = self.container_opener_event(key, true);
             self.post_block_game_event(
                 "minecraft:container_open",
                 [key.0, key.1, key.2],
@@ -3067,17 +3061,8 @@ impl Game<'_> {
             if self.guarded_by_piglins(&name) {
                 self.anger_piglins(true);
             }
-            let sound = if storage::is_shulker_box(&name) {
-                Some("minecraft:block.shulker_box.open")
-            } else if name.contains("chest") {
-                Some("minecraft:block.chest.open")
-            } else if &*name == "minecraft:barrel" {
-                Some("minecraft:block.barrel.open")
-            } else {
-                None
-            };
-            if let Some(sound) = sound {
-                self.container_sound(sound, key, &name);
+            if first {
+                self.container_edge_sound(key, true);
             }
         } else if self.open_station(pos, &name) {
             // Workstation menus: game/stations.rs.
@@ -5620,14 +5605,16 @@ impl Game<'_> {
         if let Some(key) = self.container.take() {
             // A cart's or chest boat's items go back to it.
             self.close_cart_container(key);
-            self.container_opener_event(key, false);
+            let last = self.container_opener_event(key, false);
             self.post_block_game_event(
                 "minecraft:container_close",
                 [key.0, key.1, key.2],
                 Some(horizon_client::mobs::Who::Player),
                 None,
             );
-            self.container_close_sound(key);
+            if last {
+                self.container_edge_sound(key, false);
+            }
             self.world.modified.insert((key.0 >> 4, key.2 >> 4));
         }
         self.close_ender_chest();
diff --git a/crates/horizon-client/src/game/block_entity_anims.rs b/crates/horizon-client/src/game/block_entity_anims.rs
index 3d452596e..4d48b0874 100644
--- a/crates/horizon-client/src/game/block_entity_anims.rs
+++ b/crates/horizon-client/src/game/block_entity_anims.rs
@@ -71,23 +71,24 @@ impl Game<'_> {
     /// A player opened (`open`) or closed the container at `key`: the opener
     /// count block event (`ContainerOpenersCounter` / `ShulkerBoxBlockEntity`
     /// `startOpen`/`stopOpen`) for chests, ender chests and shulker boxes,
-    /// on both halves of a double chest (`CompoundContainer`).
-    pub(super) fn container_opener_event(&mut self, key: (i32, i32, i32), open: bool) {
+    /// on both halves of a double chest (`CompoundContainer`). True when the
+    /// count went from 0 to 1 or back to 0: the only moments the container
+    /// plays its open or close sound.
+    pub(super) fn container_opener_event(&mut self, key: (i32, i32, i32), open: bool) -> bool {
         // Spectators never count as openers.
-        if !self.spectator() {
-            self.container_openers_changed(key, open);
-        }
+        !self.spectator() && self.container_openers_changed(key, open)
     }
     /// `container_opener_event` for a player who is not a spectator (a guest).
-    pub(super) fn container_openers_changed(&mut self, key: (i32, i32, i32), open: bool) {
+    pub(super) fn container_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool {
         let pos = [key.0, key.1, key.2];
         let state = self.world.block(pos[0], pos[1], pos[2]).0;
         match self.be_anims.ticker(state) {
             Some(Ticker::Lid) => {
-                self.lid_openers_changed(key, open);
+                let edge = self.lid_openers_changed(key, open);
                 if let Some(other) = self.chest_other_half(key) {
                     self.lid_openers_changed(other, open);
                 }
+                edge
             }
             _ if self
                 .res
@@ -97,26 +98,27 @@ impl Game<'_> {
                 .as_ref()
                 == "minecraft:barrel" =>
             {
-                self.barrel_openers_changed(key, open);
+                self.barrel_openers_changed(key, open)
             }
             Some(Ticker::Shulker { .. }) => {
                 let shulker = self.be_anims.shulkers.entry(pos).or_default();
-                let (count, _) = if open {
+                let (count, edge) = if open {
                     shulker.start_open()
                 } else {
                     shulker.stop_open()
                 };
                 self.block_entity_event(pos, 1, count);
                 self.lan_block_event(pos, 1, count);
+                edge
             }
-            _ => {}
+            _ => false,
         }
     }
     /// `ContainerOpenersCounter.incrementOpeners` / `decrementOpeners` of the
     /// chest at `key` (the host and the guests are counted), then
     /// `ChestBlockEntity.signalOpenCount`: block event 1 with the count, here
-    /// and for the guests.
-    fn lid_openers_changed(&mut self, key: (i32, i32, i32), open: bool) {
+    /// and for the guests. True when the count crossed zero.
+    fn lid_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool {
         let (before, count) = self.count_opener(key, open);
         let pos = [key.0, key.1, key.2];
         self.block_entity_event(pos, 1, count);
@@ -134,12 +136,15 @@ impl Game<'_> {
                 b.update_neighbors_at(level, ticks, p.offset(0, -1, 0), block);
             });
         }
+        (before == 0) != (count == 0)
     }
     /// `BarrelBlockEntity.openersCounter`: the first opener opens the barrel
     /// (`open=true`), the last one to leave closes it (`updateBlockState`).
-    fn barrel_openers_changed(&mut self, key: (i32, i32, i32), open: bool) {
+    /// True when the count crossed zero.
+    fn barrel_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool {
         let (before, count) = self.count_opener(key, open);
-        if (before == 0) != (count == 0) {
+        let edge = (before == 0) != (count == 0);
+        if edge {
             self.set_bool_prop(
                 key,
                 "open",
@@ -147,6 +152,7 @@ impl Game<'_> {
                 horizon_world::level::flags::UPDATE_ALL,
             );
         }
+        edge
     }
     /// One opener more (`open`) or less at `key`: the count before and after
     /// (`ContainerOpenersCounter.incrementOpeners` / `decrementOpeners`).
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 41ada973c..796e5f89c 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -856,14 +856,15 @@ impl Game<'_> {
     /// The guest's open container is closing (`AbstractContainerMenu.removed`):
     /// it no longer counts among the openers of the lid, and the lid's close
     /// sound is played for everyone around (`ChestBlockEntity.onClose`, a
-    /// `playSound` with no player), the guest included.
+    /// `playSound` with no player), the guest included, once the last opener
+    /// has left.
     pub(super) fn guest_container_closed(&mut self, host: &mut LanHost, conn: u32) {
         if let Some(g) = host.hub.guest(conn)
             && let Some(pos) = g.menu.as_ref().and_then(|m| m.pos)
             && !g.spectator()
+            && self.container_openers_changed(pos, false)
         {
-            self.container_openers_changed(pos, false);
-            self.container_close_sound(pos);
+            self.container_edge_sound(pos, false);
         }
     }
 
diff --git a/crates/horizon-client/src/game/storage.rs b/crates/horizon-client/src/game/storage.rs
index d733f1cca..7db0ce82c 100644
--- a/crates/horizon-client/src/game/storage.rs
+++ b/crates/horizon-client/src/game/storage.rs
@@ -142,8 +142,10 @@ impl Game<'_> {
         let pitch = self.world.random.next_float() * 0.1 + 0.9;
         self.audio.play(sound, Some(at), 0.5, pitch);
     }
-    /// The close sound of the container block at `key`, if it has one.
-    pub(super) fn container_close_sound(&mut self, key: (i32, i32, i32)) {
+    /// The open or close sound of the container block at `key`, if it has one.
+    /// Callers play it only when the opener count crosses zero
+    /// (`ContainerOpenersCounter.onOpen` / `onClose`).
+    pub(super) fn container_edge_sound(&mut self, key: (i32, i32, i32), open: bool) {
         let name = self
             .res
             .facts()
@@ -151,13 +153,29 @@ impl Game<'_> {
             .name
             .clone();
         let sound = if is_shulker_box(&name) {
-            "minecraft:block.shulker_box.close"
+            if open {
+                "minecraft:block.shulker_box.open"
+            } else {
+                "minecraft:block.shulker_box.close"
+            }
         } else if &*name == "minecraft:ender_chest" {
-            "minecraft:block.ender_chest.close"
+            if open {
+                "minecraft:block.ender_chest.open"
+            } else {
+                "minecraft:block.ender_chest.close"
+            }
         } else if name.contains("chest") {
-            "minecraft:block.chest.close"
+            if open {
+                "minecraft:block.chest.open"
+            } else {
+                "minecraft:block.chest.close"
+            }
         } else if &*name == "minecraft:barrel" {
-            "minecraft:block.barrel.close"
+            if open {
+                "minecraft:block.barrel.open"
+            } else {
+                "minecraft:block.barrel.close"
+            }
         } else {
             return;
         };

From f364c4f9c6fdb28e114ef5b7a84d1f62e5a988d5 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:28:28 +0100
Subject: [PATCH 135/475] Leave wandering traders out of the spawn egg baby
 check

---
 crates/horizon-client/src/game/creatures.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 3ebf9ef49..420509900 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2969,6 +2969,9 @@ impl Game<'_> {
         if !parent.alive()
             || stack.item.strip_suffix("_spawn_egg") != Some(parent.kind.id.as_str())
             || !horizon_client::mobs::drops::can_be_baby(parent.species())
+            // WanderingTrader.getBreedOffspring returns null: no offspring, the
+            // click carries on to trading.
+            || parent.species() == Species::WanderingTrader
         {
             return false;
         }

From c50557ea0ba2abb0c1476aa65faf12ee090478c7 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:29:05 +0100
Subject: [PATCH 136/475] Credit the projectile owner for explosion damage to
 mobs

---
 crates/horizon-client/src/game/combat.rs    | 3 +++
 crates/horizon-client/src/game/creatures.rs | 5 ++++-
 crates/horizon-client/src/game/explosion.rs | 6 +++++-
 crates/horizon-client/src/game/wither.rs    | 5 ++++-
 4 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs
index 106e0e1a1..3d0c34ff2 100644
--- a/crates/horizon-client/src/game/combat.rs
+++ b/crates/horizon-client/src/game/combat.rs
@@ -31,6 +31,9 @@ pub(super) struct CombatTracker {
     /// The mob exploding now (`ServerExplosion.source`): its team's friendly
     /// fire decides whom the blast may hurt.
     pub(super) explosion_source: Option<u32>,
+    /// The mob that owns the projectile exploding now (`getIndirectSourceEntity`):
+    /// the mobs the blast hurts record it as their attacker.
+    pub(super) explosion_owner: Option<u32>,
     /// The player's fall distance before this tick's movement (as of the
     /// end of the last one).
     fall_before: f64,
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index cd211ec48..48e029381 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2283,7 +2283,10 @@ impl Game<'_> {
                 if let Some(owner) = self.combat.projectile_owner {
                     self.note_attacker("minecraft:explosion", owner);
                 }
-                self.explode(atp, *power as f32)?;
+                self.combat.explosion_owner = self.combat.projectile_owner;
+                let result = self.explode(atp, *power as f32);
+                self.combat.explosion_owner = None;
+                result?;
             }
             (
                 ProjectileKind::Potion {
diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs
index 6ecba3a54..675203517 100644
--- a/crates/horizon-client/src/game/explosion.rs
+++ b/crates/horizon-client/src/game/explosion.rs
@@ -393,7 +393,11 @@ impl Game<'_> {
             );
             let source = horizon_client::mobs::Damage {
                 kind: horizon_client::mobs::DamageKind::Explosion,
-                attacker: None,
+                attacker: self
+                    .combat
+                    .explosion_owner
+                    .filter(|&o| o != m.id)
+                    .map(horizon_client::mobs::Who::Mob),
                 from: Some(center),
             };
             if hurtable && !m.damage(damage(dist, exposure), source) {
diff --git a/crates/horizon-client/src/game/wither.rs b/crates/horizon-client/src/game/wither.rs
index 101818f68..996f55d1c 100644
--- a/crates/horizon-client/src/game/wither.rs
+++ b/crates/horizon-client/src/game/wither.rs
@@ -172,7 +172,10 @@ impl Game<'_> {
         if let Some(id) = owner {
             self.note_attacker("minecraft:explosion", id);
         }
-        self.explode(at, 1.0)
+        self.combat.explosion_owner = owner;
+        let result = self.explode(at, 1.0);
+        self.combat.explosion_owner = None;
+        result
     }
 }
 /// Wither skulls drawn as the skull model, blue when dangerous.

From b28108128d23ac61783b160a922f00b320133d98 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:33:08 +0100
Subject: [PATCH 137/475] Keep a hopper minecart's items in sync with a
 leftover menu copy

---
 crates/horizon-client/src/game/machines.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs
index 55e47aa67..0562af8cd 100644
--- a/crates/horizon-client/src/game/machines.rs
+++ b/crates/horizon-client/src/game/machines.rs
@@ -777,7 +777,15 @@ impl Game<'_> {
                 [hi.x + 0.25, hi.y, hi.z + 0.25],
             );
         }
-        if !open && let Some(BlockEntity::Chest(items)) = self.world.block_entities.remove(&key) {
+        // The cart's own items stay the one source of truth: a menu copy that
+        // is still around (open, or left by a guest's close) gets the pulled
+        // items back into `cart.items`, so reopening never restores a stale copy.
+        let slots = if open {
+            self.world.block_entities.get(&key).cloned()
+        } else {
+            self.world.block_entities.remove(&key)
+        };
+        if let Some(BlockEntity::Chest(items)) = slots {
             cart.items = items;
         }
     }

From 3842d851d8f088a138e5a09bd42cb054ac88ffa9 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:38:07 +0100
Subject: [PATCH 138/475] Match the brewed_potion trigger's potion condition as
 a PotionsPredicate

---
 crates/horizon-client/src/advancements.rs     | 45 +++++++++++++++++++
 .../horizon-client/src/game/advancements.rs   |  5 +--
 2 files changed, 46 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/advancements.rs b/crates/horizon-client/src/advancements.rs
index 6706532b7..531116ab6 100644
--- a/crates/horizon-client/src/advancements.rs
+++ b/crates/horizon-client/src/advancements.rs
@@ -473,6 +473,51 @@ pub fn id_matches(v: &Value, registry: &str, id: &str, w: &dyn World) -> bool {
         _ => false,
     }
 }
+/// `PotionsPredicate`: the potion in a `HolderSet`, plus a `CollectionPredicate`
+/// over the potion's effects (`contains`, `count`, `size`).
+pub fn potions(v: &Value, potion: Option<&str>, w: &dyn World) -> bool {
+    if v.is_null() {
+        return true;
+    }
+    if !v["potions"].is_null() && !potion.is_some_and(|p| id_matches(&v["potions"], "potion", p, w))
+    {
+        return false;
+    }
+    let c = &v["effects"];
+    if c.is_null() {
+        return true;
+    }
+    let effects: Vec<(String, i32, i32)> = potion
+        .and_then(crate::brewing::potion)
+        .map(|d| {
+            d.effects
+                .iter()
+                .map(|(id, dur, amp)| (format!("minecraft:{id}"), *amp, *dur))
+                .collect()
+        })
+        .unwrap_or_default();
+    // `MobEffectsPredicate.test`: the one listed effect, amplifier and duration.
+    let test = |pred: &Value, e: &(String, i32, i32)| {
+        pred.as_object().is_some_and(|m| {
+            m.get(&e.0).is_some_and(|want| {
+                range_i(&want["amplifier"], i64::from(e.1))
+                    && range_i(&want["duration"], i64::from(e.2))
+                    && want["ambient"].as_bool().is_none_or(|b| !b)
+                    && want["visible"].as_bool().is_none_or(|b| b)
+            })
+        })
+    };
+    c["contains"]
+        .as_array()
+        .is_none_or(|l| l.iter().all(|p| effects.iter().any(|e| test(p, e))))
+        && c["count"].as_array().is_none_or(|l| {
+            l.iter().all(|entry| {
+                let n = effects.iter().filter(|e| test(&entry["test"], e)).count();
+                range_i(&entry["count"], n as i64)
+            })
+        })
+        && range_i(&c["size"], effects.len() as i64)
+}
 /// `ItemPredicate`.
 pub fn item(v: &Value, it: &ItemView, w: &dyn World) -> bool {
     if v.is_null() {
diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs
index 53fa282d4..a58066751 100644
--- a/crates/horizon-client/src/game/advancements.rs
+++ b/crates/horizon-client/src/game/advancements.rs
@@ -721,10 +721,7 @@ impl Game<'_> {
                 block_pos: None,
             };
             adv::conditions(&c["player"], &pctx, w)
-                && (c["potion"].is_null()
-                    || potion
-                        .as_deref()
-                        .is_some_and(|p| adv::id_matches(&c["potion"], "potion", p, w)))
+                && adv::potions(&c["potion"], potion.as_deref(), w)
         });
     }
     /// `EnterBlockTrigger`: the block, its state properties and the player.

From 4471e59132dd8af6248d8685d066aa86ae6c15a6 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 16:41:23 +0100
Subject: [PATCH 139/475] Load the loot tables before a world's first chunks
 are read

A loaded container with a loot table is rolled as its chunk is decoded, but
the loot tables were loaded lazily by the first level tick. The spawn chunks
are decoded while the world opens, so a loot chest in them came out empty and
lost its table on the next save. WorldRequest::prepare, which every world
opens through (in-frame, server thread, dedicated server), now loads them
first.

spawn_loot: vanilla writes a flat world with a seeded loot chest by the
spawn and rolls it; Horizon opens it in a fresh process, in-frame and on the
server thread, and must hold the same stacks in the same slots. Without the
fix both modes hold nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../horizon-client/src/game/world_loading.rs  |   4 +
 tools/test_spawn_loot_parity.py               | 117 ++++++++++++++++++
 2 files changed, 121 insertions(+)
 create mode 100644 tools/test_spawn_loot_parity.py

diff --git a/crates/horizon-client/src/game/world_loading.rs b/crates/horizon-client/src/game/world_loading.rs
index 0cea31fd0..44c903737 100644
--- a/crates/horizon-client/src/game/world_loading.rs
+++ b/crates/horizon-client/src/game/world_loading.rs
@@ -46,6 +46,10 @@ impl WorldRequest {
         options: &Options,
         settings: &Settings,
     ) -> Result<PreparedWorld> {
+        // Before any chunk is read: a loaded container with a loot table is rolled as its chunk
+        // is decoded (`save::roll_loaded_loot`), and the spawn chunks are read while the world
+        // opens. Every world opens here: in-frame, on the server thread, on a dedicated server.
+        horizon_client::structure_blocks::loot_data(&options.resources);
         let Self {
             save_root,
             folder,
diff --git a/tools/test_spawn_loot_parity.py b/tools/test_spawn_loot_parity.py
new file mode 100644
index 000000000..896cfab0e
--- /dev/null
+++ b/tools/test_spawn_loot_parity.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""A vanilla loot chest at spawn has its loot when Horizon opens the world.
+
+Vanilla rolls a container's loot table when a player first opens it
+(`RandomizableContainer.unpackLootTable`). Horizon rolls a loaded container with a loot table
+and no items as its chunk is read from disk (`save::roll_loaded_loot`), so a container nobody
+opens still saves as vanilla wrote it. The loot tables have to be loaded before the first chunks
+are read: the spawn chunks are read while the world opens, and a chest read before the tables
+came out empty, its loot table lost on the next save.
+
+The vanilla 26.3 server writes a flat world with a seeded loot chest beside the world spawn, then
+rolls the chest itself in a copy of that world (`execute if items` unpacks it). Horizon opens the
+untouched world in a new process, so nothing was loaded before the world, and must hold the same
+items in the same slots. Both single-player paths: the default server thread and in-frame.
+
+  test_spawn_loot_parity.py [--bin-dir DIR] [--keep]
+"""
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from test_save_roundtrip_parity import Vanilla  # noqa: E402
+from test_world_reopen_parity import game_env  # noqa: E402
+
+ROOT = Path(__file__).resolve().parent.parent
+RESOURCES = ROOT / '.local' / 'horizon-client' / '26.3'
+RUN = ROOT / '.local' / 'spawn-loot'
+CHEST = (2, -60, 1)
+LOOT = '{LootTable:"minecraft:chests/simple_dungeon",LootTableSeed:42L}'
+MODES = {'server thread': [], 'in-frame': ['--in-frame']}
+
+
+def vanilla_world():
+    """The world with the unopened chest, and what vanilla rolls from it: [(slot, id, count)]."""
+    server = Vanilla(RUN / 'v0')
+    try:
+        server.run('setworldspawn 0 -60 0')
+        server.run('forceload add 0 0')
+        time.sleep(2)
+        server.run('setblock {} {} {} minecraft:chest{}'.format(*CHEST, LOOT))
+        server.run('save-all flush')
+        time.sleep(2)
+    finally:
+        server.stop()
+    shutil.copytree(RUN / 'v0', RUN / 'vv')
+    server = Vanilla(RUN / 'vv')
+    try:
+        server.run('forceload add 0 0')
+        time.sleep(2)
+        server.run('execute if items block {} {} {} container.* *'.format(*CHEST))
+        text = ' '.join(server.run('data get block {} {} {} Items'.format(*CHEST)))
+    finally:
+        server.stop()
+    rolled = []
+    for item in re.finditer(r'\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}', text.split('data:', 1)[-1]):
+        found = item.group(0)
+        count = re.search(r'count: (\d+)', found)
+        rolled.append((int(re.search(r'Slot: (\d+)b', found).group(1)), re.search(r'id: "([^"]+)"', found).group(1),
+                       int(count.group(1)) if count else 1))
+    return sorted(rolled)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('--bin-dir', help='prebuilt horizon-client and horizon-ctl (default: build them with the fast profile)')
+    parser.add_argument('--keep', action='store_true', help='keep the run folder')
+    args = parser.parse_args()
+    bin_dir = Path(args.bin_dir).resolve() if args.bin_dir else None
+    if bin_dir is None:
+        subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', '--bins'], cwd=ROOT, check=True)
+        bin_dir = ROOT / os.environ.get('CARGO_TARGET_DIR', 'target') / 'fast'
+    shutil.rmtree(RUN, ignore_errors=True)
+    RUN.mkdir(parents=True)
+    expected = vanilla_world()
+    print('vanilla rolls:', expected)
+    if not expected:
+        sys.exit('vanilla rolled nothing from the chest')
+    env, extra = game_env()
+    failures = 0
+    for index, (mode, flags) in enumerate(MODES.items()):
+        folder = RUN / f'h{index}'
+        shutil.copytree(RUN / 'v0' / 'world', folder / 'saves' / 'world')
+        socket = Path(tempfile.mkdtemp(prefix='hzsl')) / 'control.sock'  # sockets need short paths
+
+        def ctl(*words, check=True):
+            result = subprocess.run([str(bin_dir / 'horizon-ctl'), '--socket', str(socket), '--timeout', '600',
+                                     *map(str, words)], cwd=folder, env=env, capture_output=True, text=True)
+            if check and result.returncode:
+                sys.exit(f'horizon-ctl {" ".join(map(str, words))} failed: {result.stdout}{result.stderr}')
+            return json.loads(result.stdout) if result.stdout.strip().startswith('{') else result.stdout
+
+        ctl('launch', '--resources', RESOURCES, '--world', 'world', '--render-distance', '4', *flags, *extra)
+        try:
+            ctl('wait-ready', '300')
+            slots = ctl('container', *CHEST)['slots']
+        finally:
+            ctl('quit', check=False)
+        got = sorted((slot, stack['item'], stack['count']) for slot, stack in enumerate(slots) if stack)
+        ok = got == expected
+        failures += not ok
+        print(f'{mode}: {len(got)} stacks', 'ok' if ok else f'FAIL: {got}')
+    if not args.keep and not failures:
+        shutil.rmtree(RUN, ignore_errors=True)
+    print('spawn loot:', 'PASS' if not failures else f'{failures} FAILED')
+    sys.exit(1 if failures else 0)
+
+
+if __name__ == '__main__':
+    main()

From cfd2dc83922ce606c518b085443d634f3931b23e Mon Sep 17 00:00:00 2001
From: Senjin <senjin@hatchling.org>
Date: Mon, 26 Oct 2026 16:45:57 +0100
Subject: [PATCH 140/475] HDR: present HDR10 (PQ) where the surface offers it,
 scRGB otherwise

HDR10 is what games usually present and what the display receives: a
compositor composes in it or converts to it anyway. The NVIDIA driver
offers it on Wayland next to scRGB. A 10-bit swapchain also halves the
last pass's bandwidth; the frame before it is 8-bit, so nothing is lost.

hdr.wgsl converts the same linear light to BT.2020 (BT.2087) and encodes
it with the ST 2084 curve. HORIZON_HDR_OUTPUT=pq or scrgb allows only
that one, for comparing them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/gfx.rs      | 34 ++++-----
 crates/horizon-client/src/gfx/hdr.rs  | 99 +++++++++++++++++++++++----
 crates/horizon-client/src/graphics.rs |  2 +-
 crates/horizon-client/src/hdr.wgsl    | 25 ++++++-
 docs/graphics.md                      |  2 +-
 5 files changed, 127 insertions(+), 35 deletions(-)

diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index 904370c04..86df94c0c 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -505,10 +505,10 @@ pub struct Renderer {
     occlusion: occlusion::Occlusion,
     /// Resolution scale and FXAA (Horizon settings).
     world_post: world_post::Post,
-    /// HDR output (Horizon setting): `Some` while the swapchain is scRGB.
+    /// HDR output (Horizon setting): `Some` while the swapchain is HDR.
     hdr: Option<hdr::Hdr>,
-    /// Whether the window's surface can present scRGB.
-    hdr_capable: bool,
+    /// The HDR output the window's surface can present.
+    hdr_output: Option<hdr::Output>,
     /// The shader pack's post-processing, and the dimension (legacy id) it was loaded for.
     pack_post: Option<(i32, Option<pack_post::PackPost>)>,
     /// The post passes of one of Horizon's own shader packs; never beside `pack_post`'s.
@@ -1057,7 +1057,7 @@ impl Renderer {
         let info = adapter.get_info();
         crate::graphics::suggest_reduced_far_detail(crate::graphics::lod_capped(&info));
         let size = window.inner_size();
-        let (config, present_modes, hdr_capable) = if let Some(surface) = &surface {
+        let (config, present_modes, hdr_output) = if let Some(surface) = &surface {
             let mut config = surface
                 .get_default_config(&adapter, size.width.max(1), size.height.max(1))
                 .ok_or("surface has no supported configuration")?;
@@ -1085,7 +1085,7 @@ impl Renderer {
                 ));
             }
             surface.configure(&device, &config);
-            (config, caps.present_modes.clone(), hdr::supported(&caps))
+            (config, caps.present_modes.clone(), hdr::output(&caps))
         } else {
             let format = wgpu::TextureFormat::Bgra8Unorm;
             let config = wgpu::SurfaceConfiguration {
@@ -1099,7 +1099,7 @@ impl Renderer {
                 view_formats: vec![format],
                 color_space: wgpu::SurfaceColorSpace::default(),
             };
-            (config, Vec::new(), false)
+            (config, Vec::new(), None)
         };
         let offscreen = surface
             .is_none()
@@ -2441,7 +2441,7 @@ impl Renderer {
             occlusion: occlusion::Occlusion::new(crate::chunk::MIN_Y, crate::chunk::HEIGHT / 16),
             world_post,
             hdr: None,
-            hdr_capable,
+            hdr_output,
             pack_post: None,
             native: None,
             pass_timing: pack_timing::PassTiming::logging(),
@@ -2961,24 +2961,24 @@ impl Renderer {
         }
     }
     /// The swapchain's configuration: `config` (what every pipeline draws in), or
-    /// scRGB while HDR output is on.
+    /// HDR10 or scRGB while HDR output is on.
     fn surface_config(&self) -> wgpu::SurfaceConfiguration {
         let mut config = self.config.clone();
-        if self.hdr.is_some() {
-            config.format = hdr::FORMAT;
-            config.view_formats = vec![hdr::FORMAT];
-            config.color_space = hdr::COLOR_SPACE;
+        if let Some(hdr) = &self.hdr {
+            config.format = hdr.output.format();
+            config.view_formats = vec![hdr.output.format()];
+            config.color_space = hdr.output.color_space();
             config.usage = wgpu::TextureUsages::RENDER_ATTACHMENT;
         }
         config
     }
-    /// HDR output (Horizon setting): scRGB at `paper_white` nits, the world's
+    /// HDR output (Horizon setting): HDR10 or scRGB at `paper_white` nits, the world's
     /// highlights expanded up to `peak` nits. Off where the surface can't present it.
     pub fn set_hdr(&mut self, on: bool, paper_white: f32, peak: f32) {
-        let on = on && self.hdr_capable && self.surface.is_some();
-        if on != self.hdr.is_some() {
-            self.hdr =
-                on.then(|| hdr::Hdr::new(&self.device, self.config.format.remove_srgb_suffix()));
+        let output = self.hdr_output.filter(|_| on && self.surface.is_some());
+        if output.is_some() != self.hdr.is_some() {
+            let format = self.config.format.remove_srgb_suffix();
+            self.hdr = output.map(|output| hdr::Hdr::new(&self.device, format, output));
             self.configure_surface();
         }
         if let Some(hdr) = &mut self.hdr
diff --git a/crates/horizon-client/src/gfx/hdr.rs b/crates/horizon-client/src/gfx/hdr.rs
index 11deed546..8b9df7af0 100644
--- a/crates/horizon-client/src/gfx/hdr.rs
+++ b/crates/horizon-client/src/gfx/hdr.rs
@@ -1,17 +1,50 @@
 //! HDR output (Horizon setting, off by default): the frame renders exactly as
 //! without it, into an 8-bit target in vanilla's gamma space, and one pass
-//! (`hdr.wgsl`) writes it to an scRGB swapchain at the player's paper white,
-//! expanding the world's highlights towards their peak brightness. The world
-//! is copied aside before the hand and HUD so only it is expanded.
+//! (`hdr.wgsl`) writes it to an HDR10 or scRGB swapchain at the player's paper
+//! white, expanding the world's highlights towards their peak brightness. The
+//! world is copied aside before the hand and HUD so only it is expanded.
 
-/// The swapchain format and colour space HDR output presents in.
-pub const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
-pub const COLOR_SPACE: wgpu::SurfaceColorSpace = wgpu::SurfaceColorSpace::ExtendedSrgbLinear;
+/// The swapchain HDR output presents to.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Output {
+    /// HDR10: 10-bit BT.2020 with the PQ curve, the display's own signal.
+    Pq,
+    /// scRGB: linear 16-bit float, BT.709 primaries, 1.0 = 80 nits.
+    ScRgb,
+}
 
-/// Whether `caps` can present scRGB.
-pub fn supported(caps: &wgpu::SurfaceCapabilities) -> bool {
-    caps.color_spaces(FORMAT)
-        .contains(wgpu::SurfaceColorSpaces::EXTENDED_SRGB_LINEAR)
+impl Output {
+    pub fn format(self) -> wgpu::TextureFormat {
+        match self {
+            Self::Pq => wgpu::TextureFormat::Rgb10a2Unorm,
+            Self::ScRgb => wgpu::TextureFormat::Rgba16Float,
+        }
+    }
+    pub fn color_space(self) -> wgpu::SurfaceColorSpace {
+        match self {
+            Self::Pq => wgpu::SurfaceColorSpace::Bt2100Pq,
+            Self::ScRgb => wgpu::SurfaceColorSpace::ExtendedSrgbLinear,
+        }
+    }
+    fn space(self) -> wgpu::SurfaceColorSpaces {
+        match self {
+            Self::Pq => wgpu::SurfaceColorSpaces::BT2100_PQ,
+            Self::ScRgb => wgpu::SurfaceColorSpaces::EXTENDED_SRGB_LINEAR,
+        }
+    }
+}
+
+/// The HDR output `caps` can present: HDR10 where offered, else scRGB.
+/// `HORIZON_HDR_OUTPUT=pq` or `scrgb` allows only that one.
+pub fn output(caps: &wgpu::SurfaceCapabilities) -> Option<Output> {
+    pick(caps, std::env::var("HORIZON_HDR_OUTPUT").ok().as_deref())
+}
+fn pick(caps: &wgpu::SurfaceCapabilities, only: Option<&str>) -> Option<Output> {
+    [(Output::Pq, "pq"), (Output::ScRgb, "scrgb")]
+        .into_iter()
+        .filter(|(_, name)| only.is_none_or(|o| o == *name))
+        .map(|(output, _)| output)
+        .find(|o| caps.color_spaces(o.format()).contains(o.space()))
 }
 
 struct Targets {
@@ -25,6 +58,7 @@ pub struct Hdr {
     layout: wgpu::BindGroupLayout,
     pipeline: wgpu::RenderPipeline,
     params: wgpu::Buffer,
+    pub output: Output,
     /// The frame's format: what every other pipeline draws in.
     format: wgpu::TextureFormat,
     targets: Option<Targets>,
@@ -36,7 +70,7 @@ pub struct Hdr {
 }
 
 impl Hdr {
-    pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
+    pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat, output: Output) -> Self {
         let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some("Horizon HDR"),
             source: wgpu::ShaderSource::Wgsl(include_str!("../hdr.wgsl").into()),
@@ -90,7 +124,7 @@ impl Hdr {
                 entry_point: Some("fs_hdr"),
                 compilation_options: Default::default(),
                 targets: &[Some(wgpu::ColorTargetState {
-                    format: FORMAT,
+                    format: output.format(),
                     blend: None,
                     write_mask: wgpu::ColorWrites::ALL,
                 })],
@@ -100,7 +134,7 @@ impl Hdr {
         });
         let params = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Horizon HDR parameters"),
-            size: 16,
+            size: 32,
             usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
             mapped_at_creation: false,
         });
@@ -108,6 +142,7 @@ impl Hdr {
             layout,
             pipeline,
             params,
+            output,
             format,
             targets: None,
             debug: std::env::var_os("HORIZON_HDR_DEBUG").is_some_and(|v| v == "1"),
@@ -198,6 +233,10 @@ impl Hdr {
             (self.peak / paper).max(1.0),
             f32::from(u8::from(world)),
             f32::from(u8::from(self.debug)),
+            f32::from(u8::from(self.output == Output::Pq)),
+            0.0,
+            0.0,
+            0.0,
         ];
         queue.write_buffer(&self.params, 0, bytemuck::cast_slice(&params));
         let view = target.create_view(&Default::default());
@@ -220,3 +259,37 @@ impl Hdr {
         pass.draw(0..3, 0..1);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{Output, pick};
+    use wgpu::{SurfaceColorSpaces as S, TextureFormat as F};
+
+    fn caps(offered: &[(F, S)]) -> wgpu::SurfaceCapabilities {
+        wgpu::SurfaceCapabilities {
+            format_capabilities: offered
+                .iter()
+                .map(|&(format, color_spaces)| wgpu::SurfaceFormatCapabilities {
+                    format,
+                    color_spaces,
+                })
+                .collect(),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn hdr10_first_then_scrgb() {
+        let both = caps(&[
+            (F::Bgra8UnormSrgb, S::SRGB),
+            (F::Rgb10a2Unorm, S::BT2100_PQ | S::BT2100_HLG),
+            (F::Rgba16Float, S::EXTENDED_SRGB_LINEAR),
+        ]);
+        assert_eq!(pick(&both, None), Some(Output::Pq));
+        assert_eq!(pick(&both, Some("scrgb")), Some(Output::ScRgb));
+        let scrgb = caps(&[(F::Rgba16Float, S::EXTENDED_SRGB_LINEAR)]);
+        assert_eq!(pick(&scrgb, None), Some(Output::ScRgb));
+        assert_eq!(pick(&scrgb, Some("pq")), None);
+        assert_eq!(pick(&caps(&[(F::Bgra8UnormSrgb, S::SRGB)]), None), None);
+    }
+}
diff --git a/crates/horizon-client/src/graphics.rs b/crates/horizon-client/src/graphics.rs
index 4f6f04bc0..7a2f5e225 100644
--- a/crates/horizon-client/src/graphics.rs
+++ b/crates/horizon-client/src/graphics.rs
@@ -255,7 +255,7 @@ pub struct Graphics {
     pub resolution_scale: u32,
     /// FXAA over the world.
     pub fxaa: bool,
-    /// HDR output (scRGB), where the display path offers it.
+    /// HDR output (HDR10, or scRGB), where the display path offers it.
     pub hdr: bool,
     /// HDR paper white (where SDR white sits), in nits.
     pub hdr_paper_white: u32,
diff --git a/crates/horizon-client/src/hdr.wgsl b/crates/horizon-client/src/hdr.wgsl
index bf6c27cca..8f6c25d12 100644
--- a/crates/horizon-client/src/hdr.wgsl
+++ b/crates/horizon-client/src/hdr.wgsl
@@ -1,6 +1,6 @@
 // Horizon's HDR output pass: the frame, drawn as without HDR in vanilla's gamma
-// space, decoded to linear light at the paper white and written to the scRGB
-// swapchain (1.0 = 80 nits). Bright pixels of light sources that still show the
+// space, decoded to linear light at the paper white and written to the swapchain:
+// HDR10 (BT.2020, PQ) or scRGB (1.0 = 80 nits). Bright pixels of light sources that still show the
 // world as it was before the hand and HUD are expanded towards the peak.
 @group(0) @binding(0) var frame: texture_2d<f32>;
 @group(0) @binding(1) var world: texture_2d<f32>;
@@ -14,6 +14,8 @@ struct Params {
     world: f32,
     // 1 paints expanded pixels magenta (HORIZON_HDR_DEBUG=1).
     debug: f32,
+    // 1 for an HDR10 swapchain, 0 for scRGB.
+    pq: f32,
 };
 @group(0) @binding(2) var<uniform> params: Params;
 
@@ -40,6 +42,19 @@ fn shows_world(c: vec3<f32>, w: vec3<f32>) -> bool {
     return mean <= 1.01 && mean > 0.5 && all(abs(k - vec3(mean)) < vec3(0.03));
 }
 
+// Linear BT.709 to BT.2020 (ITU-R BT.2087), columns first.
+const BT709_TO_BT2020 = mat3x3<f32>(
+    vec3(0.6274, 0.0691, 0.0164),
+    vec3(0.3293, 0.9195, 0.0880),
+    vec3(0.0433, 0.0114, 0.8956),
+);
+
+// SMPTE ST 2084: nits (up to 10000) to the PQ signal.
+fn pq(nits: vec3<f32>) -> vec3<f32> {
+    let y = pow(clamp(nits / 10000.0, vec3(0.0), vec3(1.0)), vec3(0.1593017578125));
+    return pow((0.8359375 + 18.8515625 * y) / (1.0 + 18.6875 * y), vec3(78.84375));
+}
+
 @vertex fn vs_hdr(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
     let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
     return vec4(p * 2.0 - 1.0, 0.0, 1.0);
@@ -65,5 +80,9 @@ fn shows_world(c: vec3<f32>, w: vec3<f32>) -> bool {
             }
         }
     }
-    return vec4(light * params.paper, 1.0);
+    let scrgb = light * params.paper;
+    if params.pq > 0.5 {
+        return vec4(pq(BT709_TO_BT2020 * scrgb * 80.0), 1.0);
+    }
+    return vec4(scrgb, 1.0);
 }
diff --git a/docs/graphics.md b/docs/graphics.md
index dcba29773..79c969d90 100644
--- a/docs/graphics.md
+++ b/docs/graphics.md
@@ -29,7 +29,7 @@ Every row has a one-line description and its cost in frame time (none, low, medi
 
 **Battery mode** (Performance, off by default) is for laptops and handhelds: at most 60 frames per second in a world, 30 in menus without a world or while another window has focus, and half the automatic worker threads (chunks load slower). It changes only when frames are drawn: what they show and the game's 20 ticks per second stay as they are.
 
-**HDR** (Display, off by default) presents to an scRGB swapchain (`Rgba16Float`, extended linear sRGB) on displays and compositors that offer it. The frame is drawn exactly as in SDR, in vanilla's gamma space, 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, mastering luminance), which wgpu doesn't: without it a compositor may clip everything above SDR white. KWin maps the content's reference white onto the desktop's SDR brightness, so on Linux the default Paper White matches SDR mode. `HORIZON_HDR_DEBUG=1` paints lifted pixels magenta. Not lifted yet: glowing particles, distant LOD terrain.
+**HDR** (Display, off by default) 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. The frame is drawn exactly as in SDR, in vanilla's gamma space, 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, mastering luminance), which wgpu doesn't: without it a compositor may clip everything above SDR white. KWin maps the content's reference white onto the desktop's SDR brightness, so on Linux the default Paper White matches SDR mode. `HORIZON_HDR_DEBUG=1` paints lifted pixels magenta. Not lifted yet: glowing particles, distant LOD terrain.
 
 Which settings each screen shows, their descriptions and costs are in `crates/horizon-client/src/graphics_ui.rs` (`rows`); `graphics_style.rs` draws them.
 

From 49ad61035b285c0d24bca0cde1027fd3bf60b41e Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:47:11 +0100
Subject: [PATCH 141/475] Count shield damage only for accepted hits and skip
 kills saved by a totem

---
 crates/horizon-client/src/game/combat.rs  | 5 ++++-
 crates/horizon-client/src/game/lan_pvp.rs | 4 +++-
 crates/horizon-client/src/game/shield.rs  | 7 -------
 3 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs
index 197c77f17..fee887f97 100644
--- a/crates/horizon-client/src/game/combat.rs
+++ b/crates/horizon-client/src/game/combat.rs
@@ -74,11 +74,14 @@ impl Game<'_> {
         for e in events {
             let (name, amount) = match e {
                 // LivingEntity.getDamageAfterMagicAbsorb (Resistance) and
-                // Player.actuallyHurt (absorption hearts), in tenths.
+                // Player.actuallyHurt (absorption hearts) and
+                // LivingEntity.hurtServer (the shield, only for an accepted
+                // hit), in tenths.
                 MotionEvent::Health(HealthEvent::Statistic { name, amount }) => {
                     match *name {
                         "resisted" => self.stats.custom("damage_resisted", *amount),
                         "absorbed" => self.stats.custom("damage_absorbed", *amount),
+                        "blocked" => self.stats.custom("damage_blocked_by_shield", *amount),
                         _ => {}
                     }
                     continue;
diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs
index a2ff13444..276a33c83 100644
--- a/crates/horizon-client/src/game/lan_pvp.rs
+++ b/crates/horizon-client/src/game/lan_pvp.rs
@@ -256,10 +256,12 @@ impl Game<'_> {
         // ServerPlayer.awardKillScore: the blow that kills a player.
         if hurt {
             let died = match victim {
+                // A totem that fired is applied on the next tick_totem, so the
+                // host is still at zero health but is not dying.
                 Victim::Host => self
                     .player
                     .as_ref()
-                    .is_some_and(|p| p.health.dead_or_dying()),
+                    .is_some_and(|p| p.health.dead_or_dying() && !p.health.totem_used),
                 Victim::Guest(conn) => host
                     .hub
                     .guest(conn)
diff --git a/crates/horizon-client/src/game/shield.rs b/crates/horizon-client/src/game/shield.rs
index f4642f272..c4f7f98d1 100644
--- a/crates/horizon-client/src/game/shield.rs
+++ b/crates/horizon-client/src/game/shield.rs
@@ -121,13 +121,6 @@ impl Game<'_> {
         attacker: Option<u32>,
         projectile: bool,
     ) {
-        // LivingEntity.hurtServer: the damage the shield took, in tenths.
-        if outcome.blocked > 0.0 {
-            self.stats.custom(
-                "damage_blocked_by_shield",
-                (outcome.blocked * 10.0).round() as i32,
-            );
-        }
         let Some((slot, _)) = self.using else { return };
         let Some(stack) = self.stack_in(slot).cloned() else {
             return;

From 36ef05b0b9470051b8a5e9e01ce0ba4811a30e0a Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 16:51:22 +0100
Subject: [PATCH 142/475] Keep infinite mob effects through the effect tick

---
 crates/horizon-client/src/mobs/ai.rs | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 8335cb745..68d5caee5 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -1455,25 +1455,31 @@ fn tick_effects(m: &mut Mob) {
     let mut effects = std::mem::take(&mut m.extra.effects);
     for (effect, ticks, amp) in &mut effects {
         let interval = |base: i32| (base >> (*amp).max(0)).max(1);
+        // MobEffectInstance.tickServer: an infinite (-1) effect times its
+        // ticks by the mob's tickCount and never counts down.
+        let infinite = *ticks == -1;
+        let count = if infinite { m.age as i32 } else { *ticks };
         match *effect {
             "minecraft:poison"
-                if *ticks % interval(25) == 0 && !m.kind.flags.undead && m.health > 1.0 =>
+                if count % interval(25) == 0 && !m.kind.flags.undead && m.health > 1.0 =>
             {
                 m.damage(1.0, Damage::of(DamageKind::Magic));
             }
-            "minecraft:wither" if *ticks % interval(40) == 0 => {
+            "minecraft:wither" if count % interval(40) == 0 => {
                 m.damage(1.0, Damage::of(DamageKind::Magic));
             }
             "minecraft:regeneration"
-                if *ticks % interval(50) == 0 && !m.kind.flags.undead && m.alive() =>
+                if count % interval(50) == 0 && !m.kind.flags.undead && m.alive() =>
             {
                 m.health = (m.health + 1.0).min(m.attrs.max_health);
             }
             _ => {}
         }
-        *ticks -= 1;
+        if !infinite {
+            *ticks -= 1;
+        }
     }
-    effects.retain(|e| e.1 > 0);
+    effects.retain(|e| e.1 > 0 || e.1 == -1);
     m.extra.effects = effects;
 }
 

From 5d3e9d218dc9a74b712a91d0fe504b0ca532852d Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 17:05:35 +0100
Subject: [PATCH 143/475] Clean copper for a skeleton trap's visual lightning
 too

---
 crates/horizon-client/src/game/lightning.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs
index 55e867f87..7daab2ef8 100644
--- a/crates/horizon-client/src/game/lightning.rs
+++ b/crates/horizon-client/src/game/lightning.rs
@@ -221,6 +221,12 @@ impl Game<'_> {
                 if !b.visual_only {
                     self.bolt_fire(b.at, 4);
                     self.strike_rod(b.at);
+                }
+                // LightningBolt.tick runs clearCopperOnLightningStrike for
+                // every server bolt, a skeleton trap's visual one included;
+                // a client's copy of a server bolt (spawn_remote_bolt) only
+                // flashes.
+                if self.remote.is_none() {
                     self.bolt_clear_copper(b.at);
                 }
             }

From 96984300d380c7dffba31cdc991bde8e332502f3 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 17:07:20 +0100
Subject: [PATCH 144/475] mods: the UI guest's level is 3 now that world is
 level 4

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-mods/tests/sandbox.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs
index 1d4297ba3..a5e95ddfa 100644
--- a/crates/horizon-mods/tests/sandbox.rs
+++ b/crates/horizon-mods/tests/sandbox.rs
@@ -255,8 +255,8 @@ experimental = ["ui", "render", "input"]
         needed(imports(&wasm).unwrap().iter().map(String::as_str)).0
     };
     assert_eq!(level("coords_hud.hmod"), 0);
-    // The UI guest shows a minimap (`render.set-minimap`).
-    assert_eq!(level("horizon_mods_test_ui_guest.hmod"), LEVEL);
+    // The UI guest runs quiet commands (`command.run-quiet`, level 3).
+    assert_eq!(level("horizon_mods_test_ui_guest.hmod"), 3);
 }
 
 #[test]

From ba3b567f54ef63c6c3d00d93b9a81c04e80a411e Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 17:15:29 +0100
Subject: [PATCH 145/475] Predict a full beehive reacting to shears and glass
 bottles on the client

---
 crates/horizon-client/src/game/remote.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 857f955da..b0a466d9d 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -4084,6 +4084,16 @@ impl Game<'_> {
         if self.keys.contains(&KeyCode::ShiftLeft) && hands_full {
             return (false, DryUse::default());
         }
+        // BeehiveBlock.useItemOn: shears or a glass bottle on a full hive
+        // (honey level 5) is SUCCESS, so the click ends after UseItemOn and
+        // no UseItem follows (the server does the harvest, see `use_beehive`).
+        if held.is_some_and(|s| matches!(&*s.item, "minecraft:shears" | "minecraft:glass_bottle"))
+            && self
+                .hive_state(hit.pos)
+                .is_some_and(|(honey, _)| honey == Some(5))
+        {
+            return (true, DryUse::default());
+        }
         use horizon_core::geometry::Direction;
         let face = match hit.face {
             [0, 1, 0] => Direction::Up,

From b62095dfcb58d5bd3b77bd40b1cdea70e4766de4 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 17:25:37 +0100
Subject: [PATCH 146/475] Run the trident player_hurt_entity trigger as the
 thrower

---
 crates/horizon-client/src/game/trident.rs | 27 ++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs
index 04a1be415..74525e69a 100644
--- a/crates/horizon-client/src/game/trident.rs
+++ b/crates/horizon-client/src/game/trident.rs
@@ -30,6 +30,8 @@ pub(super) struct ThrownTrident {
     pub(super) no_physics: bool,
     returning: u32,
     creative_only: bool,
+    /// The guest that threw it (`Projectile.getOwner`); `None` for the host.
+    guest: Option<u32>,
 }
 impl ThrownTrident {
     /// A trident a server sent (`handleAddEntity`): placed and moved by it.
@@ -49,6 +51,7 @@ impl ThrownTrident {
             no_physics: false,
             returning: 0,
             creative_only: false,
+            guest: None,
         }
     }
     /// One tick of a server's client: the previous position, then `step`.
@@ -240,11 +243,33 @@ impl Game<'_> {
             no_physics: false,
             returning: 0,
             creative_only: self.creative,
+            guest: self.lan_acting,
         });
         self.player_projectile_shot();
         self.audio
             .play("minecraft:item.trident.throw", at, 1.0, 1.0);
     }
+    /// The thrower's `PLAYER_HURT_ENTITY` for a trident hit: run as the
+    /// guest that threw it, and not at all once they have left.
+    fn thrower_hit(
+        &mut self,
+        guest: Option<u32>,
+        victim: &horizon_client::advancements::EntityView,
+        direct: horizon_client::advancements::EntityView,
+        damage: f32,
+    ) {
+        let Some(conn) = guest.filter(|c| self.lan_acting != Some(*c)) else {
+            self.player_hit(victim, "minecraft:trident", Some(direct), damage);
+            return;
+        };
+        let Some(mut host) = self.lan.take() else {
+            return;
+        };
+        self.as_guest(&mut host, conn, |g| {
+            g.player_hit(victim, "minecraft:trident", Some(direct), damage)
+        });
+        self.lan = Some(host);
+    }
     pub(super) fn tick_tridents(&mut self) {
         let Some(eye) = self.eye_position() else {
             return;
@@ -331,7 +356,7 @@ impl Game<'_> {
                             position: [t.position.x, t.position.y, t.position.z],
                             ..Default::default()
                         };
-                        self.player_hit(&victim, "minecraft:trident", Some(direct), damage);
+                        self.thrower_hit(t.guest, &victim, direct, damage);
                     }
                     self.audio.play(
                         "minecraft:item.trident.hit",

From e50eb7c71f5e5e7e7b27e2d8047f136e90f0ddc7 Mon Sep 17 00:00:00 2001
From: Carlos Nunez <carlosnunez01010@gmail.com>
Date: Mon, 26 Oct 2026 12:36:46 -0400
Subject: [PATCH 147/475] Count leave_game for every player who leaves, owner
 included

Vanilla's PlayerList.remove awards Stats.LEAVE_GAME to a player before
saving them, and PlayerList.removeAll does it for everyone when the
server stops. Horizon only counted it in the in-frame path, so on the
default server thread the owner never got it, and guests who left or
were removed at shutdown did not either.

LanHost::award_leave_game counts it once per guest (a guest is saved
more than once on the way out) and runs where a guest leaves, when the
integrated server stops, and when LAN closes.

Part of #2095 (item 4 of the report). The signal handling and the
remote-world disconnect are #2116's.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/integrated.rs  |  2 ++
 crates/horizon-client/src/game/lan.rs         | 31 +++++++++++++++++++
 crates/horizon-client/src/game/lan_actions.rs |  3 ++
 3 files changed, 36 insertions(+)

diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs
index dd1c04e23..6758c7c89 100644
--- a/crates/horizon-client/src/game/integrated.rs
+++ b/crates/horizon-client/src/game/integrated.rs
@@ -408,6 +408,8 @@ impl Game<'_> {
             s.flags.published.store(0, Ordering::Relaxed);
         }
         if let Some(mut host) = self.lan.take() {
+            // PlayerList.removeAll: the owner and every guest leave the game.
+            host.award_leave_game_to_all();
             for g in &host.hub.guests {
                 self.save_guest(&host, g);
             }
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 9f468db9f..9226240bd 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -78,6 +78,33 @@ pub(super) struct LanHost {
     states: lan::entity::States,
 }
 
+impl LanHost {
+    /// `PlayerList.remove`: `player.awardStat(Stats.LEAVE_GAME)` before the
+    /// player is saved. Once per guest, however often they are saved.
+    pub(super) fn award_leave_game(&mut self, conn: u32) {
+        if let Some(play) = self.play.get_mut(&conn)
+            && !play.left_game
+        {
+            play.left_game = true;
+            play.stats.custom("leave_game", 1);
+        }
+    }
+
+    /// `PlayerList.removeAll`: every player who joined leaves with the world.
+    pub(super) fn award_leave_game_to_all(&mut self) {
+        let conns: Vec<u32> = self
+            .hub
+            .guests
+            .iter()
+            .filter(|g| g.placed)
+            .map(|g| g.conn)
+            .collect();
+        for conn in conns {
+            self.award_leave_game(conn);
+        }
+    }
+}
+
 /// The player who owns an integrated server's world: a guest whose state is
 /// the world's own player (`players/data/<singleplayer_uuid>.dat`), as in
 /// single player.
@@ -634,6 +661,7 @@ impl Game<'_> {
         let Some(mut host) = self.lan.take() else {
             return;
         };
+        host.award_leave_game_to_all();
         for g in &host.hub.guests {
             self.save_guest(&host, g);
         }
@@ -1016,6 +1044,9 @@ impl Game<'_> {
                             }
                         }
                         self.lan_crafting_left(&mut host, &mut guest);
+                        if guest.placed {
+                            host.award_leave_game(guest.conn);
+                        }
                         self.save_guest(&host, &guest);
                         host.models.remove(&guest.conn);
                         host.play.remove(&guest.conn);
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index e1a13881c..dffb0177e 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -74,6 +74,9 @@ pub(super) struct GuestPlay {
     potions: super::potions::BodyPotions,
     /// `ServerPlayer.getStats` and the inventory `inventory_changed` last saw.
     pub(super) stats: super::stats::Stats,
+    /// `Stats.LEAVE_GAME` is counted: a guest is saved more than once on the
+    /// way out, the statistic is awarded once (`LanHost::award_leave_game`).
+    pub(super) left_game: bool,
     last_inventory: u64,
     /// `Entity.portalProcess` and `portalCooldown` (game/server_travel.rs).
     pub(super) portal: horizon_client::nether_portal::PortalState,

From 2a98f584dfaf78561ffde4643b4e20fc8fe1d9a7 Mon Sep 17 00:00:00 2001
From: Eshayat Al-Wasiu <eshayat.wasiu@gmail.com>
Date: Mon, 26 Oct 2026 22:40:12 +0600
Subject: [PATCH 148/475] Send cushion breaking particles to nearby multiplayer
 clients

Co-Authored-By: Codex <noreply@openai.com>
---
 crates/horizon-client/src/game.rs          |  2 +
 crates/horizon-client/src/game/cushions.rs | 24 +++---
 crates/horizon-client/src/game/lan.rs      | 29 ++++++++
 tests/test_cushion_particles.py            | 87 ++++++++++++++++++++++
 tools/lan_e2e.py                           |  6 ++
 5 files changed, 135 insertions(+), 13 deletions(-)
 create mode 100644 tests/test_cushion_particles.py

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 755a00f6f..f05be393a 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -1584,6 +1584,7 @@ struct Game<'a> {
     guest_use: Option<GuestUse>,
     /// Level events of this tick for the guests, and the guest acting now.
     lan_events: Vec<(i32, [i32; 3], i32, Option<u32>)>,
+    lan_cushion_breaks: Vec<(horizon_world::registry::BlockStateId, [f64; 3])>,
     /// Block events (position, b0, b1, state) and entity events (id, event,
     /// position) for the guests.
     lan_block_events: Vec<([i32; 3], i32, i32, u32)>,
@@ -12477,6 +12478,7 @@ impl<'a> Game<'a> {
             forced_hit: None,
             guest_use: None,
             lan_events: Vec::new(),
+            lan_cushion_breaks: Vec::new(),
             lan_block_events: Vec::new(),
             lan_entity_events: Vec::new(),
             lan_critical_hits: Vec::new(),
diff --git a/crates/horizon-client/src/game/cushions.rs b/crates/horizon-client/src/game/cushions.rs
index 0847321d6..30af72104 100644
--- a/crates/horizon-client/src/game/cushions.rs
+++ b/crates/horizon-client/src/game/cushions.rs
@@ -348,11 +348,15 @@ impl Game<'_> {
         let Some(state) = self.pack.assets.registry.default_state(&name) else {
             return;
         };
-        let at = [
-            c.position.x.floor() as i32,
-            c.position.y.floor() as i32,
-            c.position.z.floor() as i32,
-        ];
+        let p = c.position;
+        // Entity.getY(2/3) is relative to the cushion's quarter-block height.
+        let particle_at = [p.x, p.y + 0.25 * (2.0 / 3.0), p.z];
+        // Guest actions temporarily take self.lan; flush once the hub is back.
+        // Queue before resolving a sprite: a dedicated server has no renderer.
+        if self.audio.capture.is_some() {
+            self.lan_cushion_breaks.push((state, particle_at));
+        }
+        let at = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32];
         let Some((sprite, tint)) = self.particle_sprite(state, at) else {
             return;
         };
@@ -361,14 +365,8 @@ impl Game<'_> {
             sprite,
             tint,
         );
-        let p = c.position;
-        self.particles.send_particles(
-            &options,
-            [p.x, p.y + 0.666_666_7, p.z],
-            [0.25, 0.0625, 0.25],
-            0.05,
-            10,
-        );
+        self.particles
+            .send_particles(&options, particle_at, [0.25, 0.0625, 0.25], 0.05, 10);
     }
 
     /// `BlockAttachedEntity.tick`: survive and burn checks after the post-increment reaches 100.
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 63aea7e9f..75500ba79 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -21,6 +21,7 @@ use horizon_core::geometry::Vec3;
 use horizon_protocol::{
     crypto::offline_uuid,
     entity_data::{Value, serializer},
+    packets::play::{self, Clientbound as C},
 };
 use std::{
     collections::HashMap,
@@ -665,6 +666,7 @@ impl Game<'_> {
         self.audio.capture = None;
         self.lan_events.clear();
         self.lan_critical_hits.clear();
+        self.lan_cushion_breaks.clear();
         self.streaming.extra.clear();
         if announce {
             self.system_message(Text::translate(
@@ -1229,6 +1231,33 @@ impl Game<'_> {
     /// Send the tick's level events, sounds and mob animations.
     fn lan_flush_effects(&mut self, host: &mut LanHost) {
         let critical_hits = std::mem::take(&mut self.lan_critical_hits);
+        for (state, at) in std::mem::take(&mut self.lan_cushion_breaks) {
+            if let Some(id) = host
+                .hub
+                .registry_id("minecraft:particle_type", "minecraft:block")
+            {
+                host.hub.broadcast_near(
+                    at,
+                    32.0,
+                    &C::LevelParticles(play::LevelParticles {
+                        particle: horizon_protocol::entity_data::Particle {
+                            id,
+                            data: Some(horizon_protocol::entity_data::ParticleData::State(
+                                state.0 as i32,
+                            )),
+                        },
+                        override_limiter: false,
+                        always_show: false,
+                        pos: at,
+                        dist: [0.25, 0.0625, 0.25],
+                        max_speed: [0.05; 3],
+                        count: 10,
+                        randomization: 0,
+                    }),
+                    None,
+                );
+            }
+        }
         for (kind, pos, data, acting) in std::mem::take(&mut self.lan_events) {
             if kind == 2001 {
                 host.broken
diff --git a/tests/test_cushion_particles.py b/tests/test_cushion_particles.py
new file mode 100644
index 000000000..adfbf2e00
--- /dev/null
+++ b/tests/test_cushion_particles.py
@@ -0,0 +1,87 @@
+"""Cushion particles must reach clients even when the server has no sprite atlas."""
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+@unittest.skipUnless(shutil.which("rustc"), "requires Rust")
+class CushionParticlesTests(unittest.TestCase):
+    def test_headless_server_records_break_effect_before_sprite_lookup(self):
+        source = (ROOT / "crates/horizon-client/src/game/cushions.rs").read_text()
+        start = source.index("    fn cushion_break_particles(")
+        end = source.index("    /// `BlockAttachedEntity.tick`", start)
+        fixture = r'''
+#![allow(dead_code)]
+#[derive(Clone, Copy)]
+struct Vec3 { x: f64, y: f64, z: f64 }
+struct Cushion { position: Vec3 }
+impl Cushion { fn color_name(&self) -> &str { "blue" } }
+struct Registry;
+impl Registry {
+    fn default_state(&self, name: &str) -> Option<u32> {
+        assert_eq!(name, "minecraft:blue_wool"); Some(123)
+    }
+}
+struct Assets { registry: Registry }
+struct Pack { assets: Assets }
+struct Audio { capture: Option<()> }
+mod horizon_client { pub mod particles {
+    pub enum ParticleType { Block }
+    pub struct ParticleOptions;
+    impl ParticleOptions {
+        pub fn block(_: ParticleType, _: String, _: u32) -> Self { Self }
+    }
+} }
+#[derive(Default)]
+struct Particles { count: u32 }
+impl Particles {
+    fn send_particles(&mut self, _: &horizon_client::particles::ParticleOptions,
+        at: [f64; 3], spread: [f64; 3], speed: f64, count: u32) {
+        assert!((at[1] - (10.0 + 1.0/6.0)).abs() < 1e-12);
+        assert_eq!(spread, [0.25, 0.0625, 0.25]);
+        assert_eq!(speed, 0.05); assert_eq!(count, 10); self.count += count;
+    }
+}
+struct Game {
+    pack: Pack, audio: Audio, particles: Particles, headless: bool,
+    lan_cushion_breaks: Vec<(u32, [f64; 3])>,
+}
+impl Game {
+    fn particle_sprite(&self, _: u32, _: [i32; 3]) -> Option<(String, u32)> {
+        (!self.headless).then(|| ("block/blue_wool".into(), 0xffffff))
+    }
+METHOD
+}
+fn main() {
+    let cushion = Cushion { position: Vec3 { x: 1.5, y: 10.0, z: 2.5 } };
+    for headless in [true, false] {
+        for serving in [true, false] {
+            let mut game = Game {
+                pack: Pack { assets: Assets { registry: Registry } },
+                audio: Audio { capture: serving.then_some(()) },
+                particles: Particles::default(), headless, lan_cushion_breaks: vec![],
+            };
+            game.cushion_break_particles(&cushion);
+            assert_eq!(game.lan_cushion_breaks.len(), usize::from(serving));
+            if serving {
+                let (state, at) = game.lan_cushion_breaks[0];
+                assert_eq!(state, 123);
+                assert_eq!([at[0], at[2]], [1.5, 2.5]);
+                assert!((at[1] - (10.0 + 1.0/6.0)).abs() < 1e-12);
+            }
+            assert_eq!(game.particles.count, if headless { 0 } else { 10 });
+        }
+    }
+}
+'''.replace("METHOD", source[start:end])
+        with tempfile.TemporaryDirectory(prefix="cushion-particles-") as directory:
+            path = Path(directory)
+            (path / "main.rs").write_text(fixture)
+            subprocess.run(["rustc", "--edition=2024", str(path / "main.rs"), "-o", str(path / "probe")],
+                           check=True, capture_output=True, text=True)
+            result = subprocess.run([str(path / "probe")], capture_output=True, text=True)
+            self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index c508a67d6..6847f8322 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -7235,9 +7235,15 @@ def check_cushions(host, guest, out):
         assert player('status').get('riding') is None, seen
         player('command', command='gamemode creative')
         player.raw('look-at', at[0], at[1] + .125, at[2])
+        before = {g.name: g('status').get('particles', {}).get('block', 0) for g in (host, guest)}
         player.raw('mouse', 'left', 'click')
         player.wait(10)
         assert not cushions(host) and not cushions(player), seen
+        seen[label]['break_particles'] = {
+            g.name: g('status').get('particles', {}).get('block', 0) - before[g.name]
+            for g in (host, guest)
+        }
+        assert all(n == 10 for n in seen[label]['break_particles'].values()), seen
     return seen
 
 

From aa839fa99a28e2649d31d807bc032942a4ec739e Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 17:39:02 +0100
Subject: [PATCH 149/475] mods: browser, a recipe viewer's item panel (API
 level 5)

A new interface under capability ui. browser.set-items lists the items of
a panel the game shows right of the inventory and container screens (an
empty list hides it); browser.poll returns what the player did since the
last poll: a click on an item, the search text, or one of the mod's own
keys pressed over an item (a slot's or the panel's), with that stack. The
slot-clicked, action, page and back events are there now for the recipe
pages to come, since adding variant cases later would break mods.

At most 8192 items and 256 waiting events. The game side is the next PR.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-mod-sdk/src/lib.rs             |  4 +-
 crates/horizon-mod-sdk/wit/horizon.wit        | 56 ++++++++++++
 crates/horizon-mods/src/api_level.rs          |  6 +-
 crates/horizon-mods/src/manifest.rs           |  4 +
 crates/horizon-mods/src/runtime.rs            | 87 ++++++++++++++++++-
 crates/horizon-mods/tests/sandbox.rs          | 65 ++++++++++++++
 crates/horizon-mods/tests/ui_guest/src/lib.rs | 58 ++++++++++++-
 docs/api/mods-reference.md                    | 66 +++++++++++++-
 docs/api/stability.md                         |  2 +-
 docs/mods.md                                  |  2 +-
 10 files changed, 340 insertions(+), 10 deletions(-)

diff --git a/crates/horizon-mod-sdk/src/lib.rs b/crates/horizon-mod-sdk/src/lib.rs
index b00d06ecf..c87c2dbc4 100644
--- a/crates/horizon-mod-sdk/src/lib.rs
+++ b/crates/horizon-mod-sdk/src/lib.rs
@@ -39,7 +39,9 @@ wit_bindgen::generate!({
 
 pub use exports::horizon::mods::events::{Guest as __Guest, Registration};
 pub use exports::horizon::mods::ui_events::Guest as __UiEventsGuest;
-pub use horizon::mods::{chat, command, game, hud, input, log, recipes, render, storage, ui};
+pub use horizon::mods::{
+    browser, chat, command, game, hud, input, log, recipes, render, storage, ui,
+};
 
 /// The game's calls into a mod. Only the hooks [`Registration`] asks for
 /// are called; the others may stay as their defaults.
diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit
index 7d7adaa0d..ab20648d8 100644
--- a/crates/horizon-mod-sdk/wit/horizon.wit
+++ b/crates/horizon-mod-sdk/wit/horizon.wit
@@ -509,6 +509,60 @@ interface recipes {
     known: func() -> list<s32>;
 }
 
+/// Capability `ui` (experimental): a recipe viewer's panel beside the
+/// game's inventory and container screens (not the creative inventory), on
+/// the right of the screen. The game draws it with its own widgets and
+/// slots, pages it and keeps its search box; the mod says what it holds.
+/// The first loaded mod with a panel shows.
+interface browser {
+    /// An item to show: its id, a count (1 draws none) and its components
+    /// beyond the item's own, in vanilla's item syntax, or "".
+    record stack {
+        item: string,
+        count: u32,
+        components: string,
+    }
+    /// A click on an item of the panel, by its index in `set-items`'s list.
+    record click {
+        index: u32,
+        right: bool,
+    }
+    /// A key the mod registered (`input.register-key`) went down while the
+    /// pointer was on an item: a slot of the screen's, or the panel's.
+    record item-key {
+        key: string,
+        stack: stack,
+    }
+    /// A click on a slot of the recipe the panel shows (`set-recipes`).
+    record slot-click {
+        /// The recipe's index on the page and the slot's in it; the
+        /// results come after the slots.
+        recipe: u32,
+        slot: u32,
+        /// The stack the slot showed at that moment.
+        stack: stack,
+        right: bool,
+    }
+    variant event {
+        clicked(click),
+        /// The search box's text, each time the player changes it.
+        search(string),
+        key(item-key),
+        slot-clicked(slot-click),
+        /// The action button of the recipe at this index on the page.
+        action(u32),
+        /// The page arrows of `set-recipes`: -1 or 1.
+        page(s32),
+        /// The back button of `set-recipes`.
+        back,
+    }
+    /// The panel's items, at most 8192 (an empty list hides the panel).
+    set-items: func(items: list<stack>);
+    /// What the player did on the panel since the last poll, at most 256
+    /// kept.
+    poll: func() -> list<event>;
+}
+
 /// Capability `players`, server mods only (manifest `api = "0.3"`,
 /// experimental): the players on the server, and messages to them.
 interface players {
@@ -616,6 +670,7 @@ world horizon-ui-mod {
     import render;
     import input;
     import recipes;
+    import browser;
     export ui-events;
 }
 
@@ -634,4 +689,5 @@ world render-host {
 /// The game's side of capability `recipes` (imports only).
 world recipes-host {
     import recipes;
+    import browser;
 }
diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs
index ff06a94ae..2474dfddd 100644
--- a/crates/horizon-mods/src/api_level.rs
+++ b/crates/horizon-mods/src/api_level.rs
@@ -7,13 +7,13 @@
 //! version's level so the launcher can tell before it installs.
 
 /// The newest level this Horizon serves.
-pub const LEVEL: u32 = 4;
+pub const LEVEL: u32 = 5;
 
 /// Every function the game offers mods, as `interface.function`, with its
 /// level. Level 0 is the contract of Horizon 0.2.67 to 0.2.69. A new
 /// function takes the next level and raises [`LEVEL`] (the `api_reference`
 /// test fails until it is listed here).
-pub const FUNCTIONS: [(&str, u32); 37] = [
+pub const FUNCTIONS: [(&str, u32); 39] = [
     ("log.write", 0),
     ("game.get-player", 0),
     ("game.get-clock", 0),
@@ -51,6 +51,8 @@ pub const FUNCTIONS: [(&str, u32); 37] = [
     ("recipes.items", 4),
     ("recipes.all", 4),
     ("recipes.known", 4),
+    ("browser.set-items", 5),
+    ("browser.poll", 5),
 ];
 
 /// What the game's program carries so the launcher can read its level
diff --git a/crates/horizon-mods/src/manifest.rs b/crates/horizon-mods/src/manifest.rs
index 05cf96447..4c12fd805 100644
--- a/crates/horizon-mods/src/manifest.rs
+++ b/crates/horizon-mods/src/manifest.rs
@@ -173,6 +173,10 @@ impl Capability {
         if interface == "log" {
             return Ok(None);
         }
+        // A recipe viewer's panel is part of capability `ui`.
+        if interface == "browser" {
+            return Ok(Some(Capability::Ui));
+        }
         Capability::ALL
             .into_iter()
             .filter(|c| *c != Capability::Registries)
diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs
index ebce03944..0f2de0246 100644
--- a/crates/horizon-mods/src/runtime.rs
+++ b/crates/horizon-mods/src/runtime.rs
@@ -85,11 +85,16 @@ mod recipes_bindings {
         world: "recipes-host",
     });
 }
+/// Capability `ui`'s recipe viewer panel (WIT `interface browser`).
+pub use recipes_bindings::horizon::mods::browser::{
+    Click as BrowserClick, Event as BrowserEvent, ItemKey as BrowserItemKey,
+    SlotClick as BrowserSlotClick, Stack as BrowserStack,
+};
 /// What capability `recipes` reads (WIT `interface recipes`).
 pub use recipes_bindings::horizon::mods::recipes::{
     Item as RecipeItem, Kind as RecipeKind, Recipe, Stack as RecipeStack,
 };
-use recipes_bindings::{RecipesHost, horizon::mods::recipes};
+use recipes_bindings::{RecipesHost, horizon::mods::browser, horizon::mods::recipes};
 
 /// A mod's linear memory cap.
 const MEMORY: usize = 64 << 20;
@@ -309,6 +314,28 @@ struct UiState {
     close: bool,
 }
 
+/// Capability `ui`'s panel beside container screens (`browser`).
+#[derive(Default)]
+struct BrowserState {
+    items: Vec<BrowserStack>,
+    /// Which `set-items` call the items are from, unique across mods and
+    /// reloads, so the game converts them once.
+    version: u64,
+    events: std::collections::VecDeque<BrowserEvent>,
+}
+static BROWSER_VERSION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
+/// Items a panel may hold, and events kept for `browser.poll`.
+const BROWSER_ITEMS: usize = 8192;
+const BROWSER_EVENTS: usize = 256;
+impl BrowserState {
+    fn push(&mut self, event: BrowserEvent) {
+        if self.events.len() == BROWSER_EVENTS {
+            self.events.pop_front();
+        }
+        self.events.push_back(event);
+    }
+}
+
 struct State {
     name: String,
     id: String,
@@ -325,6 +352,7 @@ struct State {
     /// Capability `render`'s minimap, when the mod shows one.
     minimap: Option<ModMinimap>,
     input: InputState,
+    browser: BrowserState,
     /// Capability `storage`'s folder; made on first `set`.
     data_dir: PathBuf,
     /// Bytes `storage::set` may still write before this hook call ends
@@ -490,6 +518,7 @@ impl Mods {
             zoom: None,
             minimap: None,
             input: InputState::default(),
+            browser: BrowserState::default(),
             data_dir,
             storage_budget: STORAGE_WRITE_BUDGET,
             limits: StoreLimitsBuilder::new()
@@ -799,6 +828,40 @@ impl Mods {
             .iter()
             .any(|e| e.run.as_ref().is_some_and(|r| r.raycasts))
     }
+    /// The panel beside container screens (`browser.set-items`): the first
+    /// running mod with items, its index, the items' version and the items.
+    pub fn browser_items(&self) -> Option<(usize, u64, &[BrowserStack])> {
+        self.entries.iter().enumerate().find_map(|(i, e)| {
+            let b = &e.run.as_ref()?.store.data().browser;
+            (!b.items.is_empty()).then_some((i, b.version, b.items.as_slice()))
+        })
+    }
+    /// The player did `event` on mod `owner`'s panel.
+    pub fn browser_event(&mut self, owner: usize, event: BrowserEvent) {
+        if let Some(run) = self.entries.get_mut(owner).and_then(|e| e.run.as_mut()) {
+            run.store.data_mut().browser.push(event);
+        }
+    }
+    /// The key `key` went down with the pointer on `stack` in a container
+    /// screen: each mod with a key on it hears its own name for it.
+    pub fn browser_key(&mut self, key: &str, stack: &BrowserStack) {
+        for run in self.entries.iter_mut().filter_map(|e| e.run.as_mut()) {
+            let data = run.store.data_mut();
+            let names: Vec<String> = data
+                .input
+                .keys
+                .iter()
+                .filter(|k| k.key == key)
+                .map(|k| k.name.clone())
+                .collect();
+            for key in names {
+                data.browser.push(BrowserEvent::Key(BrowserItemKey {
+                    key,
+                    stack: stack.clone(),
+                }));
+            }
+        }
+    }
     /// Some running mod reads capability `recipes`: the snapshot needs
     /// [`Snapshot::recipes`] and [`Snapshot::known_recipes`].
     pub fn wants_recipes(&self) -> bool {
@@ -1101,7 +1164,10 @@ fn reason(e: &wasmtime::Error) -> String {
 }
 
 fn clip(text: String) -> String {
-    match text.char_indices().nth(LINE_CHARS) {
+    clip_to(text, LINE_CHARS)
+}
+fn clip_to(text: String, chars: usize) -> String {
+    match text.char_indices().nth(chars) {
         Some((at, _)) => text[..at].to_string(),
         None => text,
     }
@@ -1162,6 +1228,23 @@ impl game::Host for State {
         (*at <= distance.min(RAYCAST_MAX) && !distance.is_nan()).then(|| hit.clone())
     }
 }
+impl browser::Host for State {
+    fn set_items(&mut self, items: Vec<BrowserStack>) {
+        self.browser.items = items
+            .into_iter()
+            .take(BROWSER_ITEMS)
+            .map(|s| BrowserStack {
+                item: clip(s.item),
+                components: clip_to(s.components, 4096),
+                ..s
+            })
+            .collect();
+        self.browser.version = BROWSER_VERSION.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    }
+    fn poll(&mut self) -> Vec<BrowserEvent> {
+        self.browser.events.drain(..).collect()
+    }
+}
 impl recipes::Host for State {
     fn items(&mut self) -> Vec<RecipeItem> {
         self.snapshot
diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs
index 06a8e6aa2..576dc5942 100644
--- a/crates/horizon-mods/tests/sandbox.rs
+++ b/crates/horizon-mods/tests/sandbox.rs
@@ -1098,3 +1098,68 @@ fn recipes_reads_the_tables() {
         ["0 items, 0 recipes, 0 known, 0 brewing"]
     );
 }
+
+#[test]
+fn browser_lists_items_and_hears_the_player() {
+    use horizon_mods::{BrowserClick, BrowserEvent, BrowserStack};
+    let mut mods = load("horizon_mods_test_ui_guest.hmod");
+    let said = |mods: &mut Mods, command: &str| {
+        assert!(mods.command(command));
+        mods.drain()
+            .into_iter()
+            .filter_map(|o| match o {
+                Output::Chat { text, .. } => Some(text),
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+    };
+    assert!(mods.browser_items().is_none());
+    let potion = "[minecraft:potion_contents={potion:\"minecraft:swiftness\"}]";
+    assert_eq!(
+        said(
+            &mut mods,
+            &format!("browser minecraft:stone minecraft:potion{potion}")
+        ),
+        ["panel of 2"]
+    );
+    let (owner, version, items) = mods.browser_items().unwrap();
+    assert_eq!(
+        (items[0].item.as_str(), items[1].components.as_str()),
+        ("minecraft:stone", potion)
+    );
+    mods.browser_event(
+        owner,
+        BrowserEvent::Clicked(BrowserClick {
+            index: 1,
+            right: true,
+        }),
+    );
+    mods.browser_event(owner, BrowserEvent::Search("oak".into()));
+    let log = BrowserStack {
+        item: "minecraft:oak_log".into(),
+        count: 3,
+        components: String::new(),
+    };
+    // R is the guest's `recipe`; X is none of its keys.
+    mods.browser_key("key.keyboard.r", &log);
+    mods.browser_key("key.keyboard.x", &log);
+    assert_eq!(
+        said(&mut mods, "browser_poll"),
+        [
+            "3 events",
+            "clicked 1 right",
+            "search \"oak\"",
+            "key recipe on minecraft:oak_log x3"
+        ]
+    );
+    // Each `set-items` is a new version; an empty list hides the panel.
+    said(&mut mods, "browser minecraft:dirt");
+    assert_ne!(mods.browser_items().unwrap().1, version);
+    assert_eq!(said(&mut mods, "browser"), ["panel of 0"]);
+    assert!(mods.browser_items().is_none());
+    // At most 256 events wait for a poll: the oldest go.
+    for _ in 0..300 {
+        mods.browser_event(owner, BrowserEvent::Page(1));
+    }
+    assert_eq!(said(&mut mods, "browser_poll")[0], "256 events");
+}
diff --git a/crates/horizon-mods/tests/ui_guest/src/lib.rs b/crates/horizon-mods/tests/ui_guest/src/lib.rs
index 2fd835d3c..4fc2ee2c4 100644
--- a/crates/horizon-mods/tests/ui_guest/src/lib.rs
+++ b/crates/horizon-mods/tests/ui_guest/src/lib.rs
@@ -8,8 +8,11 @@
 //! `/raycast DISTANCE` says what `game.raycast` sees; `/quiet A;B` runs
 //! lines with `command.run-quiet` (`/quiet_many N`: N of them). `/recipes`
 //! counts what `recipes` reads; `/recipes ID` describes that recipe.
+//! `/browser ID...` fills `browser`'s panel (`/browser N`: the first N
+//! items, `/browser` alone empties it) and registers the keys `recipe` (R)
+//! and `uses` (U); `/browser_poll` says what the player did on it.
 use horizon_mod_sdk::{
-    Mod, Registration, chat, command, game,
+    Mod, Registration, browser, chat, command, game,
     input::{self, Event},
     recipes,
     render::{self, FillShape, ItemShape, Point, QuadShape, Rect, Shape, SpriteShape, TextShape},
@@ -105,6 +108,8 @@ impl Mod for Guest {
             "quiet",
             "quiet_many",
             "recipes",
+            "browser",
+            "browser_poll",
             "corner",
             "readings",
         ]
@@ -279,6 +284,57 @@ impl Mod for Guest {
                     ),
                 });
             }
+            "browser" => {
+                let stack = |item: &str| {
+                    let (item, components) = match item.find('[') {
+                        Some(at) => (&item[..at], &item[at..]),
+                        None => (item, ""),
+                    };
+                    browser::Stack {
+                        item: item.into(),
+                        count: 1,
+                        components: components.into(),
+                    }
+                };
+                let items: Vec<browser::Stack> = match args.parse::<usize>() {
+                    Ok(n) => recipes::items()
+                        .iter()
+                        .skip(1)
+                        .take(n)
+                        .map(|i| stack(&i.id))
+                        .collect(),
+                    Err(_) => args.split_whitespace().map(stack).collect(),
+                };
+                browser::set_items(&items);
+                input::register_key("recipe", "Show recipes", "key.keyboard.r")?;
+                input::register_key("uses", "Show uses", "key.keyboard.u")?;
+                chat::show(&format!("panel of {}", items.len()));
+            }
+            "browser_poll" => {
+                let stack = |s: &browser::Stack| format!("{} x{}{}", s.item, s.count, s.components);
+                // A hook shows at most 8 chat lines: the count, then the first 7.
+                let events = browser::poll();
+                chat::show(&format!("{} events", events.len()));
+                for event in events.into_iter().take(7) {
+                    chat::show(&match event {
+                        browser::Event::Clicked(c) => {
+                            format!(
+                                "clicked {} {}",
+                                c.index,
+                                if c.right { "right" } else { "left" }
+                            )
+                        }
+                        browser::Event::Search(text) => format!("search {text:?}"),
+                        browser::Event::Key(k) => format!("key {} on {}", k.key, stack(&k.stack)),
+                        browser::Event::SlotClicked(c) => {
+                            format!("slot {} {} {}", c.recipe, c.slot, stack(&c.stack))
+                        }
+                        browser::Event::Action(i) => format!("action {i}"),
+                        browser::Event::Page(step) => format!("page {step}"),
+                        browser::Event::Back => "back".into(),
+                    });
+                }
+            }
             // Clamped to (1, 10); the two after it shake nothing.
             "render_shake" => {
                 render::shake(2.0, 99.0);
diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md
index 1ee54e70f..111fefd5c 100644
--- a/docs/api/mods-reference.md
+++ b/docs/api/mods-reference.md
@@ -37,7 +37,7 @@ A server mod (manifest `side = "server"`, `api = "0.3"`, experimental): runs whe
 
 A mod with widgets (capability `ui`): the SDK builds every mod against this world. Mods built for `horizon-mod` alone (no `ui-events` export) still load and simply hear nothing of their widgets.
 
-- Imports (what the game offers): `ui`, `render`, `input`, `recipes`, `log`, `game`, `chat`, `hud`, `storage`, `command`
+- Imports (what the game offers): `ui`, `render`, `input`, `recipes`, `browser`, `log`, `game`, `chat`, `hud`, `storage`, `command`
 - Exports (what the mod provides): `ui-events`, `events`
 
 ## World `ui-host`
@@ -58,7 +58,7 @@ The game's side of capability `render` (imports only).
 
 The game's side of capability `recipes` (imports only).
 
-- Imports (what the game offers): `recipes`
+- Imports (what the game offers): `recipes`, `browser`
 - Exports (what the mod provides): 
 
 ## `log`
@@ -531,6 +531,68 @@ The station a recipe is made at.
 | `all` | `func() -> list<recipe>` | Every recipe: the book's in its order, then campfire, stonecutting, smithing and brewing. They don't change while a world is open. |
 | `known` | `func() -> list<s32>` | The `book-id`s of the recipes the player's recipe book holds now. |
 
+## `browser`
+
+Access: not granted by any capability.
+
+Capability `ui` (experimental): a recipe viewer's panel beside the game's inventory and container screens (not the creative inventory), on the right of the screen. The game draws it with its own widgets and slots, pages it and keeps its search box; the mod says what it holds. The first loaded mod with a panel shows.
+
+### record `stack`
+
+An item to show: its id, a count (1 draws none) and its components beyond the item's own, in vanilla's item syntax, or "".
+
+| Field | Type | |
+| --- | --- | --- |
+| `item` | `string` |  |
+| `count` | `u32` |  |
+| `components` | `string` |  |
+
+### record `click`
+
+A click on an item of the panel, by its index in `set-items`'s list.
+
+| Field | Type | |
+| --- | --- | --- |
+| `index` | `u32` |  |
+| `right` | `bool` |  |
+
+### record `item-key`
+
+A key the mod registered (`input.register-key`) went down while the pointer was on an item: a slot of the screen's, or the panel's.
+
+| Field | Type | |
+| --- | --- | --- |
+| `key` | `string` |  |
+| `stack` | `stack` |  |
+
+### record `slot-click`
+
+A click on a slot of the recipe the panel shows (`set-recipes`).
+
+| Field | Type | |
+| --- | --- | --- |
+| `recipe` | `u32` | The recipe's index on the page and the slot's in it; the results come after the slots. |
+| `slot` | `u32` |  |
+| `stack` | `stack` | The stack the slot showed at that moment. |
+| `right` | `bool` |  |
+
+### variant `event`
+
+| Case | Payload | |
+| --- | --- | --- |
+| `clicked` | `click` |  |
+| `search` | `string` | The search box's text, each time the player changes it. |
+| `key` | `item-key` |  |
+| `slot-clicked` | `slot-click` |  |
+| `action` | `u32` | The action button of the recipe at this index on the page. |
+| `page` | `s32` | The page arrows of `set-recipes`: -1 or 1. |
+| `back` |  | The back button of `set-recipes`. |
+
+| Function | Signature | What it does |
+| --- | --- | --- |
+| `set-items` | `func(items: list<stack>)` | The panel's items, at most 8192 (an empty list hides the panel). |
+| `poll` | `func() -> list<event>` | What the player did on the panel since the last poll, at most 256 kept. |
+
 ## `players`
 
 Access: capability `players`.
diff --git a/docs/api/stability.md b/docs/api/stability.md
index 00b5541a9..bb0ddf501 100644
--- a/docs/api/stability.md
+++ b/docs/api/stability.md
@@ -38,7 +38,7 @@ don't import it); faster, or fixing behaviour to what the reference already says
 
 A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every
 function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`):
-level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`, level 3 `command.run-quiet`, level 4 `recipes` (`items`, `all`, `known`). A mod needs the level of
+level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`, level 3 `command.run-quiet`, level 4 `recipes` (`items`, `all`, `known`), level 5 `browser` (`set-items`, `poll`). A mod needs the level of
 the newest function it imports (a component imports only the functions it calls). The level is read from the file,
 never declared:
 
diff --git a/docs/mods.md b/docs/mods.md
index 73ecfb9a5..9aed4897b 100644
--- a/docs/mods.md
+++ b/docs/mods.md
@@ -88,7 +88,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3.
 | `hud` | `hud` | `set-panel(corner, lines)`, `clear()`: up to 16 lines of 256 characters |
 | `storage` | `storage` | `get(key)`, `set(key, value)`, `delete(key)`: a per-mod folder of up to 64 files, 4 MiB total, at most 1 MiB written per call |
 | `command` | `command` | `run(line)`: a vanilla command run as the player, with the player's permissions, after the hook returns (8 per call); mods' own commands are not run. `run-quiet(lines)`: up to 256 a call, the same rights, nothing in the chat (single player and Horizon's servers run them 64 a tick and log one line a batch; elsewhere they go as chat commands and their feedback shows) |
-| `ui` | `ui` | `open-screen`, `close-screen`, `set-settings`: a screen the mod owns and a page in Options > Mods, of text, button, item and list widgets the game lays out and draws with its own menus' code. **Experimental:** the manifest needs `experimental = ["ui"]` |
+| `ui` | `ui` | `open-screen`, `close-screen`, `set-settings`: a screen the mod owns and a page in Options > Mods, of text, button, item and list widgets the game lays out and draws with its own menus' code; `browser.set-items`, `browser.poll`: a recipe viewer's panel of items right of the inventory and container screens (not the creative one), which the game pages and draws with its own slots and search box, and the mod hears its clicks, its searches and the mod's own keys (`input.register-key`) pressed over any item on the screen. **Experimental:** the manifest needs `experimental = ["ui"]` |
 | `render` | `render` | `set-hud(shapes)`: up to 1024 fills, four-cornered shapes, GUI sprites, items and text, kept on the HUD (over the hotbar, under chat and screens, hidden with F1) until replaced; `set-corner(corner, w, h, shapes)`: a box the game places in a corner, stacked with its overlays and other panels, as `hud`'s panels are; `text-width(text)`; `frame-stats()`: the game's FPS, min and 1% low; `gui-size()`; `shake(strength, seconds)`: the view turns, the player doesn't, scaled by Distortion Effects; `set-zoom(zoom)`: the field of view divided by up to 10, eased or at once, with slower turning, while playing and not through a spyglass (the strongest of several mods' zooms counts); `set-minimap(minimap)`: a map of the world around the player in a corner, as a map item colours it (the floor underground and under roofs), square or round, turning with the player or north up, with the player's arrow; the game keeps its tiles within its own frame budget (one map at a time, the first loaded mod's). The game's own HUD renderer draws them: a mod never supplies shader code. **Experimental:** `experimental = ["render"]` |
 | `input` | `input` | `claim-items(ids)`: the use button on those items is the mod's (`use-start`, `use-stop` with the ticks held; the game doesn't place, eat or swing); `register-key(name, label, key)`: up to 16 keys (`key.keyboard.r`), heard while playing as `key-down` / `key-up` (the game's own mapping on that key still runs; a screen opening lets held keys up), mouse buttons as `key.mouse.4`. The player rebinds them on the mod's page in Options > Mods, where the game lists them first as Key Binds rows (click, then press a key or mouse button; Esc binds none), even for a mod without `ui`; the choice is kept in `horizon-mods.txt` (`key.<mod>.<name>:key.keyboard.z`) and wins over `register-key`'s default; `claim-wheel(on)`: the wheel's steps become `wheel` events and the hotbar doesn't move (the one input a mod takes from the game; a mod's keys never do); `held()`; `mapping(name)`: a movement or click mapping's key label and whether it is held; `clicks-per-second()`; `poll()` returns the events, at most 256 kept. **Experimental:** `experimental = ["input"]` |
 | `recipes` | `recipes` | `items()`: every item in the registry's order, with its name in the player's language and its tags; `all()`: every recipe (crafting, smelting, blasting, smoking, campfire, stonecutting, smithing, brewing), its slots as the stacks that fit each, its results, cooking time and experience, and the recipe book's id for it; `known()`: the book ids the player's recipe book holds. The recipes are the world's in single player and on Horizon's servers, vanilla 26.3's on any other server (a client is sent no others), while `known` follows that server's book. The game makes the tables once, when a mod first reads them. **Experimental:** `experimental = ["recipes"]` |

From 487a461a8a7454871aaf92e11466cadc9504699b Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 17:39:12 +0100
Subject: [PATCH 150/475] game: the item panel of a mod's browser beside
 container screens

The panel sits right of the inventory or container window, from the top of
the screen to a search box at its foot, in up to 12 columns of the game's
own item slots, with the recipe book's page arrows. It shows on the
survival inventory and every container screen (not the creative one) while
a running mod has items in it, and hides when there is no room for two
columns. Clicks on it never throw the carried stack; the carried stack and
tooltips are drawn again above it.

The mod hears clicks on items, the search text as it changes, and its own
keys pressed with the pointer on an item, the panel's or a slot's. The
search box takes every key but Escape while focused, as the recipe book's.
Each set-items is turned into stacks once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game.rs             |  56 ++-
 crates/horizon-client/src/game/control.rs     |   3 +
 crates/horizon-client/src/game/mod_browser.rs | 440 ++++++++++++++++++
 crates/horizon-client/src/game/mod_input.rs   |  12 +
 crates/horizon-client/src/game/mod_recipes.rs |   2 +-
 crates/horizon-client/src/game/mods.rs        |   3 +
 6 files changed, 496 insertions(+), 20 deletions(-)
 create mode 100644 crates/horizon-client/src/game/mod_browser.rs

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 826ea73c1..6779d367a 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -99,6 +99,7 @@ mod maps;
 mod minecarts;
 mod mob_blocks;
 mod mob_gear;
+mod mod_browser;
 mod mod_input;
 #[cfg(feature = "mods")]
 mod mod_recipes;
@@ -5217,6 +5218,7 @@ impl Game<'_> {
             Screen::CommandBlock => self.draw_command_block(&mut batch),
             Screen::Inventory => {
                 self.draw_inventory(&mut batch);
+                self.draw_mod_browser(&mut batch);
             }
             Screen::Creative => {
                 self.draw_creative(&mut batch);
@@ -5595,6 +5597,7 @@ impl Game<'_> {
         }
     }
     pub(super) fn close_container(&mut self) {
+        self.mod_browser_closed();
         self.close_station();
         self.mount_closed();
         self.recipe_ui.reset_screen();
@@ -6319,6 +6322,9 @@ impl Game<'_> {
     fn inventory_press(&mut self, right: bool) {
         use horizon_client::container_screen::Target;
         use horizon_client::menu::Input;
+        if self.mod_browser_press(right) {
+            return;
+        }
         if !right && self.sort_press() {
             return;
         }
@@ -6495,24 +6501,8 @@ impl Game<'_> {
     }
     /// `hasClickedOutside` of the open screen at the cursor.
     fn clicked_outside(&self, batch: &HudBatch) -> bool {
-        use horizon_client::container_screen::{Book, Image, clicked_outside};
-        let (ox, oy) = self.inventory_origin(batch);
-        let (shift, width, height) = if self.screen == Screen::Creative {
-            (0.0, Creative::WIDTH as i32, Creative::HEIGHT as i32)
-        } else {
-            let (shift, width) = match self.station.as_ref().map(|s| s.kind) {
-                Some(stations::Kind::Merchant) => (-50.0, 276),
-                Some(stations::Kind::Beacon) => (beacon::SHIFT, 230),
-                _ => (0.0, 176),
-            };
-            (shift, width, self.screen_height() as i32)
-        };
-        let image = Image {
-            left: (ox + shift) as i32,
-            top: oy as i32,
-            width,
-            height,
-        };
+        use horizon_client::container_screen::{Book, clicked_outside};
+        let image = self.container_image(batch);
         let book = self
             .recipe_book_area(batch)
             .map(|(visible, tab_hovered)| Book {
@@ -6526,6 +6516,26 @@ impl Game<'_> {
             book,
         )
     }
+    /// The open container screen's window: its place and size.
+    fn container_image(&self, batch: &HudBatch) -> horizon_client::container_screen::Image {
+        let (ox, oy) = self.inventory_origin(batch);
+        let (shift, width, height) = if self.screen == Screen::Creative {
+            (0.0, Creative::WIDTH as i32, Creative::HEIGHT as i32)
+        } else {
+            let (shift, width) = match self.station.as_ref().map(|s| s.kind) {
+                Some(stations::Kind::Merchant) => (-50.0, 276),
+                Some(stations::Kind::Beacon) => (beacon::SHIFT, 230),
+                _ => (0.0, 176),
+            };
+            (shift, width, self.screen_height() as i32)
+        };
+        horizon_client::container_screen::Image {
+            left: (ox + shift) as i32,
+            top: oy as i32,
+            width,
+            height,
+        }
+    }
     /// A click outside the window (slot id -999): `THROW` does nothing; a
     /// `PICKUP` drops the carried stack (left) or one of it (right), thrown
     /// from the hand (`AbstractContainerMenu.doClick`, `LivingEntity.drop`).
@@ -6686,7 +6696,7 @@ impl Game<'_> {
         }
     }
     fn click_inventory(&mut self, right: bool) {
-        if self.mount_click(right) {
+        if self.mod_browser_press(right) || self.mount_click(right) {
             return;
         }
         if self.recipe_book_click(right) {
@@ -11645,6 +11655,14 @@ impl ApplicationHandler for Game<'_> {
                     // The recipe book's search box takes every key but Escape.
                     self.recipe_key(&event);
                 }
+                WindowEvent::KeyboardInput { event, .. }
+                    if self.mod_browser_typing()
+                        && event.state == ElementState::Pressed
+                        && !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
+                {
+                    // A mod's item panel's search box, as the recipe book's.
+                    self.mod_browser_key(&event);
+                }
                 WindowEvent::KeyboardInput { event, .. }
                     if self.station_typing()
                         && event.state == ElementState::Pressed
diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs
index 3202b23f4..191fa8359 100644
--- a/crates/horizon-client/src/game/control.rs
+++ b/crates/horizon-client/src/game/control.rs
@@ -628,6 +628,9 @@ impl Game<'_> {
                     // The port, or the game rules' search and number boxes.
                     Screen::WorldOptions if text == "\\b" => self.world_options_text(None),
                     Screen::WorldOptions => self.world_options_text(Some(text)),
+                    Screen::Inventory if self.mod_browser_typing() => {
+                        self.mod_browser_text((text != "\\b").then_some(text), text == "\\b")
+                    }
                     Screen::Inventory if self.recipe_search_focused() => {
                         self.recipe_text(Some(text), false)
                     }
diff --git a/crates/horizon-client/src/game/mod_browser.rs b/crates/horizon-client/src/game/mod_browser.rs
new file mode 100644
index 000000000..2f317792f
--- /dev/null
+++ b/crates/horizon-client/src/game/mod_browser.rs
@@ -0,0 +1,440 @@
+//! Capability `ui`'s panel beside container screens (WIT `interface
+//! browser`, docs/mods.md): the items a recipe viewer mod lists, drawn as
+//! the game's own item slots in pages right of the screen's window, with a
+//! search box under them. The mod says what the panel holds; the game pages
+//! it and tells the mod what the player clicked, typed, and which of the
+//! mod's keys went down over an item. With no mod showing a panel, each
+//! hook here returns after one check.
+use super::Game;
+#[cfg(feature = "mods")]
+use {
+    super::Screen,
+    horizon_client::{
+        hud::{HudBatch, rgba},
+        items::ItemStack,
+        ui::EditBox,
+    },
+    horizon_mods::{BrowserClick, BrowserEvent, BrowserStack},
+};
+
+#[cfg(not(feature = "mods"))]
+impl Game<'_> {
+    pub(super) fn draw_mod_browser(&mut self, _batch: &mut horizon_client::hud::HudBatch) {}
+    pub(super) fn mod_browser_press(&mut self, _right: bool) -> bool {
+        false
+    }
+    pub(super) fn mod_browser_typing(&self) -> bool {
+        false
+    }
+    pub(super) fn mod_browser_key(&mut self, _event: &winit::event::KeyEvent) {}
+    pub(super) fn mod_browser_text(&mut self, _text: Option<&str>, _backspace: bool) {}
+    pub(super) fn mod_browser_closed(&mut self) {}
+}
+
+/// One slot of the panel, in GUI pixels.
+#[cfg(feature = "mods")]
+const SLOT: f32 = 18.0;
+/// The most columns the panel takes, and the fewest it shows with.
+#[cfg(feature = "mods")]
+const COLUMNS: (usize, usize) = (12, 2);
+/// The gap between the window and the panel, and the screen's edges.
+#[cfg(feature = "mods")]
+const MARGIN: f32 = 8.0;
+
+/// The panel's state in the game.
+#[cfg(feature = "mods")]
+#[derive(Default)]
+pub(super) struct Browser {
+    /// The items' owner and version they were made from.
+    of: Option<(usize, u64)>,
+    /// The mod's items as stacks; `None` for an item the game doesn't have.
+    stacks: Vec<Option<ItemStack>>,
+    page: usize,
+    search: Option<EditBox>,
+    /// The search text the mod last heard.
+    sent: String,
+}
+
+/// Where the panel's parts are this frame.
+#[cfg(feature = "mods")]
+struct Layout {
+    /// The panel's whole area, for clicks that hit none of its parts.
+    area: [f32; 4],
+    /// The grid's top left corner, its columns and rows.
+    grid: (f32, f32),
+    columns: usize,
+    rows: usize,
+    /// The page arrows' row.
+    arrows_y: f32,
+    search: [f32; 4],
+}
+#[cfg(feature = "mods")]
+impl Layout {
+    fn per_page(&self) -> usize {
+        self.columns * self.rows
+    }
+    fn width(&self) -> f32 {
+        self.columns as f32 * SLOT
+    }
+    fn slot(&self, n: usize) -> (f32, f32) {
+        (
+            self.grid.0 + (n % self.columns) as f32 * SLOT,
+            self.grid.1 + (n / self.columns) as f32 * SLOT,
+        )
+    }
+    /// The page arrows: backward, then forward.
+    fn arrows(&self) -> [(f32, f32); 2] {
+        [
+            (self.grid.0, self.arrows_y),
+            (self.grid.0 + self.width() - 12.0, self.arrows_y),
+        ]
+    }
+}
+
+#[cfg(feature = "mods")]
+fn inside(p: (f32, f32), [x, y, w, h]: [f32; 4]) -> bool {
+    p.0 >= x && p.1 >= y && p.0 < x + w && p.1 < y + h
+}
+
+#[cfg(feature = "mods")]
+impl Game<'_> {
+    fn browser_batch(&self) -> Option<HudBatch> {
+        let r = self.renderer.as_ref()?;
+        Some(HudBatch::new([r.config.width, r.config.height]))
+    }
+    /// The mod showing a panel, with its items made into stacks once per
+    /// `set-items`; none while no mod shows one or no container screen is up.
+    fn browser_sync(&mut self) -> Option<usize> {
+        if self.screen != Screen::Inventory || self.title.is_some() {
+            return None;
+        }
+        let Some((owner, version)) = self.mods.mods.browser_items().map(|(o, v, _)| (o, v)) else {
+            self.mods.browser.of = None;
+            self.mods.browser.stacks.clear();
+            return None;
+        };
+        if self.mods.browser.of != Some((owner, version)) {
+            let items = self.res.items();
+            let stacks = self
+                .mods
+                .mods
+                .browser_items()
+                .map_or_else(Vec::new, |(_, _, list)| {
+                    list.iter().map(|s| browser_stack(items, s)).collect()
+                });
+            self.mods.browser.stacks = stacks;
+            self.mods.browser.of = Some((owner, version));
+        }
+        Some(owner)
+    }
+    /// The panel's parts: right of the window, from the top of the screen to
+    /// the search box at its foot. None when the screen has no room for it.
+    fn browser_layout(&self, batch: &HudBatch) -> Option<Layout> {
+        let image = self.container_image(batch);
+        let left = (image.left + image.width) as f32 + MARGIN;
+        let right = batch.width - MARGIN;
+        let columns = (((right - left) / SLOT).floor().max(0.0) as usize).min(COLUMNS.0);
+        if columns < COLUMNS.1 {
+            return None;
+        }
+        let x = (left + (right - left - columns as f32 * SLOT) / 2.0).floor();
+        let arrows_y = MARGIN;
+        let top = arrows_y + 17.0 + 4.0;
+        let search = [x, batch.height - MARGIN - 16.0, columns as f32 * SLOT, 16.0];
+        let rows = ((search[1] - 4.0 - top) / SLOT).floor().max(0.0) as usize;
+        (rows > 0).then_some(Layout {
+            area: [left, 0.0, right - left, batch.height],
+            grid: (x, top),
+            columns,
+            rows,
+            arrows_y,
+            search,
+        })
+    }
+    fn browser_pages(&self, layout: &Layout) -> usize {
+        self.mods
+            .browser
+            .stacks
+            .len()
+            .div_ceil(layout.per_page())
+            .max(1)
+    }
+    /// The panel's item under the pointer: its index and stack.
+    fn browser_hovered(&self, layout: &Layout) -> Option<(usize, ItemStack)> {
+        let first = self.mods.browser.page * layout.per_page();
+        (0..layout.per_page()).find_map(|n| {
+            let (x, y) = layout.slot(n);
+            if !inside(self.cursor, [x, y, SLOT, SLOT]) {
+                return None;
+            }
+            let stack = self.mods.browser.stacks.get(first + n)?.clone()?;
+            Some((first + n, stack))
+        })
+    }
+    fn browser_search(&mut self, layout: &Layout) -> &mut EditBox {
+        let search = self.mods.browser.search.get_or_insert_with(|| {
+            let mut edit = EditBox::new(0.0, 0.0, 0.0, 0.0);
+            edit.max_length = 50;
+            edit.focused = false;
+            edit
+        });
+        [search.x, search.y, search.width, search.height] = layout.search;
+        search
+    }
+
+    /// Draws the panel over the open container screen, then the carried
+    /// stack or the tooltip again so they stay on top of it.
+    pub(super) fn draw_mod_browser(&mut self, batch: &mut HudBatch) {
+        if self.browser_sync().is_none() {
+            return;
+        }
+        let Some(layout) = self.browser_layout(batch) else {
+            return;
+        };
+        let pages = self.browser_pages(&layout);
+        self.mods.browser.page = self.mods.browser.page.min(pages - 1);
+        let page = self.mods.browser.page;
+        let cursor = self.cursor;
+        if pages > 1 {
+            let labels = [
+                self.translate("gui.recipebook.previous_page", "Previous Page"),
+                self.translate("gui.recipebook.next_page", "Next Page"),
+            ];
+            let shown = [page > 0, page + 1 < pages];
+            let atlas = &self.gui.atlas;
+            for (((x, y), name), (label, shown)) in layout
+                .arrows()
+                .into_iter()
+                .zip(["page_backward", "page_forward"])
+                .zip(labels.iter().zip(shown))
+            {
+                if !shown {
+                    continue;
+                }
+                let hover = inside(cursor, [x, y, 12.0, 17.0]);
+                let suffix = if hover { "_highlighted" } else { "" };
+                batch.sprite(
+                    atlas,
+                    &format!("gui/sprites/recipe_book/{name}{suffix}"),
+                    x,
+                    y,
+                );
+                horizon_client::widgets::record(label, [x, y, 12.0, 17.0], true);
+            }
+            let text = format!("{}/{pages}", page + 1);
+            let w = HudBatch::text_width(atlas, &text);
+            let x = (layout.grid.0 + (layout.width() - w) / 2.0).floor();
+            batch.text(atlas, &text, x, layout.arrows_y + 5.0, u32::MAX, true);
+        }
+        let first = page * layout.per_page();
+        for n in 0..layout.per_page() {
+            let Some(stack) = self.mods.browser.stacks.get(first + n) else {
+                break;
+            };
+            let Some(stack) = stack.clone() else {
+                continue;
+            };
+            let (x, y) = layout.slot(n);
+            self.draw_item(batch, &stack, x + 1.0, y + 1.0);
+            let rect = [x + 1.0, y + 1.0, 16.0, 16.0];
+            if inside(cursor, [x, y, SLOT, SLOT]) {
+                batch.fill(
+                    &self.gui.atlas,
+                    x + 1.0,
+                    y + 1.0,
+                    16.0,
+                    16.0,
+                    rgba(255, 255, 255, 128),
+                );
+            }
+            let name = self.pack.names.display_item(&stack.item);
+            horizon_client::widgets::record_as(
+                &name,
+                rect,
+                true,
+                horizon_client::widgets::Kind::Button,
+            );
+        }
+        let hint = self.translate("gui.recipebook.search_hint", "Search...");
+        let search = self.browser_search(&layout);
+        // The hint shows in an empty box without focus, as the recipe book's.
+        search.suggestion = (search.value.is_empty() && !search.focused).then_some(hint);
+        let mut search = search.clone();
+        search.draw(batch, &self.gui.atlas, None);
+        self.mods.browser.search = Some(search);
+        if self.carried.is_some() {
+            self.draw_carried(batch);
+        } else if let Some((_, stack)) = self.browser_hovered(&layout) {
+            let lines = self.stack_tooltip(&stack);
+            self.draw_tooltip_lines(batch, &lines, cursor.0, cursor.1);
+        } else {
+            self.draw_slot_tooltip(batch);
+        }
+    }
+
+    /// A mouse press on a container screen: true when the panel took it
+    /// (its search box, page arrows, items or empty space; a click there
+    /// never throws the carried stack).
+    pub(super) fn mod_browser_press(&mut self, right: bool) -> bool {
+        let Some(owner) = self.browser_sync() else {
+            return false;
+        };
+        let Some(batch) = self.browser_batch() else {
+            return false;
+        };
+        let Some(layout) = self.browser_layout(&batch) else {
+            return false;
+        };
+        let cursor = self.cursor;
+        let shift = self.has_shift_down();
+        let atlas = &self.gui.atlas;
+        let search = self.mods.browser.search.get_or_insert_with(|| {
+            let mut edit = EditBox::new(0.0, 0.0, 0.0, 0.0);
+            edit.max_length = 50;
+            edit
+        });
+        [search.x, search.y, search.width, search.height] = layout.search;
+        if inside(cursor, layout.search) {
+            search.focused = true;
+            search.click(atlas, cursor.0, shift, false);
+            search.reset_blink();
+            return true;
+        }
+        search.focused = false;
+        let pages = self.browser_pages(&layout);
+        let page = self.mods.browser.page;
+        let [back, forward] = layout.arrows();
+        let step = if pages > 1 && page > 0 && inside(cursor, [back.0, back.1, 12.0, 17.0]) {
+            Some(page - 1)
+        } else if pages > 1
+            && page + 1 < pages
+            && inside(cursor, [forward.0, forward.1, 12.0, 17.0])
+        {
+            Some(page + 1)
+        } else {
+            None
+        };
+        if let Some(to) = step {
+            self.mods.browser.page = to;
+            self.audio
+                .play("minecraft:ui.button.click", None, 0.25, 1.0);
+            return true;
+        }
+        if let Some((index, _)) = self.browser_hovered(&layout) {
+            let event = BrowserEvent::Clicked(BrowserClick {
+                index: index as u32,
+                right,
+            });
+            self.mods.mods.browser_event(owner, event);
+            return true;
+        }
+        inside(cursor, layout.area)
+    }
+
+    /// Whether keys go to the panel's search box.
+    pub(super) fn mod_browser_typing(&self) -> bool {
+        self.screen == Screen::Inventory
+            && self.mods.browser.of.is_some()
+            && self.mods.browser.search.as_ref().is_some_and(|s| s.focused)
+    }
+    /// A key press while the search box has focus.
+    pub(super) fn mod_browser_key(&mut self, event: &winit::event::KeyEvent) {
+        use winit::keyboard::PhysicalKey;
+        let shortcut = self.edit_shortcut(event);
+        let ctrl = self.has_control_down();
+        let shift = self.has_shift_down();
+        let Some(search) = self.mods.browser.search.as_mut() else {
+            return;
+        };
+        if let Some(shortcut) = shortcut {
+            search.shortcut(shortcut, &mut self.clipboard);
+        } else {
+            let handled = match event.physical_key {
+                PhysicalKey::Code(code) => search.key(code, ctrl, shift),
+                _ => false,
+            };
+            if !handled
+                && !ctrl
+                && let Some(text) = &event.text
+            {
+                let text: String = text.chars().filter(|c| !c.is_control()).collect();
+                search.insert_text(&text);
+            }
+        }
+        search.reset_blink();
+        self.browser_searched();
+    }
+    /// Text typed (or one backspace) into the search box (`horizon-ctl type`).
+    pub(super) fn mod_browser_text(&mut self, text: Option<&str>, backspace: bool) {
+        let Some(search) = self.mods.browser.search.as_mut() else {
+            return;
+        };
+        if backspace {
+            search.delete_chars(-1);
+        } else if let Some(text) = text {
+            search.insert_text(text);
+        }
+        self.browser_searched();
+    }
+    /// The mod hears the search text when it changed.
+    fn browser_searched(&mut self) {
+        let (Some((owner, _)), Some(search)) = (self.mods.browser.of, &self.mods.browser.search)
+        else {
+            return;
+        };
+        if search.value != self.mods.browser.sent {
+            let value = search.value.clone();
+            self.mods.browser.sent.clone_from(&value);
+            self.mods.browser.page = 0;
+            self.mods
+                .mods
+                .browser_event(owner, BrowserEvent::Search(value));
+        }
+    }
+    /// The container screen closed: the search box lets go of the keys.
+    pub(super) fn mod_browser_closed(&mut self) {
+        if let Some(search) = self.mods.browser.search.as_mut() {
+            search.focused = false;
+        }
+    }
+    /// The item under the pointer on a container screen, for the mods' keys
+    /// (`browser`'s `key` event): the panel's, else a slot's.
+    pub(super) fn mod_browser_pointed(&mut self) -> Option<BrowserStack> {
+        let batch = self.browser_batch()?;
+        let stack = match self
+            .browser_sync()
+            .and_then(|_| self.browser_layout(&batch))
+        {
+            Some(layout) if inside(self.cursor, layout.area) => self.browser_hovered(&layout)?.1,
+            _ => {
+                let slot = self.slot_at(&batch, self.cursor.0, self.cursor.1)?;
+                self.slot_view(slot)?
+            }
+        };
+        Some(BrowserStack {
+            item: stack.item.to_string(),
+            count: stack.count,
+            components: super::mod_recipes::components(&stack),
+        })
+    }
+}
+
+/// A mod's item as a stack: an item the game has, its components read as
+/// `/give` reads them (ones it can't read are left out).
+#[cfg(feature = "mods")]
+fn browser_stack(items: &horizon_client::items::Items, s: &BrowserStack) -> Option<ItemStack> {
+    items.get(&s.item)?;
+    let (damage, extra) = if s.components.is_empty() {
+        (0, None)
+    } else {
+        horizon_client::item_data::command_components(&s.components).map_or((0, None), |tag| {
+            horizon_client::item_data::decode_components(Some(&tag))
+        })
+    };
+    Some(ItemStack {
+        item: s.item.as_str().into(),
+        count: s.count.clamp(1, 99),
+        damage,
+        extra,
+    })
+}
diff --git a/crates/horizon-client/src/game/mod_input.rs b/crates/horizon-client/src/game/mod_input.rs
index 10faf6a81..3df62c3d4 100644
--- a/crates/horizon-client/src/game/mod_input.rs
+++ b/crates/horizon-client/src/game/mod_input.rs
@@ -111,6 +111,18 @@ impl Game<'_> {
         if repeat || !self.mods.mods.has_keys() {
             return;
         }
+        // Over an item on a container screen, the mods' keys are `browser`
+        // events (a recipe viewer's R and U).
+        if pressed
+            && self.screen == Screen::Inventory
+            && self.title.is_none()
+            && !self.mod_browser_typing()
+            && let Some(name) = horizon_client::keybinds::key_name(key)
+            && let Some(stack) = self.mod_browser_pointed()
+        {
+            self.mods.mods.browser_key(name, &stack);
+            return;
+        }
         if pressed && (self.screen != Screen::Playing || self.title.is_some()) {
             return;
         }
diff --git a/crates/horizon-client/src/game/mod_recipes.rs b/crates/horizon-client/src/game/mod_recipes.rs
index 0d57e1f94..f02eb6424 100644
--- a/crates/horizon-client/src/game/mod_recipes.rs
+++ b/crates/horizon-client/src/game/mod_recipes.rs
@@ -35,7 +35,7 @@ impl Index {
 
 /// A stack's components beyond its item's, as vanilla's item syntax writes
 /// them (`[minecraft:potion_contents={potion:"minecraft:swiftness"}]`), or "".
-fn components(s: &ItemStack) -> String {
+pub(super) fn components(s: &ItemStack) -> String {
     use horizon_world::nbt::Tag;
     let Some(Tag::Compound(entries)) = horizon_client::item_data::encode_components(s) else {
         return String::new();
diff --git a/crates/horizon-client/src/game/mods.rs b/crates/horizon-client/src/game/mods.rs
index 156467e7a..40298a922 100644
--- a/crates/horizon-client/src/game/mods.rs
+++ b/crates/horizon-client/src/game/mods.rs
@@ -76,6 +76,9 @@ pub(super) struct ModsState {
     /// The recipe book's known displays, and the book's version they are of.
     #[cfg(feature = "mods")]
     pub(super) known_recipes: (Option<u64>, std::sync::Arc<[i32]>),
+    /// Capability `ui`'s item panel beside container screens.
+    #[cfg(feature = "mods")]
+    pub(super) browser: super::mod_browser::Browser,
     /// Extras that are official mods now, being installed.
     #[cfg(feature = "mods")]
     pub(super) moved: super::moved_extras::MovedState,

From 823941756f2981a76611538c1e66351b43da8b02 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 17:46:53 +0100
Subject: [PATCH 151/475] block_removal: print a merged orb once per count on
 both sides

Whether two orbs merge (ExperienceOrb.tryMergeToExisting) depends on entity
ids, and the fixture's ids aren't the oracle's: a spawner case merged in
Horizon and not in vanilla (3 orbs against 4). Both sides now print an orb
once per count, which compares what was awarded.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../horizon-client/src/game/dispense_fixture.rs  | 16 ++++++++++------
 .../parity/VanillaDispenserOracle.java           | 14 +++++++++++++-
 2 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/crates/horizon-client/src/game/dispense_fixture.rs b/crates/horizon-client/src/game/dispense_fixture.rs
index 267f323c3..a3ac8dcad 100644
--- a/crates/horizon-client/src/game/dispense_fixture.rs
+++ b/crates/horizon-client/src/game/dispense_fixture.rs
@@ -1126,14 +1126,18 @@ impl Game<'_> {
             let (p, v) = (b.position, b.velocity);
             out.push(line(&kind, [p.x, p.y, p.z], [v.x, v.y, v.z], ""));
         }
+        // A merged orb prints once per count, as the oracle does: whether orbs
+        // merge depends on entity ids, which differ from vanilla's.
         for o in &self.orbs {
             let (p, v) = (o.position, o.velocity);
-            out.push(line(
-                "minecraft:experience_orb",
-                [p.x, p.y, p.z],
-                [v.x, v.y, v.z],
-                "",
-            ));
+            for _ in 0..o.count.max(1) {
+                out.push(line(
+                    "minecraft:experience_orb",
+                    [p.x, p.y, p.z],
+                    [v.x, v.y, v.z],
+                    "",
+                ));
+            }
         }
         for c in &self.carts {
             let (p, v) = (c.position, c.velocity);
diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDispenserOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDispenserOracle.java
index a529ae6ac..b83634f94 100644
--- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDispenserOracle.java
+++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDispenserOracle.java
@@ -461,7 +461,9 @@ public final class VanillaDispenserOracle {
             line.append(' ').append(num(v.x)).append(' ').append(num(v.y)).append(' ').append(num(v.z));
             if (e instanceof ItemEntity item) line.append(' ').append(ParityData.canon(item.getItem()));
             if (e instanceof PrimedTnt tnt) line.append(" fuse=").append(tnt.getFuse());
-            result.add(line.toString());
+            // An orb that took others in (ExperienceOrb.tryMergeToExisting) prints once per
+            // count: whether orbs merge depends on entity ids, which Horizon doesn't share.
+            for (int n = e instanceof ExperienceOrb orb ? orbCount(orb) : 1; n > 0; n--) result.add(line.toString());
         }
         for (int i = 0; i < targets.size(); i++) result.add(describe(i, targets.get(i)));
         for (String s : w.log.toString().split("\n")) {
@@ -821,6 +823,16 @@ public final class VanillaDispenserOracle {
     }
 
     /** A target's state after dispensing: removal, equipment and readiness for shearing. */
+    static int orbCount(ExperienceOrb orb) {
+        try {
+            var f = ExperienceOrb.class.getDeclaredField("count");
+            f.setAccessible(true);
+            return f.getInt(orb);
+        } catch (ReflectiveOperationException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
     static String describe(int index, Entity e) {
         StringBuilder line = new StringBuilder("T " + index + " " + BuiltInRegistries.ENTITY_TYPE.getKey(e.getType()));
         if (e.isRemoved()) line.append(" removed");

From b8da45f5ef2d4b1b1584b0255b36ef389ac18a10 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 17:51:32 +0100
Subject: [PATCH 152/475] mods: browser's page event names the first recipe
 shown, set-recipes' indexes are its list's

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-mod-sdk/wit/horizon.wit        | 14 ++++++++------
 crates/horizon-mods/tests/ui_guest/src/lib.rs |  2 +-
 docs/api/mods-reference.md                    |  8 ++++----
 3 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit
index ab20648d8..38a0e5879 100644
--- a/crates/horizon-mod-sdk/wit/horizon.wit
+++ b/crates/horizon-mod-sdk/wit/horizon.wit
@@ -533,10 +533,10 @@ interface browser {
         key: string,
         stack: stack,
     }
-    /// A click on a slot of the recipe the panel shows (`set-recipes`).
+    /// A click on a slot of a recipe the panel shows (`set-recipes`).
     record slot-click {
-        /// The recipe's index on the page and the slot's in it; the
-        /// results come after the slots.
+        /// The recipe's index in `set-recipes`'s list and the slot's in
+        /// it; the results come after the slots.
         recipe: u32,
         slot: u32,
         /// The stack the slot showed at that moment.
@@ -549,10 +549,12 @@ interface browser {
         search(string),
         key(item-key),
         slot-clicked(slot-click),
-        /// The action button of the recipe at this index on the page.
+        /// The action button of the recipe at this index in
+        /// `set-recipes`'s list.
         action(u32),
-        /// The page arrows of `set-recipes`: -1 or 1.
-        page(s32),
+        /// The player turned the recipes' page (`set-recipes`): the index
+        /// of the first recipe now shown.
+        page(u32),
         /// The back button of `set-recipes`.
         back,
     }
diff --git a/crates/horizon-mods/tests/ui_guest/src/lib.rs b/crates/horizon-mods/tests/ui_guest/src/lib.rs
index 4fc2ee2c4..43aa207e0 100644
--- a/crates/horizon-mods/tests/ui_guest/src/lib.rs
+++ b/crates/horizon-mods/tests/ui_guest/src/lib.rs
@@ -330,7 +330,7 @@ impl Mod for Guest {
                             format!("slot {} {} {}", c.recipe, c.slot, stack(&c.stack))
                         }
                         browser::Event::Action(i) => format!("action {i}"),
-                        browser::Event::Page(step) => format!("page {step}"),
+                        browser::Event::Page(first) => format!("page {first}"),
                         browser::Event::Back => "back".into(),
                     });
                 }
diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md
index 111fefd5c..298db26ba 100644
--- a/docs/api/mods-reference.md
+++ b/docs/api/mods-reference.md
@@ -567,11 +567,11 @@ A key the mod registered (`input.register-key`) went down while the pointer was
 
 ### record `slot-click`
 
-A click on a slot of the recipe the panel shows (`set-recipes`).
+A click on a slot of a recipe the panel shows (`set-recipes`).
 
 | Field | Type | |
 | --- | --- | --- |
-| `recipe` | `u32` | The recipe's index on the page and the slot's in it; the results come after the slots. |
+| `recipe` | `u32` | The recipe's index in `set-recipes`'s list and the slot's in it; the results come after the slots. |
 | `slot` | `u32` |  |
 | `stack` | `stack` | The stack the slot showed at that moment. |
 | `right` | `bool` |  |
@@ -584,8 +584,8 @@ A click on a slot of the recipe the panel shows (`set-recipes`).
 | `search` | `string` | The search box's text, each time the player changes it. |
 | `key` | `item-key` |  |
 | `slot-clicked` | `slot-click` |  |
-| `action` | `u32` | The action button of the recipe at this index on the page. |
-| `page` | `s32` | The page arrows of `set-recipes`: -1 or 1. |
+| `action` | `u32` | The action button of the recipe at this index in `set-recipes`'s list. |
+| `page` | `u32` | The player turned the recipes' page (`set-recipes`): the index of the first recipe now shown. |
 | `back` |  | The back button of `set-recipes`. |
 
 | Function | Signature | What it does |

From b37528f5d6e1f87ff59fdf40763c9ae3ce9f9cc1 Mon Sep 17 00:00:00 2001
From: socksprox <info@shadowfly.net>
Date: Mon, 26 Oct 2026 17:51:54 +0100
Subject: [PATCH 153/475] Pause menu: server links

ClientboundServerLinksPacket (configuration and play) decoded and kept,
the pause menu gains its "Server Links..." button when a server sends
links, opening the server_links dialog screen: scrollable link buttons,
ConfirmLinkScreen on click (chatLinks/chatLinksPrompt honoured), and the
custom-screens warning with its disconnect. A dedicated server sends its
`bug-report-link` property as the BUG_REPORT link, like vanilla.

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 crates/horizon-client/src/game.rs             |  32 ++
 crates/horizon-client/src/game/agent.rs       |   3 +
 crates/horizon-client/src/game/control.rs     |   3 +
 crates/horizon-client/src/game/dedicated.rs   |  16 +
 crates/horizon-client/src/game/packs.rs       |   4 +
 crates/horizon-client/src/game/remote.rs      |   9 +
 crates/horizon-client/src/game/screens.rs     |  91 +++-
 .../horizon-client/src/game/server_links.rs   | 487 ++++++++++++++++++
 crates/horizon-client/src/lan/conn.rs         |  10 +
 crates/horizon-client/src/lan/mod.rs          |   5 +
 crates/horizon-client/src/net.rs              |   9 +
 crates/horizon-client/src/options_ui.rs       |   5 +
 crates/horizon-client/src/settings.rs         |   4 +
 .../src/packets/configuration.rs              |  61 +++
 crates/horizon-protocol/src/packets/play.rs   |   5 +-
 15 files changed, 726 insertions(+), 18 deletions(-)
 create mode 100644 crates/horizon-client/src/game/server_links.rs

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 755a00f6f..ca9e7110a 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -150,6 +150,7 @@ mod scoreboard;
 mod screens;
 mod sculk;
 mod sculk_fixture;
+mod server_links;
 mod server_mods;
 mod server_packs;
 mod server_travel;
@@ -490,6 +491,12 @@ enum Screen {
     Friends,
     /// CommandBlockEditScreen (game/command_blocks.rs).
     CommandBlock,
+    /// ServerLinksDialogScreen: a server's links (game/server_links.rs).
+    ServerLinks,
+    /// ConfirmLinkScreen for a server link (game/server_links.rs).
+    ConfirmLink,
+    /// DialogScreen.WarningScreen: the note about custom screens.
+    DialogWarning,
     /// WinScreen: the end poem and the credits (game/win.rs).
     Win,
     /// A `ui` mod's own screen, or its settings page from Options > Mods
@@ -1641,6 +1648,8 @@ struct Game<'a> {
     restore_player_state: bool,
     stats_ui: stats_screen::StatsUi,
     adv_ui: advancements_screen::AdvUi,
+    /// The Server Links screens' state (game/server_links.rs).
+    links_ui: server_links::LinksUi,
     camera_type: perspective::CameraType,
     fangs: fangs::FangState,
     /// The local player as a model (third person, the inventory).
@@ -4765,6 +4774,9 @@ impl Game<'_> {
                     | Screen::Advancements
                     | Screen::WorldOptions
                     | Screen::Friends
+                    | Screen::ServerLinks
+                    | Screen::ConfirmLink
+                    | Screen::DialogWarning
                     | Screen::CommandBlock
             ) || self.book.is_some()
                 || self.win_screen_pauses())
@@ -5248,6 +5260,9 @@ impl Game<'_> {
             Screen::Advancements => self.draw_advancements(&mut batch),
             Screen::WorldOptions => self.draw_world_options(&mut batch),
             Screen::Friends => self.draw_friends_screen(&mut batch),
+            Screen::ServerLinks => self.draw_server_links(&mut batch),
+            Screen::ConfirmLink => self.draw_confirm_link(&mut batch),
+            Screen::DialogWarning => self.draw_dialog_warning(&mut batch),
             Screen::CommandBlock => self.draw_command_block(&mut batch),
             Screen::Inventory => {
                 self.draw_inventory(&mut batch);
@@ -10786,6 +10801,10 @@ impl Game<'_> {
                 Screen::GameModeSwitcher => self.close_gamemode_switcher(false),
                 Screen::Dead => {}
                 Screen::Stats | Screen::Friends => self.screen = Screen::Paused,
+                Screen::ServerLinks => self.screen = Screen::Paused,
+                // ConfirmScreen.keyPressed: Escape answers no; both return to
+                // the Server Links screen they came from.
+                Screen::ConfirmLink | Screen::DialogWarning => self.screen = Screen::ServerLinks,
                 Screen::Advancements => self.close_advancements(),
                 Screen::WorldOptions => self.world_options_escape(),
                 Screen::CommandBlock => self.close_command_block(),
@@ -11465,6 +11484,9 @@ impl ApplicationHandler for Game<'_> {
                     if self.screen == Screen::WorldOptions && d != 0.0 {
                         self.world_options_scroll(d);
                     }
+                    if self.screen == Screen::ServerLinks && d != 0.0 {
+                        self.server_links_scroll(d);
+                    }
                     if self.screen == Screen::Advancements {
                         self.advancements_scroll(scaled(raw_x) as f32, d);
                     }
@@ -11655,6 +11677,15 @@ impl ApplicationHandler for Game<'_> {
                         Screen::WorldOptions if pressed && button == MouseButton::Left => {
                             self.world_options_click()
                         }
+                        Screen::ServerLinks if pressed && button == MouseButton::Left => {
+                            self.server_links_click()?
+                        }
+                        Screen::ConfirmLink if pressed && button == MouseButton::Left => {
+                            self.confirm_link_click()
+                        }
+                        Screen::DialogWarning if pressed && button == MouseButton::Left => {
+                            self.dialog_warning_click()?
+                        }
                         Screen::WorldOptions if button == MouseButton::Left => {
                             self.world_options_release()
                         }
@@ -12511,6 +12542,7 @@ impl<'a> Game<'a> {
             restore_player_state: true,
             stats_ui: Default::default(),
             adv_ui: Default::default(),
+            links_ui: Default::default(),
             camera_type: Default::default(),
             fangs: Default::default(),
             player_model: None,
diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs
index fa9dbf3c6..0b82ac0b8 100644
--- a/crates/horizon-client/src/game/agent.rs
+++ b/crates/horizon-client/src/game/agent.rs
@@ -419,6 +419,9 @@ impl Game<'_> {
             Screen::Advancements => "advancements",
             Screen::WorldOptions => "world-options",
             Screen::Friends => "friends",
+            Screen::ServerLinks => "server-links",
+            Screen::ConfirmLink => "confirm-link",
+            Screen::DialogWarning => "dialog-warning",
             Screen::CommandBlock => "command-block",
             Screen::Win => "win",
             Screen::Mod => "mod",
diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs
index 3202b23f4..6c910ab8a 100644
--- a/crates/horizon-client/src/game/control.rs
+++ b/crates/horizon-client/src/game/control.rs
@@ -875,6 +875,9 @@ impl Game<'_> {
             Screen::Advancements => "advancements",
             Screen::WorldOptions => "world-options",
             Screen::Friends => "friends",
+            Screen::ServerLinks => "server-links",
+            Screen::ConfirmLink => "confirm-link",
+            Screen::DialogWarning => "dialog-warning",
             Screen::CommandBlock => "command-block",
             Screen::Win => "win",
             Screen::Mod => "mod",
diff --git a/crates/horizon-client/src/game/dedicated.rs b/crates/horizon-client/src/game/dedicated.rs
index fa5365195..10e10cd31 100644
--- a/crates/horizon-client/src/game/dedicated.rs
+++ b/crates/horizon-client/src/game/dedicated.rs
@@ -618,6 +618,22 @@ impl Game<'_> {
                 log_ips: props.log_ips,
             }),
             resource_pack: props.resource_pack.clone(),
+            // DedicatedServer.serverLinks: `bug-report-link` as the only link
+            // (ServerLinks.KnownLinkType.BUG_REPORT is id 0).
+            server_links: if props.bug_report_link.is_empty() {
+                Vec::new()
+            } else if super::server_links::valid_untrusted_uri(&props.bug_report_link) {
+                vec![horizon_protocol::packets::configuration::ServerLink {
+                    kind: horizon_protocol::packets::configuration::ServerLinkKind::Known(0),
+                    link: props.bug_report_link.clone(),
+                }]
+            } else {
+                log(
+                    "WARN",
+                    &format!("Failed to parse bug link {}", props.bug_report_link),
+                );
+                Vec::new()
+            },
         };
         let config = HubConfig {
             default_game_mode: game_mode,
diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs
index ee57e9f2b..e5026cd17 100644
--- a/crates/horizon-client/src/game/packs.rs
+++ b/crates/horizon-client/src/game/packs.rs
@@ -34,6 +34,10 @@ pub fn open_folder(dir: &Path) {
         log::warn!("Horizon: could not open {}: {e}", dir.display());
     }
 }
+/// `Util.getPlatform().openUri`: the system browser on the link.
+pub fn open_uri(uri: &str) {
+    open_folder(Path::new(uri));
+}
 /// The resource root to load from, given the vanilla root, the selection and
 /// a server's packs, which go on top (`Pack.Position.TOP`, fixed).
 pub fn startup_root(
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3ef87c201..6e770aaeb 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -212,6 +212,9 @@ pub(super) struct Remote {
     /// `ClientboundTransferPacket`'s target: when the connection ends the
     /// game connects here, the stored cookies carried over (`TransferState`).
     transfer: Option<String>,
+    /// `ClientCommonPacketListenerImpl.serverLinks`: the links "Server
+    /// Links..." in the pause menu lists (only `http`/`https` URIs kept).
+    pub(super) server_links: Vec<horizon_protocol::packets::configuration::ServerLink>,
 }
 
 /// The time a frame spends on chunk packets before it leaves the rest of
@@ -486,6 +489,7 @@ impl Game<'_> {
             chunk_center: (0, 0),
             backlog: VecDeque::new(),
             backlog_since: None,
+            server_links: Vec::new(),
             transfer: None,
         });
         // The level's TickRateManager follows the server's ticking packets.
@@ -862,6 +866,11 @@ impl Game<'_> {
                 }
                 Event::PackPush(p) => self.handle_pack_push(p),
                 Event::PackPop(id) => self.handle_pack_pop(id),
+                Event::ServerLinks(links) => {
+                    if let Some(r) = self.remote.as_mut() {
+                        r.server_links = super::server_links::trusted(links);
+                    }
+                }
                 Event::ShowDialog(dialog) => self.show_dialog(&dialog),
                 Event::ClearDialog => self.clear_dialog(),
                 Event::DecodeError(e) => {
diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs
index f8885f83a..750895adb 100644
--- a/crates/horizon-client/src/game/screens.rs
+++ b/crates/horizon-client/src/game/screens.rs
@@ -19,6 +19,9 @@ impl Screen {
             | Self::Advancements
             | Self::WorldOptions
             | Self::Friends
+            | Self::ServerLinks
+            | Self::ConfirmLink
+            | Self::DialogWarning
             | Self::Mod => true,
             Self::Playing
             | Self::GameModeSwitcher
@@ -35,20 +38,35 @@ impl Screen {
 }
 
 /// PauseScreen buttons: (x, y, width, label key, action id, active).
+/// `links`: the `minecraft:server_links` dialog's button, which the
+/// `pause_screen_additions` tag (empty in vanilla) falls back to when the
+/// server sent links — a full-width row that pushes the last two rows down.
 /// https://mcsrc.dev/2/26.3/net/minecraft/client/gui/screens/PauseScreen
-fn pause_buttons(w: f32, h: f32, remote: bool) -> Vec<(f32, f32, f32, &'static str, u8, bool)> {
+fn pause_buttons(
+    w: f32,
+    h: f32,
+    remote: bool,
+    links: bool,
+) -> Vec<(f32, f32, f32, &'static str, u8, bool)> {
     // GridLayout of two 98px columns (padding 4), aligned at (0.5, 0.25).
-    let (grid_w, grid_h) = (212.0, 166.0);
+    let (grid_w, grid_h) = (212.0, 166.0 + if links { 24.0 } else { 0.0 });
     let x0 = ((w - grid_w) * 0.5).floor();
     let y0 = ((h - grid_h) * 0.25).floor();
-    vec![
+    let down = if links { 24.0 } else { 0.0 };
+    let mut v = vec![
         (x0 + 4.0, y0 + 50.0, 204.0, "menu.returnToGame", 0, true),
         (x0 + 4.0, y0 + 74.0, 98.0, "gui.advancements", 4, true),
         (x0 + 110.0, y0 + 74.0, 98.0, "gui.stats", 3, true),
-        (x0 + 4.0, y0 + 122.0, 98.0, "menu.options", 1, true),
+    ];
+    if links {
+        // CommonDialogData.computeExternalTitle of Dialogs.SERVER_LINKS.
+        v.push((x0 + 4.0, y0 + 122.0, 204.0, "menu.server_links", 11, true));
+    }
+    v.extend([
+        (x0 + 4.0, y0 + 122.0 + down, 98.0, "menu.options", 1, true),
         (
             x0 + 110.0,
-            y0 + 122.0,
+            y0 + 122.0 + down,
             98.0,
             "options.worldOptions.button",
             9,
@@ -56,7 +74,7 @@ fn pause_buttons(w: f32, h: f32, remote: bool) -> Vec<(f32, f32, f32, &'static s
         ),
         (
             x0 + 4.0,
-            y0 + 146.0,
+            y0 + 146.0 + down,
             204.0,
             if remote {
                 "menu.disconnect"
@@ -66,16 +84,17 @@ fn pause_buttons(w: f32, h: f32, remote: bool) -> Vec<(f32, f32, f32, &'static s
             2,
             true,
         ),
-    ]
+    ]);
+    v
 }
 
 /// The icon row: report bugs, feedback, friends, player reporting.
 /// `FRIENDS_ICON` (vanilla's `CommonButtons.friends`) opens Horizon's
 /// Play with Friends; the others stay inactive.
 const FRIENDS_ICON: usize = 2;
-fn pause_icons(w: f32, h: f32) -> [(f32, f32, &'static str); 4] {
+fn pause_icons(w: f32, h: f32, links: bool) -> [(f32, f32, &'static str); 4] {
     let x0 = ((w - 212.0) * 0.5).floor() + 60.0;
-    let y = ((h - 166.0) * 0.25).floor() + 98.0;
+    let y = ((h - 166.0 - if links { 24.0 } else { 0.0 }) * 0.25).floor() + 98.0;
     [
         (x0, y, "gui/sprites/pause_menu/bug"),
         (x0 + 24.0, y, "gui/sprites/pause_menu/social_interactions"),
@@ -120,7 +139,9 @@ impl Game<'_> {
             u32::MAX,
             true,
         );
-        for (x, y, bw, key, _, active) in pause_buttons(w, h, self.external_server()) {
+        let links = !self.server_links().is_empty();
+        let mut tooltip = None;
+        for (x, y, bw, key, id, active) in pause_buttons(w, h, self.external_server(), links) {
             let hover = active && ui::hovered(self.cursor, x, y, bw, 20.0);
             ui::button(
                 batch,
@@ -133,9 +154,12 @@ impl Game<'_> {
                 active,
                 hover,
             );
+            // PauseScreen's customAdditions button: CUSTOM_OPTIONS_TOOLTIP.
+            if id == 11 && hover {
+                tooltip = Some(Text::translate("menu.custom_options.tooltip", &[]));
+            }
         }
-        let mut tooltip = None;
-        for (i, (x, y, sprite)) in pause_icons(w, h).into_iter().enumerate() {
+        for (i, (x, y, sprite)) in pause_icons(w, h, links).into_iter().enumerate() {
             let active = i == FRIENDS_ICON && friends;
             let hover = ui::hovered(self.cursor, x, y, 20.0, 20.0);
             // The icon has no label: name it for controller focus and the
@@ -168,7 +192,13 @@ impl Game<'_> {
         }
         // SpriteIconButton.withTootip: the label as a tooltip.
         if let Some(tip) = tooltip {
-            ui::tooltip(batch, atlas, &[tip], self.cursor);
+            let lines: Vec<Text> = atlas
+                .font
+                .split_lines(&tip, batch.width)
+                .into_iter()
+                .map(|(line, _)| line)
+                .collect();
+            ui::tooltip(batch, atlas, &lines, self.cursor);
         }
     }
     pub(super) fn pause_click(&mut self) -> Result<()> {
@@ -180,8 +210,9 @@ impl Game<'_> {
             let b = HudBatch::new(size);
             (b.width, b.height)
         };
-        let friends = pause_icons(w, h)[FRIENDS_ICON];
-        let hit = pause_buttons(w, h, self.external_server())
+        let links = !self.server_links().is_empty();
+        let friends = pause_icons(w, h, links)[FRIENDS_ICON];
+        let hit = pause_buttons(w, h, self.external_server(), links)
             .into_iter()
             .find(|b| b.5 && ui::hovered(self.cursor, b.0, b.1, b.2, 20.0))
             .map(|b| b.4)
@@ -200,6 +231,11 @@ impl Game<'_> {
             Some(4) => self.open_advancements(true),
             Some(9) => self.open_world_options(),
             Some(10) => self.screen = Screen::Friends,
+            // DialogConnectionAccess.openDialog(Dialogs.SERVER_LINKS).
+            Some(11) => {
+                self.links_ui.scroll = 0.0;
+                self.screen = Screen::ServerLinks;
+            }
             Some(2) => self.close_world()?,
             _ => {}
         }
@@ -357,7 +393,7 @@ impl Game<'_> {
 
 #[cfg(test)]
 mod tests {
-    use super::{Screen, pause_buttons};
+    use super::{Screen, pause_buttons, pause_icons};
 
     #[test]
     fn menu_blur_matches_vanilla_screen_backgrounds() {
@@ -390,11 +426,32 @@ mod tests {
     #[test]
     fn pause_menu_uses_disconnect_for_servers_and_keeps_world_options() {
         for (remote, label) in [(false, "menu.returnToMenu"), (true, "menu.disconnect")] {
-            let buttons = pause_buttons(427.0, 240.0, remote);
+            let buttons = pause_buttons(427.0, 240.0, remote, false);
             let quit = buttons.iter().find(|b| b.4 == 2).unwrap();
             assert_eq!(quit.3, label);
             assert!(quit.5);
             assert!(buttons.iter().any(|b| b.4 == 9 && b.5));
         }
     }
+
+    #[test]
+    fn server_links_adds_a_full_width_row_above_options() {
+        let with = pause_buttons(427.0, 240.0, true, true);
+        let without = pause_buttons(427.0, 240.0, true, false);
+        let links = with.iter().find(|b| b.4 == 11).unwrap();
+        assert_eq!(links.2, 204.0);
+        assert_eq!(links.3, "menu.server_links");
+        assert!(links.5);
+        // The icon row sits above it; Options and Disconnect move down 24.
+        let icons = pause_icons(427.0, 240.0, true);
+        let y0_icons = ((240.0f32 - 190.0) * 0.25).floor() + 98.0;
+        assert_eq!(icons[0].1, y0_icons);
+        assert!(links.1 > icons[0].1);
+        for b in &with {
+            if b.4 == 1 || b.4 == 9 || b.4 == 2 {
+                let same = without.iter().find(|o| o.4 == b.4).unwrap();
+                assert_eq!(b.1, same.1 + 24.0 - 6.0, "{}", b.3);
+            }
+        }
+    }
 }
diff --git a/crates/horizon-client/src/game/server_links.rs b/crates/horizon-client/src/game/server_links.rs
new file mode 100644
index 000000000..85fda71d6
--- /dev/null
+++ b/crates/horizon-client/src/game/server_links.rs
@@ -0,0 +1,487 @@
+//! `ServerLinksDialogScreen`: the pause menu's "Server Links..." button opens
+//! the `minecraft:server_links` dialog (the `pause_screen_additions` tag's
+//! fallback when a server sent ClientboundServerLinksPacket): a scrollable
+//! list of the server's links, each opened through `ConfirmLinkScreen`
+//! (Screen.clickUrlAction), and the `dialog/warning_button`'s
+//! DialogScreen.WarningScreen ("Note about custom screens").
+//! https://mcsrc.dev/2/26.3/net/minecraft/client/gui/screens/dialog/ServerLinksDialogScreen
+use super::{Game, Screen, packs::open_uri};
+use horizon_client::{Result, clipboard::Clipboard, hud::HudBatch, text::Text, ui};
+use horizon_protocol::packets::configuration::{ServerLink, ServerLinkKind};
+
+/// HeaderAndFooterLayout's header and footer heights; the content wants to
+/// start 30 pixels under the header (its `CONTENTS_MARGIN_TOP`).
+const HEADER: f32 = 33.0;
+const FOOTER: f32 = 33.0;
+const CONTENT_TOP: f32 = HEADER + 30.0;
+/// `server_links.json`: `columns` 1, `button_width` 310, `exit_action`'s 200.
+const LINK_WIDTH: f32 = 310.0;
+/// packControlsIntoColumns: rowSpacing 2 under the 20-pixel buttons.
+const ROW: f32 = 22.0;
+/// ScrollableLayout's BOTH reserve (scrollbarSpacing 4 + SCROLLBAR_WIDTH 6).
+const SCROLL_RESERVE: f32 = 10.0;
+/// DialogScreen's `dialog/warning_button` ImageButton.
+const WARNING_BUTTON: f32 = 20.0;
+
+/// The ServerLinks screen's state: ScrollableLayout's scroll and the link
+/// ConfirmLinkScreen is asking about (`Screen::ConfirmLink`).
+#[derive(Default)]
+pub(super) struct LinksUi {
+    pub scroll: f32,
+    pub confirm: Option<String>,
+}
+
+/// `Util.parseAndValidateUntrustedUri`: an absolute `http`/`https` URI
+/// (java.net.URI's scheme then the allowlist; whitespace-free).
+pub(super) fn valid_untrusted_uri(uri: &str) -> bool {
+    let Some(colon) = uri.find(':') else {
+        return false;
+    };
+    let scheme = &uri[..colon];
+    let mut chars = scheme.chars();
+    if !chars.next().is_some_and(|c| c.is_ascii_alphabetic())
+        || !chars.all(|c| c.is_ascii_alphanumeric() || matches!(c, '+' | '-' | '.'))
+    {
+        return false;
+    }
+    if !matches!(scheme.to_ascii_lowercase().as_str(), "http" | "https") {
+        return false;
+    }
+    !uri.chars().any(|c| c.is_control() || c == ' ')
+}
+/// `ClientCommonPacketListenerImpl.handleServerLinks`: keep only the links
+/// that validate, warning about the dropped ones.
+pub(super) fn trusted(links: Vec<ServerLink>) -> Vec<ServerLink> {
+    links
+        .into_iter()
+        .filter(|l| {
+            let ok = valid_untrusted_uri(&l.link);
+            if !ok {
+                log::warn!("Horizon: server sent an invalid link: {}", l.link);
+            }
+            ok
+        })
+        .collect()
+}
+/// `ServerLinks.Entry.displayName`: `known_server_link.<name>` for a known
+/// type (ByIdMap.ZERO reads unknown ids as `report_bug`), the component else.
+fn link_label(link: &ServerLink) -> Text {
+    const KNOWN: [&str; 10] = [
+        "report_bug",
+        "community_guidelines",
+        "support",
+        "status",
+        "feedback",
+        "community",
+        "website",
+        "forums",
+        "news",
+        "announcements",
+    ];
+    match &link.kind {
+        ServerLinkKind::Known(id) => Text::translate(
+            &format!(
+                "known_server_link.{}",
+                KNOWN.get(*id as usize).copied().unwrap_or(KNOWN[0])
+            ),
+            &[],
+        ),
+        ServerLinkKind::Custom(tag) => {
+            horizon_client::scoreboard::comp_text(&horizon_client::scoreboard::tag_to_json(tag))
+        }
+    }
+}
+
+/// The scrolled column of link buttons: content height and, for a list that
+/// fits, the `HeaderAndFooterLayout` contents frame's top.
+fn list_height(n: usize) -> f32 {
+    n as f32 * ROW - 2.0
+}
+fn list_top(h: f32, n: usize) -> f32 {
+    CONTENT_TOP.min(h - FOOTER - list_height(n).min(h - HEADER - FOOTER))
+}
+fn scroll_limit(h: f32, n: usize) -> f32 {
+    (list_height(n) - (h - HEADER - FOOTER)).max(0.0)
+}
+
+/// `ServerLinksScreen`'s buttons as (x, y) over the scrolled content, and the
+/// footer `Back` button's corner. `top` includes the scroll.
+fn link_buttons(w: f32, top: f32, n: usize) -> Vec<(f32, f32)> {
+    let x = ((w - LINK_WIDTH - 2.0 * SCROLL_RESERVE) / 2.0 + SCROLL_RESERVE).floor();
+    (0..n).map(|i| (x, top + i as f32 * ROW)).collect()
+}
+/// The warning button beside the title (DialogScreen's title row: 10 pixels
+/// apart), clamped onto the screen (makeSureWarningButtonIsInBounds).
+fn warning_button(w: f32, h: f32, title_width: f32) -> (f32, f32) {
+    let x = ((w - title_width - 30.0) / 2.0).floor() + title_width + 10.0;
+    let y = ((HEADER - WARNING_BUTTON) / 2.0).floor();
+    if x < 0.0 || y < 0.0 || x > w - WARNING_BUTTON || y > h - WARNING_BUTTON {
+        (0.0f32.max(w - 40.0), 5.0f32.min(h))
+    } else {
+        (x, y)
+    }
+}
+fn back_button(w: f32, h: f32) -> (f32, f32) {
+    (
+        ((w - 200.0) / 2.0).floor(),
+        h - FOOTER + ((FOOTER - 20.0) / 2.0).floor(),
+    )
+}
+
+impl Game<'_> {
+    /// `connection.serverLinks()`: the links the open server sent (empty for
+    /// a world without a connection or one that sent none).
+    pub(super) fn server_links(&self) -> &[ServerLink] {
+        self.remote
+            .as_ref()
+            .map_or(&[], |r| r.server_links.as_slice())
+    }
+    /// DialogScreen over the pause menu: `menu.server_links.title`, the
+    /// scrollable link buttons and `gui.back` in the footer.
+    pub(super) fn draw_server_links(&mut self, batch: &mut HudBatch) {
+        let atlas = &self.gui.atlas;
+        let (w, h) = (batch.width, batch.height);
+        ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true);
+        let links = self.server_links().to_vec();
+        self.links_ui.scroll = self
+            .links_ui
+            .scroll
+            .clamp(0.0, scroll_limit(h, links.len()));
+        let top = list_top(h, links.len()) - self.links_ui.scroll.trunc();
+        // The title row: the title, then 10 pixels on the warning button.
+        let title = Text::translate("menu.server_links.title", &[]);
+        let tw = atlas.font.width_text(&title);
+        let tx = ((w - tw - 30.0) / 2.0).floor();
+        batch.text_styled(atlas, &title, tx, 12.0, u32::MAX, true);
+        let (wx, wy) = warning_button(w, h, tw);
+        let wh = ui::hovered(self.cursor, wx, wy, WARNING_BUTTON, WARNING_BUTTON);
+        horizon_client::widgets::record(
+            "menu.custom_screen_info.tooltip",
+            [wx, wy, WARNING_BUTTON, WARNING_BUTTON],
+            true,
+        );
+        batch.sprite_scaled(
+            atlas,
+            if wh {
+                "gui/sprites/dialog/warning_button_highlighted"
+            } else {
+                "gui/sprites/dialog/warning_button"
+            },
+            wx,
+            wy,
+            WARNING_BUTTON,
+            WARNING_BUTTON,
+            u32::MAX,
+        );
+        let first = batch.vertices.len();
+        let inside = self.cursor.1 >= HEADER && self.cursor.1 < h - FOOTER;
+        for (link, (x, y)) in links.iter().zip(link_buttons(w, top, links.len())) {
+            let hover = inside && ui::hovered(self.cursor, x, y, LINK_WIDTH, 20.0);
+            ui::button(
+                batch,
+                atlas,
+                x,
+                y,
+                LINK_WIDTH,
+                20.0,
+                &link_label(link),
+                true,
+                hover,
+            );
+        }
+        batch.clip_since(first, 0.0, HEADER, w, h - FOOTER);
+        ui::scrollbar(
+            batch,
+            atlas,
+            (w / 2.0).floor() + 155.0 + 4.0,
+            HEADER,
+            h - FOOTER,
+            list_height(links.len()),
+            self.links_ui.scroll.trunc(),
+        );
+        let (bx, by) = back_button(w, h);
+        let hover = ui::hovered(self.cursor, bx, by, 200.0, 20.0);
+        ui::button(
+            batch,
+            atlas,
+            bx,
+            by,
+            200.0,
+            20.0,
+            &Text::translate("gui.back", &[]),
+            true,
+            hover,
+        );
+        if wh {
+            ui::tooltip(
+                batch,
+                atlas,
+                &[Text::translate("menu.custom_screen_info.tooltip", &[])],
+                self.cursor,
+            );
+        }
+    }
+    /// A click on `Screen::ServerLinks`: a link, the warning button or Back.
+    pub(super) fn server_links_click(&mut self) -> Result<()> {
+        let (w, h) = self.gui_size();
+        let links = self.server_links().to_vec();
+        let top = list_top(h, links.len()) - self.links_ui.scroll.trunc();
+        let inside = self.cursor.1 >= HEADER && self.cursor.1 < h - FOOTER;
+        if inside
+            && let Some(i) = link_buttons(w, top, links.len())
+                .iter()
+                .position(|(x, y)| ui::hovered(self.cursor, *x, *y, LINK_WIDTH, 20.0))
+        {
+            self.audio.play_button_click();
+            self.click_link(&links[i].link);
+            return Ok(());
+        }
+        let title = Text::translate("menu.server_links.title", &[]);
+        let tw = self.gui.atlas.font.width_text(&title);
+        let (wx, wy) = warning_button(w, h, tw);
+        if ui::hovered(self.cursor, wx, wy, WARNING_BUTTON, WARNING_BUTTON) {
+            self.audio.play_button_click();
+            self.screen = Screen::DialogWarning;
+            return Ok(());
+        }
+        let (bx, by) = back_button(w, h);
+        if ui::hovered(self.cursor, bx, by, 200.0, 20.0) {
+            self.audio.play_button_click();
+            self.screen = Screen::Paused;
+        }
+        Ok(())
+    }
+    /// `Screen.clickUrlAction`: "Web Links" off ignores the click; "Prompt on
+    /// Links" asks with ConfirmLinkScreen, else the browser opens directly.
+    fn click_link(&mut self, url: &str) {
+        if !self.settings.chat_links {
+            return;
+        }
+        if self.settings.chat_links_prompt {
+            self.links_ui.confirm = Some(url.to_owned());
+            self.screen = Screen::ConfirmLink;
+        } else {
+            open_uri(url);
+        }
+    }
+    /// `ScrollableLayout`'s mouse wheel over the links.
+    pub(super) fn server_links_scroll(&mut self, delta: f32) {
+        let (_, h) = self.gui_size();
+        self.links_ui.scroll = (self.links_ui.scroll - delta * 10.0)
+            .clamp(0.0, scroll_limit(h, self.server_links().len()));
+    }
+    /// `ConfirmLinkScreen` (untrusted): "Are you sure you want to open the
+    /// following website?", the link, the red warning, and Yes / Copy Link to
+    /// Clipboard / No.
+    pub(super) fn draw_confirm_link(&mut self, batch: &mut HudBatch) {
+        let atlas = &self.gui.atlas;
+        let (w, h) = (batch.width, batch.height);
+        ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true);
+        let url = self.links_ui.confirm.clone().unwrap_or_default();
+        let layout = confirm_link_layout(atlas, (w, h), &url);
+        for (line, x, y) in &layout.lines {
+            batch.text_styled(atlas, line, *x, *y, u32::MAX, true);
+        }
+        let labels = ["gui.yes", "gui.copy_link_to_clipboard", "gui.no"];
+        for ((x, y), key) in layout.buttons.iter().zip(labels) {
+            let hover = ui::hovered(self.cursor, *x, *y, 100.0, 20.0);
+            ui::button(
+                batch,
+                atlas,
+                *x,
+                *y,
+                100.0,
+                20.0,
+                &Text::translate(key, &[]),
+                true,
+                hover,
+            );
+        }
+    }
+    /// ConfirmLinkScreen's answer: yes opens the browser, the middle button
+    /// copies the link, no closes; all return to Server Links.
+    pub(super) fn confirm_link_click(&mut self) {
+        let (w, h) = self.gui_size();
+        let url = self.links_ui.confirm.clone().unwrap_or_default();
+        let layout = confirm_link_layout(&self.gui.atlas, (w, h), &url);
+        for (i, (x, y)) in layout.buttons.iter().enumerate() {
+            if !ui::hovered(self.cursor, *x, *y, 100.0, 20.0) {
+                continue;
+            }
+            self.audio.play_button_click();
+            match i {
+                0 => open_uri(&url),
+                1 => {
+                    self.clipboard.set(&url);
+                }
+                _ => {}
+            }
+            self.screen = Screen::ServerLinks;
+            return;
+        }
+    }
+    /// `DialogScreen.WarningScreen`: the custom-screens note, a disconnect
+    /// button ("Custom screen rejected" is the shown reason) and Back.
+    pub(super) fn draw_dialog_warning(&mut self, batch: &mut HudBatch) {
+        let atlas = &self.gui.atlas;
+        let (w, h) = (batch.width, batch.height);
+        ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true);
+        let layout = dialog_warning_layout(atlas, (w, h));
+        for (line, x, y) in &layout.lines {
+            batch.text_styled(atlas, line, *x, *y, u32::MAX, true);
+        }
+        let quit = if self.external_server() {
+            "menu.disconnect"
+        } else {
+            "menu.returnToMenu"
+        };
+        for ((x, y), key) in layout.buttons.into_iter().zip([quit, "gui.back"]) {
+            let hover = ui::hovered(self.cursor, x, y, 150.0, 20.0);
+            ui::button(
+                batch,
+                atlas,
+                x,
+                y,
+                150.0,
+                20.0,
+                &Text::translate(key, &[]),
+                true,
+                hover,
+            );
+        }
+    }
+    /// WarningScreen's answer: disconnect, or back to Server Links.
+    pub(super) fn dialog_warning_click(&mut self) -> Result<()> {
+        let (w, h) = self.gui_size();
+        let layout = dialog_warning_layout(&self.gui.atlas, (w, h));
+        for (i, (x, y)) in layout.buttons.iter().enumerate() {
+            if !ui::hovered(self.cursor, *x, *y, 150.0, 20.0) {
+                continue;
+            }
+            self.audio.play_button_click();
+            if i == 0 {
+                // DialogConnectionAccess.disconnect: leave with the custom
+                // screens' reason.
+                let reason = self.translate(
+                    "menu.custom_screen_info.disconnect",
+                    "Custom screen rejected",
+                );
+                self.leave_server(Some(reason))?;
+            } else {
+                self.screen = Screen::ServerLinks;
+            }
+            return Ok(());
+        }
+        Ok(())
+    }
+}
+
+/// A confirm screen's laid-out text (title, message, extra warning lines) and
+/// button corners; the whole column centred (ConfirmScreen.init).
+struct ConfirmLayout {
+    lines: Vec<(Text, f32, f32)>,
+    buttons: Vec<(f32, f32)>,
+}
+/// `ConfirmScreen.init`: title, message wrapped to `width - 50` (15 rows at
+/// most), the extra lines, then a button row `spacing` 4 with `paddingTop` 16.
+fn confirm_layout(
+    font: &horizon_client::font::Font,
+    (w, h): (f32, f32),
+    title: &Text,
+    message: &Text,
+    extra: &[Text],
+    button_widths: &[f32],
+) -> ConfirmLayout {
+    let message: Vec<Text> = font
+        .split_lines(message, w - 50.0)
+        .into_iter()
+        .take(15)
+        .map(|(line, _)| line)
+        .collect();
+    // LinearLayout vertical spacing 8; the button row's children pad 16 on top.
+    let extra_h = 17.0 * extra.len() as f32;
+    let mh = 9.0 * message.len() as f32;
+    let total = 9.0 + 8.0 + mh + extra_h + 8.0 + 16.0 + 20.0;
+    let mut y = ((h - total) / 2.0).trunc();
+    let mut lines = Vec::new();
+    let mut push = |line: &Text, at: f32| {
+        let lw = font.width_text(line);
+        lines.push((line.clone(), ((w - lw) / 2.0).trunc(), at));
+    };
+    push(title, y);
+    y += 17.0;
+    for line in &message {
+        push(line, y);
+        y += 9.0;
+    }
+    for line in extra {
+        y += 8.0;
+        push(line, y);
+        y += 9.0;
+    }
+    let row_w: f32 = button_widths.iter().sum::<f32>() + 4.0 * (button_widths.len() - 1) as f32;
+    let by = y + 8.0 + 16.0;
+    let mut bx = ((w - row_w) / 2.0).trunc();
+    let buttons = button_widths
+        .iter()
+        .map(|bw| {
+            let p = (bx, by);
+            bx += bw + 4.0;
+            p
+        })
+        .collect();
+    ConfirmLayout { lines, buttons }
+}
+fn confirm_link_layout(
+    atlas: &horizon_client::hud::HudAtlas,
+    size: (f32, f32),
+    url: &str,
+) -> ConfirmLayout {
+    // ConfirmLinkScreen (untrusted): `chat.link.confirm`, the link as the
+    // message, `chat.link.warning` in its red (0xFFCCCC).
+    confirm_layout(
+        &atlas.font,
+        size,
+        &Text::translate("chat.link.confirm", &[]),
+        &Text::literal(url.to_owned()),
+        &[Text::translate("chat.link.warning", &[]).with_color(0xFFCCCC)],
+        &[100.0; 3],
+    )
+}
+fn dialog_warning_layout(atlas: &horizon_client::hud::HudAtlas, size: (f32, f32)) -> ConfirmLayout {
+    confirm_layout(
+        &atlas.font,
+        size,
+        &Text::translate("menu.custom_screen_info.title", &[]),
+        &Text::translate("menu.custom_screen_info.contents", &[]),
+        &[],
+        &[150.0; 2],
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn untrusted_uris_are_http_or_https_with_a_scheme() {
+        for ok in [
+            "https://example.net/x",
+            "http://example.net",
+            "HTTPS://EXAMPLE.NET",
+        ] {
+            assert!(valid_untrusted_uri(ok), "{ok}");
+        }
+        for bad in [
+            "example.net/no-scheme",
+            "ftp://example.net",
+            "file:///etc/passwd",
+            "javascript:alert(1)",
+            "https://exa mple.net",
+            "://example.net",
+            "",
+        ] {
+            assert!(!valid_untrusted_uri(bad), "{bad}");
+        }
+    }
+}
diff --git a/crates/horizon-client/src/lan/conn.rs b/crates/horizon-client/src/lan/conn.rs
index f2dcf701d..99b70e065 100644
--- a/crates/horizon-client/src/lan/conn.rs
+++ b/crates/horizon-client/src/lan/conn.rs
@@ -791,6 +791,16 @@ fn login_and_configure(
             },
         }),
     )?;
+    // ServerConfigurationPacketListenerImpl.startConfiguration: links, only
+    // when there are any (MinecraftServer.serverLinks is empty elsewhere).
+    if !shared.config.server_links.is_empty() {
+        send(
+            c,
+            cfg::Clientbound::ServerLinks(cfg::ServerLinks {
+                links: shared.config.server_links.clone(),
+            }),
+        )?;
+    }
     send(
         c,
         cfg::Clientbound::UpdateEnabledFeatures(cfg::UpdateEnabledFeatures {
diff --git a/crates/horizon-client/src/lan/mod.rs b/crates/horizon-client/src/lan/mod.rs
index 3e9b93cac..34c465ffa 100644
--- a/crates/horizon-client/src/lan/mod.rs
+++ b/crates/horizon-client/src/lan/mod.rs
@@ -142,6 +142,10 @@ pub struct NetConfig {
     /// server.properties `resource-pack`: offered to every player during
     /// configuration (a dedicated server's; MinecraftServer.getServerResourcePack).
     pub resource_pack: Option<crate::server::properties::ResourcePackInfo>,
+    /// MinecraftServer.serverLinks (a dedicated server's `bug-report-link`):
+    /// sent in configuration when non-empty
+    /// (ServerConfigurationPacketListenerImpl.startConfiguration).
+    pub server_links: Vec<horizon_protocol::packets::configuration::ServerLink>,
 }
 impl NetConfig {
     /// MinecraftServer.enforceSecureProfile.
@@ -168,6 +172,7 @@ impl NetConfig {
             online: None,
             log: None,
             resource_pack: None,
+            server_links: Vec::new(),
         }
     }
 }
diff --git a/crates/horizon-client/src/net.rs b/crates/horizon-client/src/net.rs
index 34daaf85c..93364ed91 100644
--- a/crates/horizon-client/src/net.rs
+++ b/crates/horizon-client/src/net.rs
@@ -68,6 +68,9 @@ pub enum Event {
         host: String,
         port: i32,
     },
+    /// `ClientboundServerLinksPacket`: the links the pause menu's "Server
+    /// Links..." lists (ClientCommonPacketListenerImpl.handleServerLinks).
+    ServerLinks(Vec<cfg::ServerLink>),
     /// The connection ended. `from_server`: the server gave the reason (or
     /// the connection was refused for good), rather than the connection
     /// failing (auto-reconnect retries only failures and shutdowns).
@@ -565,6 +568,9 @@ fn receive_play(
             play::Clientbound::StoreCookie(p) => {
                 cookies.lock().unwrap().insert(p.key, p.payload);
             }
+            play::Clientbound::ServerLinks(p) => {
+                let _ = send.send(Event::ServerLinks(p.links));
+            }
             // ClientCommonPacketListenerImpl.handleTransfer: the connection
             // ends and the game connects to the other address.
             play::Clientbound::Transfer(p) => {
@@ -644,6 +650,9 @@ fn configure(
             cfg::Clientbound::StoreCookie(p) => {
                 cookies.lock().unwrap().insert(p.key, p.payload);
             }
+            cfg::Clientbound::ServerLinks(p) => {
+                let _ = send.send(Event::ServerLinks(p.links));
+            }
             cfg::Clientbound::Transfer(p) => {
                 let _ = send.send(Event::Transfer {
                     host: p.host,
diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs
index 61fda9878..63c6165eb 100644
--- a/crates/horizon-client/src/options_ui.rs
+++ b/crates/horizon-client/src/options_ui.rs
@@ -56,6 +56,7 @@ pub enum Opt {
     ChatVisibility,
     ChatColors,
     ChatLinks,
+    ChatLinksPrompt,
     ChatOpacity,
     TextBackgroundOpacity,
     ChatScale,
@@ -237,6 +238,7 @@ impl Opt {
             Opt::ChatVisibility => "options.chat.visibility",
             Opt::ChatColors => "options.chat.color",
             Opt::ChatLinks => "options.chat.links",
+            Opt::ChatLinksPrompt => "options.chat.links.prompt",
             Opt::ChatOpacity => "options.chat.opacity",
             Opt::TextBackgroundOpacity => "options.accessibility.text_background_opacity",
             Opt::ChatScale => "options.chat.scale",
@@ -574,6 +576,7 @@ impl Opt {
             ][usize::from(s.chat_visibility.min(2))]),
             Opt::ChatColors => on_off(s.chat_colors),
             Opt::ChatLinks => on_off(s.chat_links),
+            Opt::ChatLinksPrompt => on_off(s.chat_links_prompt),
             Opt::AutoSuggestions => on_off(s.auto_suggestions),
             Opt::ReducedDebugInfo => on_off(s.reduced_debug_info),
             Opt::HighContrast => on_off(s.high_contrast),
@@ -743,6 +746,7 @@ impl Opt {
             Opt::ChatVisibility => s.chat_visibility = next(s.chat_visibility, 3),
             Opt::ChatColors => s.chat_colors = !s.chat_colors,
             Opt::ChatLinks => s.chat_links = !s.chat_links,
+            Opt::ChatLinksPrompt => s.chat_links_prompt = !s.chat_links_prompt,
             Opt::AutoSuggestions => s.auto_suggestions = !s.auto_suggestions,
             Opt::ReducedDebugInfo => s.reduced_debug_info = !s.reduced_debug_info,
             Opt::HighContrast => s.high_contrast = !s.high_contrast,
@@ -1487,6 +1491,7 @@ impl OptionsUi {
                 Opt::ChatVisibility,
                 Opt::ChatColors,
                 Opt::ChatLinks,
+                Opt::ChatLinksPrompt,
                 Opt::ChatOpacity,
                 Opt::TextBackgroundOpacity,
                 Opt::ChatScale,
diff --git a/crates/horizon-client/src/settings.rs b/crates/horizon-client/src/settings.rs
index 74c428923..c64cfcb33 100644
--- a/crates/horizon-client/src/settings.rs
+++ b/crates/horizon-client/src/settings.rs
@@ -149,6 +149,7 @@ pub struct Settings {
     pub chat_visibility: u8,
     pub chat_colors: bool,
     pub chat_links: bool,
+    pub chat_links_prompt: bool,
     pub chat_opacity: f32,
     pub text_background_opacity: f32,
     pub chat_scale: f32,
@@ -234,6 +235,7 @@ impl Default for Settings {
             chat_visibility: 0,
             chat_colors: true,
             chat_links: true,
+            chat_links_prompt: true,
             chat_opacity: 1.0,
             text_background_opacity: 0.5,
             chat_scale: 1.0,
@@ -427,6 +429,7 @@ impl Settings {
             chat_visibility: f.int("chatVisibility") as u8,
             chat_colors: f.bool("chatColors"),
             chat_links: f.bool("chatLinks"),
+            chat_links_prompt: f.bool("chatLinksPrompt"),
             chat_opacity: f.double("chatOpacity") as f32,
             text_background_opacity: f.double("textBackgroundOpacity") as f32,
             chat_scale: f.double("chatScale") as f32,
@@ -510,6 +513,7 @@ impl Settings {
         put_i(&mut f, "chatVisibility", i32::from(self.chat_visibility));
         put_b(&mut f, "chatColors", self.chat_colors);
         put_b(&mut f, "chatLinks", self.chat_links);
+        put_b(&mut f, "chatLinksPrompt", self.chat_links_prompt);
         put_f(&mut f, "chatOpacity", self.chat_opacity);
         put_f(
             &mut f,
diff --git a/crates/horizon-protocol/src/packets/configuration.rs b/crates/horizon-protocol/src/packets/configuration.rs
index ced56dacf..22a8a1456 100644
--- a/crates/horizon-protocol/src/packets/configuration.rs
+++ b/crates/horizon-protocol/src/packets/configuration.rs
@@ -45,6 +45,54 @@ packet!(
 packet!(KnownPack { namespace: String => Str, id: String => Str, version: String => Str });
 packet!(SelectKnownPacks { packs: Vec<KnownPack> => List<KnownPack> });
 packet!(CodeOfConduct { text: String => Str });
+
+/// ServerLinks.UntrustedEntry's `type` (Either<KnownLinkType, Component>): a
+/// known link's id, or a custom label component.
+#[derive(Clone, Debug, PartialEq)]
+pub enum ServerLinkKind {
+    /// ServerLinks.KnownLinkType by id (ByIdMap: unknown ids read as 0).
+    Known(i32),
+    /// A custom label (TRUSTED_CONTEXT_FREE_STREAM_CODEC: a component in NBT).
+    Custom(Tag),
+}
+/// ServerLinks.UntrustedEntry: the label and the unchecked link string (the
+/// client keeps only `http`/`https` URIs, Util.parseAndValidateUntrustedUri).
+#[derive(Clone, Debug, PartialEq)]
+pub struct ServerLink {
+    pub kind: ServerLinkKind,
+    pub link: String,
+}
+impl Codec<ServerLink> for ServerLink {
+    fn read(r: &mut Reader) -> Result<Self> {
+        let kind = if Bool::read(r)? {
+            ServerLinkKind::Known(VarInt::read(r)?)
+        } else {
+            ServerLinkKind::Custom(Nbt::read(r)?)
+        };
+        Ok(Self {
+            kind,
+            link: Str::read(r)?,
+        })
+    }
+    fn write(v: &Self, w: &mut Writer) {
+        match &v.kind {
+            ServerLinkKind::Known(id) => {
+                Bool::write(&true, w);
+                VarInt::write(id, w);
+            }
+            ServerLinkKind::Custom(tag) => {
+                Bool::write(&false, w);
+                Nbt::write(tag, w);
+            }
+        }
+        Str::write(&v.link, w);
+    }
+}
+packet!(
+    /// ClientboundServerLinksPacket (a common packet: configuration and play).
+    /// Links the pause menu's "Server Links..." screen lists.
+    ServerLinks { links: Vec<ServerLink> => List<ServerLink> }
+);
 packet!(
     /// ClientboundShowDialogPacket.CONTEXT_FREE_STREAM_CODEC: the dialog
     /// itself (`Dialog.DIRECT_CODEC` as NBT).
@@ -89,6 +137,7 @@ packet_enum!(Clientbound, crate::ids::configuration::clientbound {
     UpdateTags(UpdateTags) = UPDATE_TAGS,
     SelectKnownPacks(SelectKnownPacks) = SELECT_KNOWN_PACKS,
     ClearDialog(Empty) = CLEAR_DIALOG,
+    ServerLinks(ServerLinks) = SERVER_LINKS,
     ShowDialog(ShowDialog) = SHOW_DIALOG,
     CodeOfConduct(CodeOfConduct) = CODE_OF_CONDUCT,
 });
@@ -236,6 +285,18 @@ mod tests {
             Clientbound::CodeOfConduct(CodeOfConduct {
                 text: "Be nice".into(),
             }),
+            Clientbound::ServerLinks(ServerLinks {
+                links: vec![
+                    ServerLink {
+                        kind: ServerLinkKind::Known(0),
+                        link: "https://bugs.example.net".into(),
+                    },
+                    ServerLink {
+                        kind: ServerLinkKind::Custom(crate::text::literal("Custom link")),
+                        link: "https://example.net".into(),
+                    },
+                ],
+            }),
             Clientbound::ShowDialog(ShowDialog {
                 dialog: Tag::compound([("type", Tag::String("minecraft:notice".into()))]),
             }),
diff --git a/crates/horizon-protocol/src/packets/play.rs b/crates/horizon-protocol/src/packets/play.rs
index 26bc09a84..a21171693 100644
--- a/crates/horizon-protocol/src/packets/play.rs
+++ b/crates/horizon-protocol/src/packets/play.rs
@@ -15,7 +15,7 @@ use crate::{
         configuration::{
             ClientInformation, CookieRequest, CookieResponse, CustomClickAction, CustomPayload,
             Disconnect, KeepAlive, Ping, ResourcePackPop, ResourcePackPush, ResourcePackResponse,
-            StoreCookie, Transfer, UpdateTags,
+            ServerLinks, StoreCookie, Transfer, UpdateTags,
         },
         login::Property,
     },
@@ -1903,6 +1903,9 @@ packet_enum!(Clientbound, crate::ids::play::clientbound {
     StopSound(StopSound) = STOP_SOUND,
     StartConfiguration(Empty) = START_CONFIGURATION,
     StoreCookie(StoreCookie) = STORE_COOKIE,
+    // A common packet: the same `configuration::ServerLinks` the
+    // configuration phase sends.
+    ServerLinks(ServerLinks) = SERVER_LINKS,
     SwingAnimation(SwingAnimation) = SWING_ANIMATION,
     SystemChat(SystemChat) = SYSTEM_CHAT,
     TabList(TabList) = TAB_LIST,

From 5179f975826747290826b6453cc4f1be59899265 Mon Sep 17 00:00:00 2001
From: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Mon, 26 Oct 2026 18:01:04 +0100
Subject: [PATCH 154/475] Server packs: show a progress screen while a pushed
 pack's resources reload

The download toast already matched vanilla, but once a server pack was
downloaded the whole resource reload ran synchronously on the render
thread: the frame froze on "Joining world" for seconds where vanilla's
Minecraft.reloadResourcePacks shows a LoadingOverlay with a progress bar.

The reload is split like the startup loader: a worker builds the overlay
root, models and sprites, the menu bundle and the pack's tables while a
progress screen (Preparing resources -> Loading assets -> Loading pack
tables -> Applying resources) covers the frame, then the renderer swap
and resource application land on the render thread and
ServerPacks.reloaded drives the feedback replies, including the recovery
reload on failure. The pack screen's own reload reuses the same staged
load, so its behaviour is unchanged.

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 crates/horizon-client/src/game.rs             |  35 +++-
 crates/horizon-client/src/game/packs.rs       | 152 ++++++++++++++----
 .../horizon-client/src/game/server_packs.rs   | 105 ++++++++++--
 docs/resource-packs.md                        |   3 +-
 4 files changed, 236 insertions(+), 59 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 755a00f6f..abaa639eb 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -10250,6 +10250,21 @@ impl Game<'_> {
             }
             return Ok(false);
         }
+        // A server pack's reload covers the frame with its progress
+        // (`LoadingOverlay`) until `tick_server_packs` applies it.
+        if let Some(reload) = &self.server_packs.reload {
+            if let Some(renderer) = &mut self.renderer {
+                let mut hud = HudBatch::new([renderer.config.width, renderer.config.height]);
+                horizon_client::level_loading::draw_progress(
+                    &mut hud,
+                    &self.gui.atlas,
+                    reload.progress.line(),
+                    reload.progress.fraction(),
+                );
+                return renderer.render(&loading_frame(&hud));
+            }
+            return Ok(false);
+        }
         let Some(size) = self
             .renderer
             .as_ref()
@@ -12742,7 +12757,6 @@ const NUMERIC_KEYS: [KeyCode; 11] = [
     KeyCode::Numpad9,
 ];
 
-const STAGES: u32 = 10;
 const STAGE_LINES: [&str; 10] = [
     "Loading menu",
     "Loading assets",
@@ -12758,19 +12772,28 @@ const STAGE_LINES: [&str; 10] = [
 
 /// The background loader's checkpoint, read by the loading screen each frame.
 #[derive(Clone)]
-struct Progress(Arc<AtomicU32>);
+struct Progress {
+    value: Arc<AtomicU32>,
+    lines: &'static [&'static str],
+}
 impl Progress {
     fn new() -> Self {
-        Self(Arc::new(AtomicU32::new(0)))
+        Self::with(&STAGE_LINES)
+    }
+    fn with(lines: &'static [&'static str]) -> Self {
+        Self {
+            value: Arc::new(AtomicU32::new(0)),
+            lines,
+        }
     }
     fn set(&self, stage: u32) {
-        self.0.store(stage, Ordering::Relaxed);
+        self.value.store(stage, Ordering::Relaxed);
     }
     fn fraction(&self) -> f32 {
-        self.0.load(Ordering::Relaxed) as f32 / (STAGES - 1) as f32
+        self.value.load(Ordering::Relaxed) as f32 / (self.lines.len() - 1) as f32
     }
     fn line(&self) -> &'static str {
-        STAGE_LINES[(self.0.load(Ordering::Relaxed) as usize).min(STAGE_LINES.len() - 1)]
+        self.lines[(self.value.load(Ordering::Relaxed) as usize).min(self.lines.len() - 1)]
     }
 }
 
diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs
index ee57e9f2b..995ebc8ca 100644
--- a/crates/horizon-client/src/game/packs.rs
+++ b/crates/horizon-client/src/game/packs.rs
@@ -1,14 +1,23 @@
 //! Resource pack selection bound to the game: the pack screen lists, and a
 //! full resource reload after a change, while playing.
-use super::Game;
+use super::{
+    Game, PackResources, Resources, UiResources, build_renderer, prepare_renderer_textures,
+};
 use horizon_client::{
+    assets::Assets,
+    gfx::PreparedTextures,
     hud::HudAtlas,
     lang,
     pack_screen::{self, Compat, PackInfo, Source as PackSource},
     packs::{self, Pack, Position},
+    streaming::WorkerContext,
     text::{Style, Text},
 };
-use std::path::{Path, PathBuf};
+use std::{
+    collections::BTreeSet,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 
 /// Where overlay roots are built (beside options.txt).
 pub fn cache_dir() -> PathBuf {
@@ -94,7 +103,7 @@ pub(super) fn pack_infos(vanilla: &Path) -> Vec<PackInfo> {
     infos
 }
 impl Game<'_> {
-    fn vanilla_root(&self) -> PathBuf {
+    pub(super) fn vanilla_root(&self) -> PathBuf {
         if self.ui.vanilla_root.as_os_str().is_empty() {
             self.options.resources.clone()
         } else {
@@ -134,35 +143,36 @@ impl Game<'_> {
             self.ui.options.resource_error = Some(e.to_string());
         }
     }
-    /// Reload from the selected packs and the server's.
-    pub(super) fn reload_selected_packs(&mut self) -> horizon_client::Result<()> {
+    /// The CPU half of the reload, safe on a worker (`PackReload` runs it):
+    /// `apply_staged_pack` finishes the GPU half and the swap.
+    pub(super) fn stage_selected_packs(&mut self) -> horizon_client::Result<StagedPack> {
         let vanilla = self.vanilla_root();
         if self.ui.vanilla_root.as_os_str().is_empty() {
             self.ui.vanilla_root = vanilla.clone();
         }
-        let server = &self.server_packs.active;
-        let root = startup_root(&vanilla, &self.settings.resource_packs, server)?;
-        let root =
-            super::mods::content_root(&root, &self.settings.mods.enabled, &self.options.dev_mods);
-        self.reload_resources(&root)
+        stage_pack(
+            &vanilla,
+            &self.settings.resource_packs,
+            &self.server_packs.active,
+            &self.settings.mods.enabled,
+            &self.options.dev_mods,
+            &self.pack.assets,
+            &self.res,
+            &self.pack.context,
+            self.settings.force_unicode,
+            self.settings.japanese_glyphs,
+            &super::Progress::new(),
+        )
     }
-    fn reload_resources(&mut self, root: &Path) -> horizon_client::Result<()> {
-        let render = std::sync::Arc::new(self.pack.assets.reload(root)?);
-        let mut atlas = HudAtlas::build_over(root, &self.vanilla_root())?;
-        atlas.font.uniform = self.settings.force_unicode;
-        atlas.font.japanese = self.settings.japanese_glyphs;
-        let gui = super::UiResources {
-            atlas,
-            panorama: std::sync::Arc::new(horizon_client::gfx::panorama::Faces::load(root)),
-        };
-        let pack = super::PackResources::load(
+    /// The render-thread half: the renderer on the new pack's textures, then
+    /// the swap (`ReloadInstance`'s application listeners).
+    pub(super) fn apply_staged_pack(&mut self, staged: StagedPack) -> horizon_client::Result<()> {
+        let StagedPack {
             root,
-            self.pack.assets.clone(),
-            render,
-            self.res.facts(),
-            self.pack.context.biomes.clone(),
-            self.pack.context.light.clone(),
-        )?;
+            gui,
+            pack,
+            textures,
+        } = staged;
         // Keep the working GPU resources, but release its exclusive window surface.
         if let Some(renderer) = &mut self.renderer {
             renderer.release_surface();
@@ -170,7 +180,17 @@ impl Game<'_> {
         let renderer = match self
             .window
             .clone()
-            .map(|window| self.renderer_for(window, &pack, &gui))
+            .map(|window| {
+                build_renderer(
+                    window,
+                    self.options.offscreen,
+                    &pack,
+                    &gui,
+                    self.renderer.as_ref(),
+                    Some(textures),
+                    self.settings.horizon.api,
+                )
+            })
             .transpose()
         {
             Ok(renderer) => renderer,
@@ -186,18 +206,18 @@ impl Game<'_> {
             }
         };
         // Everything loaded: switch over.
-        self.waypoint_styles = horizon_client::locator_bar::WaypointStyles::load(root);
-        self.armor_stand_assets.reload_trims(root);
+        self.waypoint_styles = horizon_client::locator_bar::WaypointStyles::load(&root);
+        self.armor_stand_assets.reload_trims(&root);
         self.random_tick_sections.clear();
         self.portals.sections.clear();
-        self.options.resources = root.to_path_buf();
+        self.options.resources = root.clone();
         let context = pack.context.clone();
         self.pack = pack;
         self.gui = gui;
         // The atlas's sprites moved: the particle engine re-reads every rect
         // and the packs' sprite sets, or every particle draws a stale region.
         self.particles
-            .reload(root, &self.gui.atlas.sprites, &self.gui.atlas.translucent);
+            .reload(&root, &self.gui.atlas.sprites, &self.gui.atlas.translucent);
         horizon_client::ui_theme::reset_atlas();
         // Villager hats come from the pack's texture metadata (shared data, swapped in place).
         *self
@@ -206,11 +226,11 @@ impl Game<'_> {
             .villager_hats
             .write()
             .unwrap_or_else(std::sync::PoisonError::into_inner) =
-            horizon_client::mobs::villager_hats::VillagerHats::load(root);
-        horizon_client::ui::load_metadata(root);
-        lang::set(lang::Language::load(&[&root.to_path_buf()], &lang::code()));
+            horizon_client::mobs::villager_hats::VillagerHats::load(&root);
+        horizon_client::ui::load_metadata(&root);
+        lang::set(lang::Language::load(&[&root], &lang::code()));
         self.refresh_remote_language();
-        self.audio.reload(root);
+        self.audio.reload(&root);
         self.clear_lod();
         self.streaming.reload_resources(&mut self.world, context);
         self.pending_uploads.clear();
@@ -223,4 +243,66 @@ impl Game<'_> {
         self.ui.chat.rescale(&self.gui.atlas);
         Ok(())
     }
+    /// `Minecraft.reloadResourcePacks`: the reload staged on the spot, then
+    /// applied (`PackReload` runs the same two phases across frames).
+    pub(super) fn reload_selected_packs(&mut self) -> horizon_client::Result<()> {
+        let staged = self.stage_selected_packs()?;
+        self.apply_staged_pack(staged)
+    }
+}
+
+/// The CPU half of `reload_selected_packs` (`PackReload` runs it on a
+/// worker; `apply_staged_pack` does the GPU half and the swap): the overlay
+/// root, the models and sprites, the menu bundle, the pack's tables and its
+/// CPU mip chains.
+pub(super) fn stage_pack(
+    vanilla_root: &Path,
+    selected: &[String],
+    server: &[Pack],
+    mods_enabled: &BTreeSet<String>,
+    dev_mods: &[PathBuf],
+    assets: &Arc<Assets>,
+    res: &Resources,
+    context: &WorkerContext,
+    force_unicode: bool,
+    japanese: bool,
+    progress: &super::Progress,
+) -> horizon_client::Result<StagedPack> {
+    let root = startup_root(vanilla_root, selected, server)?;
+    let root = super::mods::content_root(&root, mods_enabled, dev_mods);
+    progress.set(1);
+    let render = Arc::new(assets.reload(&root)?);
+    let mut atlas = HudAtlas::build_over(&root, vanilla_root)?;
+    atlas.font.uniform = force_unicode;
+    atlas.font.japanese = japanese;
+    let gui = UiResources {
+        atlas,
+        panorama: Arc::new(horizon_client::gfx::panorama::Faces::load(&root)),
+    };
+    progress.set(2);
+    let pack = PackResources::load(
+        &root,
+        assets.clone(),
+        render,
+        res.facts(),
+        context.biomes.clone(),
+        context.light.clone(),
+    )?;
+    let textures = prepare_renderer_textures(&pack);
+    progress.set(3);
+    Ok(StagedPack {
+        root,
+        gui,
+        pack,
+        textures,
+    })
+}
+
+/// Everything a pack reload builds on the CPU (`apply_staged_pack` finishes
+/// it on the render thread).
+pub(super) struct StagedPack {
+    pub root: PathBuf,
+    pub gui: UiResources,
+    pub pack: PackResources,
+    pub textures: PreparedTextures,
 }
diff --git a/crates/horizon-client/src/game/server_packs.rs b/crates/horizon-client/src/game/server_packs.rs
index 58d25de0e..12b73f4f9 100644
--- a/crates/horizon-client/src/game/server_packs.rs
+++ b/crates/horizon-client/src/game/server_packs.rs
@@ -3,7 +3,7 @@
 //! and `DownloadedPackSource` as `Minecraft` drives it): the prompt, the
 //! server list's setting, downloads into `downloads/`, and a resource reload
 //! with the server's packs on top of the player's own.
-use super::Game;
+use super::{Game, Progress};
 use horizon_client::{
     Result,
     confirm_screen::Confirm,
@@ -82,6 +82,9 @@ pub(super) struct ServerPackState {
     pub(super) active: Vec<packs::Pack>,
     /// The download batches' notifiers, oldest first.
     notifiers: Vec<PackNotifier>,
+    /// A `tick`-asked reload staged on a worker (`LoadingOverlay`): the
+    /// frame draws its progress until `tick_server_packs` applies it.
+    pub(super) reload: Option<PackReload>,
 }
 /// `DownloadedPackSource.createDownloadNotifier`: one batch's progress in its
 /// own `SystemToast`.
@@ -191,6 +194,21 @@ fn saves() -> PathBuf {
     std::env::current_dir().unwrap_or_default().join("saves")
 }
 
+/// `LoadingOverlay`'s stage lines for a pack reload, indexed by `progress`.
+const RELOAD_LINES: [&str; 4] = [
+    "Preparing resources",
+    "Loading assets",
+    "Loading pack tables",
+    "Applying resources",
+];
+/// A pack reload `ServerPacks::tick` asked for: the CPU half runs on a
+/// worker while `progress` feeds the loading screen, then the apply lands
+/// on the render thread.
+pub(super) struct PackReload {
+    pub(super) progress: Progress,
+    handle: std::thread::JoinHandle<std::result::Result<super::packs::StagedPack, String>>,
+}
+
 impl Game<'_> {
     /// `ConnectScreen`: the server's setting decides what its packs do
     /// (`configureForServerControl`); single player's own server takes them
@@ -314,6 +332,7 @@ impl Game<'_> {
         if self.rest_loader.is_some() || self.world_loader.is_some() {
             return;
         }
+        self.drive_pack_reload();
         let finished = self
             .server_packs
             .queue
@@ -328,13 +347,8 @@ impl Game<'_> {
             if !tick.download.is_empty() {
                 self.start_pack_downloads(tick.download);
             }
-            if let Some(mut load) = tick.reload {
-                while let Some(recovery) = {
-                    let ok = self.reload_server_packs(&load);
-                    self.server_packs.packs.reloaded(ok)
-                } {
-                    load = recovery;
-                }
+            if let Some(load) = tick.reload {
+                self.start_pack_reload(&load);
             }
         }
         for (id, status) in self.server_packs.packs.take_replies() {
@@ -379,24 +393,83 @@ impl Game<'_> {
         }
     }
     /// `DownloadedPackSource.startReload`: the packs on top of the player's
-    /// own, then `Minecraft.reloadResourcePacks`. False when a pack has no
-    /// readable `pack.mcmeta` or the reload failed.
-    fn reload_server_packs(&mut self, load: &[(u128, PathBuf)]) -> bool {
-        let packs: Option<Vec<_>> = load
+    /// own, staged on a worker (`Minecraft.reloadResourcePacks` under a
+    /// `LoadingOverlay`); `drive_pack_reload` applies it. A pack with no
+    /// readable `pack.mcmeta` fails the reload at once, as `onFailure`.
+    fn start_pack_reload(&mut self, load: &[(u128, PathBuf)]) {
+        let server: Option<Vec<_>> = load
             .iter()
             .map(|(id, path)| packs::server_pack(*id, path))
             .collect();
-        let Some(packs) = packs else {
+        let Some(server) = server else {
             log::warn!("Horizon: invalid pack metadata in a server pack, ignoring all");
-            return false;
+            self.finish_pack_reload(false);
+            return;
         };
-        self.server_packs.active = packs;
-        match self.reload_selected_packs() {
+        self.server_packs.active = server.clone();
+        let vanilla = self.vanilla_root();
+        if self.ui.vanilla_root.as_os_str().is_empty() {
+            self.ui.vanilla_root = vanilla.clone();
+        }
+        let (selected, mods, dev_mods) = (
+            self.settings.resource_packs.clone(),
+            self.settings.mods.enabled.clone(),
+            self.options.dev_mods.clone(),
+        );
+        let (assets, res, context) = (
+            self.pack.assets.clone(),
+            self.res.clone(),
+            self.pack.context.clone(),
+        );
+        let (unicode, japanese) = (self.settings.force_unicode, self.settings.japanese_glyphs);
+        let progress = Progress::with(&RELOAD_LINES);
+        let worker = progress.clone();
+        let handle = std::thread::Builder::new()
+            .name("server-pack-reload".into())
+            .spawn(move || {
+                super::packs::stage_pack(
+                    &vanilla, &selected, &server, &mods, &dev_mods, &assets, &res, &context,
+                    unicode, japanese, &worker,
+                )
+                .map_err(|e| e.to_string())
+            });
+        match handle {
+            Ok(handle) => self.server_packs.reload = Some(PackReload { progress, handle }),
+            Err(e) => {
+                log::error!("Horizon: could not start the pack reload worker: {e}");
+                self.finish_pack_reload(false);
+            }
+        }
+    }
+    /// `PackReloadConfig.Callbacks`: applies the staged reload once its
+    /// worker is done; on failure the packs active before reload again.
+    fn drive_pack_reload(&mut self) {
+        let Some(reload) = &self.server_packs.reload else {
+            return;
+        };
+        if !reload.handle.is_finished() {
+            return;
+        }
+        let reload = self.server_packs.reload.take().unwrap();
+        let staged = reload
+            .handle
+            .join()
+            .unwrap_or_else(|_| Err("the pack reload worker panicked".into()));
+        let ok = match staged
+            .and_then(|staged| self.apply_staged_pack(staged).map_err(|e| e.to_string()))
+        {
             Ok(()) => true,
             Err(e) => {
                 log::warn!("Horizon: server resource pack reload failed: {e}");
                 false
             }
+        };
+        self.finish_pack_reload(ok);
+    }
+    /// `ServerPacks::reloaded` and the recovery reload it can ask for.
+    fn finish_pack_reload(&mut self, ok: bool) {
+        if let Some(recovery) = self.server_packs.packs.reloaded(ok) {
+            self.start_pack_reload(&recovery);
         }
     }
 
diff --git a/docs/resource-packs.md b/docs/resource-packs.md
index 783c381dd..69eee3393 100644
--- a/docs/resource-packs.md
+++ b/docs/resource-packs.md
@@ -33,7 +33,7 @@ harness named checks that loader against vanilla).
 | Overlays per format | `pack.mcmeta` `overlays` | works | `test_resource_pack_parity` (an overlay for 26.3 applied, an older one not) |
 | Filters | `pack.mcmeta` `filter` | works | `test_resource_pack_parity` (`packs/pattern.rs` regex subset) |
 | Folder and zip packs, order, built-in packs | `resourcepacks/` | works | `test_resource_pack_parity`, `test_pack_selection_parity` |
-| Server resource packs: the prompt, the server list's Server Resource Packs setting, download (250 MiB, SHA-1, `downloads/` keeps 20), applied on top of the player's packs, removed on leaving | the server's `resource_pack_push`/`_pop` | works, no download toasts | `tools/server_pack_e2e.py` (against vanilla's server and Horizon's), unit tests in `server_packs.rs`; `test_server_resource_pack_parity` for Horizon's server |
+| Server resource packs: the prompt, the server list's Server Resource Packs setting, download (250 MiB, SHA-1, `downloads/` keeps 20), download toasts, a progress screen while the packs reload, applied on top of the player's packs, removed on leaving | the server's `resource_pack_push`/`_pop` | works | `tools/server_pack_e2e.py` (against vanilla's server and Horizon's), unit tests in `server_packs.rs`; `test_server_resource_pack_parity` for Horizon's server |
 | Other namespaces | `assets/<namespace>/` | works | `test_resource_pack_parity` |
 | Block states: variants, multipart, weights, rotations, uvlock | `blockstates/` | works | `test_blockstate_model_parity`, `test_model_choice_parity`, `test_blockstate_transform_parity` |
 | Block models: parents, elements, rotations, faces, cullface, tint, shade, light emission, ambient occlusion | `models/block/` | works | `test_model_resolution_parity`, `test_model_baking_parity`, `test_section_mesh_parity` |
@@ -84,7 +84,6 @@ shaders, the missing pieces are missing vanilla features too, and each vanilla p
 | Gap | Size | Where |
 | --- | --- | --- |
 | Animation `interpolate` | small | fix PR (`gfx.rs` `animate_sprites`) |
-| Server pack download toasts (`download.pack.*`) | small | `game/server_packs.rs` |
 | GUI scaling `width`/`height`, `stretch_inner`, `tile`, `stretch` | small | next fix PR (`ui.rs`) |
 | Villager hats | small | [#334](https://github.com/ludovic111/horizon/issues/334) |
 | `blur`/`clamp` from packs | small | [#335](https://github.com/ludovic111/horizon/issues/335) |

From fc9305bb155c090b35daa3534bcdf4d4daacb92f Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 18:03:42 +0100
Subject: [PATCH 155/475] mods: browser.set-recipes, recipes in the item
 panel's place

A mod gives the recipes to show (a layout: crafting grid, cooking, single
input, smithing or brewing; the slots, each cycling through its stacks;
the results; a note; and an optional action button, enabled or greyed)
under a title; an empty list shows the items again. The game pages them
and sends the slot-clicked, action, page and back events.

At most 256 recipes, 9 slots each and 64 stacks a slot. Same level as the
rest of browser (5): none of it has shipped yet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-mod-sdk/wit/horizon.wit        | 33 +++++++++++
 crates/horizon-mods/src/api_level.rs          |  3 +-
 crates/horizon-mods/src/runtime.rs            | 56 ++++++++++++++++--
 crates/horizon-mods/tests/sandbox.rs          | 52 ++++++++++++++++
 crates/horizon-mods/tests/ui_guest/src/lib.rs | 59 ++++++++++++++++++-
 docs/api/mods-reference.md                    | 27 +++++++++
 docs/api/stability.md                         |  2 +-
 docs/mods.md                                  |  2 +-
 8 files changed, 225 insertions(+), 9 deletions(-)

diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit
index 38a0e5879..4896c3e21 100644
--- a/crates/horizon-mod-sdk/wit/horizon.wit
+++ b/crates/horizon-mod-sdk/wit/horizon.wit
@@ -558,8 +558,41 @@ interface browser {
         /// The back button of `set-recipes`.
         back,
     }
+    /// How the game lays out a recipe of `set-recipes`.
+    enum layout {
+        /// A crafting grid of `width` x `height` slots, an arrow and the
+        /// result.
+        grid,
+        /// One input over a flame, an arrow and the result (furnaces,
+        /// smokers, campfires).
+        cooking,
+        /// One input, an arrow and the result (the stonecutter).
+        single,
+        /// Template, base and addition, an arrow and the result.
+        smithing,
+        /// A potion and an ingredient, an arrow and the result.
+        brewing,
+    }
+    /// A recipe to show. Each slot, and the result, cycles through its
+    /// stacks, one a second; an empty slot shows nothing.
+    record recipe-view {
+        layout: layout,
+        /// The grid's size (`grid` only), at most 3 x 3.
+        width: u32,
+        height: u32,
+        slots: list<list<stack>>,
+        results: list<stack>,
+        /// A short line under the recipe (a cooking time), or "".
+        note: string,
+        /// The action button beside it: none, enabled, or shown greyed.
+        action: option<bool>,
+    }
     /// The panel's items, at most 8192 (an empty list hides the panel).
     set-items: func(items: list<stack>);
+    /// Shows these recipes in the panel instead of its items, as many as
+    /// fit a page, under `title` and a back button; an empty list shows the
+    /// items again. At most 256 recipes.
+    set-recipes: func(title: string, recipes: list<recipe-view>);
     /// What the player did on the panel since the last poll, at most 256
     /// kept.
     poll: func() -> list<event>;
diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs
index 2474dfddd..7bb87b674 100644
--- a/crates/horizon-mods/src/api_level.rs
+++ b/crates/horizon-mods/src/api_level.rs
@@ -13,7 +13,7 @@ pub const LEVEL: u32 = 5;
 /// level. Level 0 is the contract of Horizon 0.2.67 to 0.2.69. A new
 /// function takes the next level and raises [`LEVEL`] (the `api_reference`
 /// test fails until it is listed here).
-pub const FUNCTIONS: [(&str, u32); 39] = [
+pub const FUNCTIONS: [(&str, u32); 40] = [
     ("log.write", 0),
     ("game.get-player", 0),
     ("game.get-clock", 0),
@@ -53,6 +53,7 @@ pub const FUNCTIONS: [(&str, u32); 39] = [
     ("recipes.known", 4),
     ("browser.set-items", 5),
     ("browser.poll", 5),
+    ("browser.set-recipes", 5),
 ];
 
 /// What the game's program carries so the launcher can read its level
diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs
index 0f2de0246..43c9e3fac 100644
--- a/crates/horizon-mods/src/runtime.rs
+++ b/crates/horizon-mods/src/runtime.rs
@@ -88,7 +88,8 @@ mod recipes_bindings {
 /// Capability `ui`'s recipe viewer panel (WIT `interface browser`).
 pub use recipes_bindings::horizon::mods::browser::{
     Click as BrowserClick, Event as BrowserEvent, ItemKey as BrowserItemKey,
-    SlotClick as BrowserSlotClick, Stack as BrowserStack,
+    Layout as BrowserLayout, RecipeView as BrowserRecipe, SlotClick as BrowserSlotClick,
+    Stack as BrowserStack,
 };
 /// What capability `recipes` reads (WIT `interface recipes`).
 pub use recipes_bindings::horizon::mods::recipes::{
@@ -318,14 +319,20 @@ struct UiState {
 #[derive(Default)]
 struct BrowserState {
     items: Vec<BrowserStack>,
-    /// Which `set-items` call the items are from, unique across mods and
-    /// reloads, so the game converts them once.
+    /// Which `set-items` or `set-recipes` call the panel is from, unique
+    /// across mods and reloads, so the game converts them once.
     version: u64,
+    /// `set-recipes`' title and recipes, shown instead of the items.
+    recipes: Option<(String, Vec<BrowserRecipe>)>,
     events: std::collections::VecDeque<BrowserEvent>,
 }
 static BROWSER_VERSION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
 /// Items a panel may hold, and events kept for `browser.poll`.
 const BROWSER_ITEMS: usize = 8192;
+/// Recipes `set-recipes` may show, slots in one, and stacks a slot cycles.
+const BROWSER_RECIPES: usize = 256;
+const RECIPE_SLOTS: usize = 9;
+const SLOT_STACKS: usize = 64;
 const BROWSER_EVENTS: usize = 256;
 impl BrowserState {
     fn push(&mut self, event: BrowserEvent) {
@@ -829,13 +836,26 @@ impl Mods {
             .any(|e| e.run.as_ref().is_some_and(|r| r.raycasts))
     }
     /// The panel beside container screens (`browser.set-items`): the first
-    /// running mod with items, its index, the items' version and the items.
+    /// running mod with items or recipes, its index, the panel's version and
+    /// the items.
     pub fn browser_items(&self) -> Option<(usize, u64, &[BrowserStack])> {
         self.entries.iter().enumerate().find_map(|(i, e)| {
             let b = &e.run.as_ref()?.store.data().browser;
-            (!b.items.is_empty()).then_some((i, b.version, b.items.as_slice()))
+            (!b.items.is_empty() || b.recipes.is_some()).then_some((
+                i,
+                b.version,
+                b.items.as_slice(),
+            ))
         })
     }
+    /// The recipes mod `owner`'s panel shows instead of its items
+    /// (`browser.set-recipes`): the title and the recipes.
+    pub fn browser_recipes(&self, owner: usize) -> Option<(&str, &[BrowserRecipe])> {
+        let b = &self.entries.get(owner)?.run.as_ref()?.store.data().browser;
+        b.recipes
+            .as_ref()
+            .map(|(title, list)| (title.as_str(), list.as_slice()))
+    }
     /// The player did `event` on mod `owner`'s panel.
     pub fn browser_event(&mut self, owner: usize, event: BrowserEvent) {
         if let Some(run) = self.entries.get_mut(owner).and_then(|e| e.run.as_mut()) {
@@ -1241,6 +1261,32 @@ impl browser::Host for State {
             .collect();
         self.browser.version = BROWSER_VERSION.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
     }
+    fn set_recipes(&mut self, title: String, recipes: Vec<BrowserRecipe>) {
+        let stack = |s: BrowserStack| BrowserStack {
+            item: clip(s.item),
+            components: clip_to(s.components, 4096),
+            ..s
+        };
+        let cycle = |list: Vec<BrowserStack>| -> Vec<BrowserStack> {
+            list.into_iter().take(SLOT_STACKS).map(stack).collect()
+        };
+        self.browser.recipes = (!recipes.is_empty()).then(|| {
+            let recipes = recipes
+                .into_iter()
+                .take(BROWSER_RECIPES)
+                .map(|r| BrowserRecipe {
+                    width: r.width.clamp(1, 3),
+                    height: r.height.clamp(1, 3),
+                    slots: r.slots.into_iter().take(RECIPE_SLOTS).map(cycle).collect(),
+                    results: cycle(r.results),
+                    note: clip(r.note),
+                    ..r
+                })
+                .collect();
+            (clip(title), recipes)
+        });
+        self.browser.version = BROWSER_VERSION.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    }
     fn poll(&mut self) -> Vec<BrowserEvent> {
         self.browser.events.drain(..).collect()
     }
diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs
index 576dc5942..081884dc2 100644
--- a/crates/horizon-mods/tests/sandbox.rs
+++ b/crates/horizon-mods/tests/sandbox.rs
@@ -1157,6 +1157,58 @@ fn browser_lists_items_and_hears_the_player() {
     assert_ne!(mods.browser_items().unwrap().1, version);
     assert_eq!(said(&mut mods, "browser"), ["panel of 0"]);
     assert!(mods.browser_items().is_none());
+    // Recipes in the panel's place: the guest shows those making planks.
+    use horizon_mods::{BrowserLayout, Recipe, RecipeItem, RecipeKind, RecipeStack, Recipes};
+    let item = |id: &str| RecipeItem {
+        id: id.into(),
+        name: id.into(),
+        tags: Vec::new(),
+    };
+    let stack = |item| RecipeStack {
+        item,
+        count: 1,
+        components: String::new(),
+    };
+    mods.set_snapshot(Snapshot {
+        recipes: Some(std::sync::Arc::new(Recipes {
+            items: vec![item("minecraft:oak_log"), item("minecraft:oak_planks")],
+            recipes: vec![Recipe {
+                id: "minecraft:oak_planks".into(),
+                kind: RecipeKind::CraftingShapeless,
+                category: "building".into(),
+                group: "planks".into(),
+                width: 0,
+                height: 0,
+                slots: vec![vec![stack(0)]],
+                results: vec![RecipeStack {
+                    count: 4,
+                    ..stack(1)
+                }],
+                cooking_time: 0,
+                experience: 0.0,
+                book_id: 1,
+            }],
+        })),
+        ..Snapshot::default()
+    });
+    said(&mut mods, "browser minecraft:dirt");
+    assert_eq!(
+        said(&mut mods, "browser_recipes minecraft:oak_planks"),
+        ["recipes shown: 1"]
+    );
+    let (title, recipes) = mods.browser_recipes(owner).unwrap();
+    assert_eq!(title, "Recipes for minecraft:oak_planks");
+    let r = &recipes[0];
+    assert_eq!(
+        (r.layout, r.width, r.height, r.action),
+        (BrowserLayout::Grid, 1, 1, Some(false))
+    );
+    assert_eq!(
+        (r.slots[0][0].item.as_str(), r.results[0].count),
+        ("minecraft:oak_log", 4)
+    );
+    assert_eq!(said(&mut mods, "browser_recipes"), ["recipes shown: 0"]);
+    assert!(mods.browser_recipes(owner).is_none());
     // At most 256 events wait for a poll: the oldest go.
     for _ in 0..300 {
         mods.browser_event(owner, BrowserEvent::Page(1));
diff --git a/crates/horizon-mods/tests/ui_guest/src/lib.rs b/crates/horizon-mods/tests/ui_guest/src/lib.rs
index 43aa207e0..751169565 100644
--- a/crates/horizon-mods/tests/ui_guest/src/lib.rs
+++ b/crates/horizon-mods/tests/ui_guest/src/lib.rs
@@ -10,7 +10,9 @@
 //! counts what `recipes` reads; `/recipes ID` describes that recipe.
 //! `/browser ID...` fills `browser`'s panel (`/browser N`: the first N
 //! items, `/browser` alone empties it) and registers the keys `recipe` (R)
-//! and `uses` (U); `/browser_poll` says what the player did on it.
+//! and `uses` (U); `/browser_poll` says what the player did on it;
+//! `/browser_recipes ID` shows the recipes making ID (`/browser_recipes`
+//! alone: the items again).
 use horizon_mod_sdk::{
     Mod, Registration, browser, chat, command, game,
     input::{self, Event},
@@ -110,6 +112,7 @@ impl Mod for Guest {
             "recipes",
             "browser",
             "browser_poll",
+            "browser_recipes",
             "corner",
             "readings",
         ]
@@ -310,6 +313,60 @@ impl Mod for Guest {
                 input::register_key("uses", "Show uses", "key.keyboard.u")?;
                 chat::show(&format!("panel of {}", items.len()));
             }
+            "browser_recipes" => {
+                let items = recipes::items();
+                let id = |i: u32| {
+                    items
+                        .get(i as usize)
+                        .map_or(String::new(), |x| x.id.clone())
+                };
+                let stack = |s: &recipes::Stack| browser::Stack {
+                    item: id(s.item),
+                    count: s.count,
+                    components: s.components.clone(),
+                };
+                let views: Vec<browser::RecipeView> = recipes::all()
+                    .iter()
+                    .filter(|r| !args.is_empty() && r.results.iter().any(|s| id(s.item) == args))
+                    .map(|r| {
+                        use recipes::Kind;
+                        let crafting =
+                            matches!(r.kind, Kind::CraftingShaped | Kind::CraftingShapeless);
+                        let shapeless = (r.slots.len() as u32).clamp(1, 3);
+                        browser::RecipeView {
+                            layout: match r.kind {
+                                Kind::CraftingShaped | Kind::CraftingShapeless => {
+                                    browser::Layout::Grid
+                                }
+                                Kind::Stonecutting => browser::Layout::Single,
+                                Kind::Smithing => browser::Layout::Smithing,
+                                Kind::Brewing => browser::Layout::Brewing,
+                                _ => browser::Layout::Cooking,
+                            },
+                            width: if r.width == 0 { shapeless } else { r.width },
+                            height: if r.height == 0 {
+                                (r.slots.len() as u32).div_ceil(3).max(1)
+                            } else {
+                                r.height
+                            },
+                            slots: r
+                                .slots
+                                .iter()
+                                .map(|s| s.iter().map(stack).collect())
+                                .collect(),
+                            results: r.results.iter().map(stack).collect(),
+                            note: if r.cooking_time > 0 {
+                                format!("{} ticks", r.cooking_time)
+                            } else {
+                                String::new()
+                            },
+                            action: crafting.then_some(r.kind == Kind::CraftingShaped),
+                        }
+                    })
+                    .collect();
+                browser::set_recipes(&format!("Recipes for {args}"), &views);
+                chat::show(&format!("recipes shown: {}", views.len()));
+            }
             "browser_poll" => {
                 let stack = |s: &browser::Stack| format!("{} x{}{}", s.item, s.count, s.components);
                 // A hook shows at most 8 chat lines: the count, then the first 7.
diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md
index 298db26ba..6af12fa5b 100644
--- a/docs/api/mods-reference.md
+++ b/docs/api/mods-reference.md
@@ -588,9 +588,36 @@ A click on a slot of a recipe the panel shows (`set-recipes`).
 | `page` | `u32` | The player turned the recipes' page (`set-recipes`): the index of the first recipe now shown. |
 | `back` |  | The back button of `set-recipes`. |
 
+### enum `layout`
+
+How the game lays out a recipe of `set-recipes`.
+
+| Case | |
+| --- | --- |
+| `grid` | A crafting grid of `width` x `height` slots, an arrow and the result. |
+| `cooking` | One input over a flame, an arrow and the result (furnaces, smokers, campfires). |
+| `single` | One input, an arrow and the result (the stonecutter). |
+| `smithing` | Template, base and addition, an arrow and the result. |
+| `brewing` | A potion and an ingredient, an arrow and the result. |
+
+### record `recipe-view`
+
+A recipe to show. Each slot, and the result, cycles through its stacks, one a second; an empty slot shows nothing.
+
+| Field | Type | |
+| --- | --- | --- |
+| `layout` | `layout` |  |
+| `width` | `u32` | The grid's size (`grid` only), at most 3 x 3. |
+| `height` | `u32` |  |
+| `slots` | `list<list<stack>>` |  |
+| `results` | `list<stack>` |  |
+| `note` | `string` | A short line under the recipe (a cooking time), or "". |
+| `action` | `option<bool>` | The action button beside it: none, enabled, or shown greyed. |
+
 | Function | Signature | What it does |
 | --- | --- | --- |
 | `set-items` | `func(items: list<stack>)` | The panel's items, at most 8192 (an empty list hides the panel). |
+| `set-recipes` | `func(title: string, recipes: list<recipe-view>)` | Shows these recipes in the panel instead of its items, as many as fit a page, under `title` and a back button; an empty list shows the items again. At most 256 recipes. |
 | `poll` | `func() -> list<event>` | What the player did on the panel since the last poll, at most 256 kept. |
 
 ## `players`
diff --git a/docs/api/stability.md b/docs/api/stability.md
index bb0ddf501..1314d9813 100644
--- a/docs/api/stability.md
+++ b/docs/api/stability.md
@@ -38,7 +38,7 @@ don't import it); faster, or fixing behaviour to what the reference already says
 
 A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every
 function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`):
-level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`, level 3 `command.run-quiet`, level 4 `recipes` (`items`, `all`, `known`), level 5 `browser` (`set-items`, `poll`). A mod needs the level of
+level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`, level 3 `command.run-quiet`, level 4 `recipes` (`items`, `all`, `known`), level 5 `browser` (`set-items`, `poll`, `set-recipes`). A mod needs the level of
 the newest function it imports (a component imports only the functions it calls). The level is read from the file,
 never declared:
 
diff --git a/docs/mods.md b/docs/mods.md
index 9aed4897b..bbd14dc84 100644
--- a/docs/mods.md
+++ b/docs/mods.md
@@ -88,7 +88,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3.
 | `hud` | `hud` | `set-panel(corner, lines)`, `clear()`: up to 16 lines of 256 characters |
 | `storage` | `storage` | `get(key)`, `set(key, value)`, `delete(key)`: a per-mod folder of up to 64 files, 4 MiB total, at most 1 MiB written per call |
 | `command` | `command` | `run(line)`: a vanilla command run as the player, with the player's permissions, after the hook returns (8 per call); mods' own commands are not run. `run-quiet(lines)`: up to 256 a call, the same rights, nothing in the chat (single player and Horizon's servers run them 64 a tick and log one line a batch; elsewhere they go as chat commands and their feedback shows) |
-| `ui` | `ui` | `open-screen`, `close-screen`, `set-settings`: a screen the mod owns and a page in Options > Mods, of text, button, item and list widgets the game lays out and draws with its own menus' code; `browser.set-items`, `browser.poll`: a recipe viewer's panel of items right of the inventory and container screens (not the creative one), which the game pages and draws with its own slots and search box, and the mod hears its clicks, its searches and the mod's own keys (`input.register-key`) pressed over any item on the screen. **Experimental:** the manifest needs `experimental = ["ui"]` |
+| `ui` | `ui` | `open-screen`, `close-screen`, `set-settings`: a screen the mod owns and a page in Options > Mods, of text, button, item and list widgets the game lays out and draws with its own menus' code; `browser.set-items`, `browser.poll`: a recipe viewer's panel of items right of the inventory and container screens (not the creative one), which the game pages and draws with its own slots and search box, and the mod hears its clicks, its searches and the mod's own keys (`input.register-key`) pressed over any item on the screen; `browser.set-recipes`: recipes in the panel's place (crafting grids, cooking, stonecutting, smithing and brewing layouts, their slots cycling through their stacks, a note and an action button each), paged by the game, with clicks on their slots, action buttons, page turns and a back button. **Experimental:** the manifest needs `experimental = ["ui"]` |
 | `render` | `render` | `set-hud(shapes)`: up to 1024 fills, four-cornered shapes, GUI sprites, items and text, kept on the HUD (over the hotbar, under chat and screens, hidden with F1) until replaced; `set-corner(corner, w, h, shapes)`: a box the game places in a corner, stacked with its overlays and other panels, as `hud`'s panels are; `text-width(text)`; `frame-stats()`: the game's FPS, min and 1% low; `gui-size()`; `shake(strength, seconds)`: the view turns, the player doesn't, scaled by Distortion Effects; `set-zoom(zoom)`: the field of view divided by up to 10, eased or at once, with slower turning, while playing and not through a spyglass (the strongest of several mods' zooms counts); `set-minimap(minimap)`: a map of the world around the player in a corner, as a map item colours it (the floor underground and under roofs), square or round, turning with the player or north up, with the player's arrow; the game keeps its tiles within its own frame budget (one map at a time, the first loaded mod's). The game's own HUD renderer draws them: a mod never supplies shader code. **Experimental:** `experimental = ["render"]` |
 | `input` | `input` | `claim-items(ids)`: the use button on those items is the mod's (`use-start`, `use-stop` with the ticks held; the game doesn't place, eat or swing); `register-key(name, label, key)`: up to 16 keys (`key.keyboard.r`), heard while playing as `key-down` / `key-up` (the game's own mapping on that key still runs; a screen opening lets held keys up), mouse buttons as `key.mouse.4`. The player rebinds them on the mod's page in Options > Mods, where the game lists them first as Key Binds rows (click, then press a key or mouse button; Esc binds none), even for a mod without `ui`; the choice is kept in `horizon-mods.txt` (`key.<mod>.<name>:key.keyboard.z`) and wins over `register-key`'s default; `claim-wheel(on)`: the wheel's steps become `wheel` events and the hotbar doesn't move (the one input a mod takes from the game; a mod's keys never do); `held()`; `mapping(name)`: a movement or click mapping's key label and whether it is held; `clicks-per-second()`; `poll()` returns the events, at most 256 kept. **Experimental:** `experimental = ["input"]` |
 | `recipes` | `recipes` | `items()`: every item in the registry's order, with its name in the player's language and its tags; `all()`: every recipe (crafting, smelting, blasting, smoking, campfire, stonecutting, smithing, brewing), its slots as the stacks that fit each, its results, cooking time and experience, and the recipe book's id for it; `known()`: the book ids the player's recipe book holds. The recipes are the world's in single player and on Horizon's servers, vanilla 26.3's on any other server (a client is sent no others), while `known` follows that server's book. The game makes the tables once, when a mod first reads them. **Experimental:** `experimental = ["recipes"]` |

From ad557fef4708767d3e60ab24f173192af04716e6 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 18:03:42 +0100
Subject: [PATCH 156/475] game: a mod's recipe pages in the item panel

browser.set-recipes replaces the panel's items with the mod's recipes,
laid out with the game's slot, furnace arrow and flame sprites and small
buttons: a crafting grid, one input over a flame, one input, three inputs
or two, then an arrow and the result, a note under it and the action
button beside the result (under it when the panel is narrow). Slots cycle
through their stacks once a second. As many recipes as fit the panel's
height make a page, with the recipe book's arrows; a title row holds a
Back button and the title. The same title sent again keeps the page.

Clicks on the slots, the action button, the arrows and Back reach the mod;
tooltips and the mods' keys work on the recipes' stacks as on the items.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game.rs             |   2 +
 crates/horizon-client/src/game/mod_browser.rs |  89 +++-
 .../src/game/mod_browser_recipes.rs           | 419 ++++++++++++++++++
 3 files changed, 486 insertions(+), 24 deletions(-)
 create mode 100644 crates/horizon-client/src/game/mod_browser_recipes.rs

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 6779d367a..ec21bdbb9 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -100,6 +100,8 @@ mod minecarts;
 mod mob_blocks;
 mod mob_gear;
 mod mod_browser;
+#[cfg(feature = "mods")]
+mod mod_browser_recipes;
 mod mod_input;
 #[cfg(feature = "mods")]
 mod mod_recipes;
diff --git a/crates/horizon-client/src/game/mod_browser.rs b/crates/horizon-client/src/game/mod_browser.rs
index 2f317792f..3121eb05b 100644
--- a/crates/horizon-client/src/game/mod_browser.rs
+++ b/crates/horizon-client/src/game/mod_browser.rs
@@ -53,27 +53,29 @@ pub(super) struct Browser {
     search: Option<EditBox>,
     /// The search text the mod last heard.
     sent: String,
+    /// `set-recipes`' recipes, shown instead of the items.
+    pub(super) recipes: Option<super::mod_browser_recipes::Pages>,
 }
 
 /// Where the panel's parts are this frame.
 #[cfg(feature = "mods")]
-struct Layout {
+pub(super) struct Layout {
     /// The panel's whole area, for clicks that hit none of its parts.
-    area: [f32; 4],
+    pub(super) area: [f32; 4],
     /// The grid's top left corner, its columns and rows.
-    grid: (f32, f32),
-    columns: usize,
-    rows: usize,
+    pub(super) grid: (f32, f32),
+    pub(super) columns: usize,
+    pub(super) rows: usize,
     /// The page arrows' row.
-    arrows_y: f32,
-    search: [f32; 4],
+    pub(super) arrows_y: f32,
+    pub(super) search: [f32; 4],
 }
 #[cfg(feature = "mods")]
 impl Layout {
     fn per_page(&self) -> usize {
         self.columns * self.rows
     }
-    fn width(&self) -> f32 {
+    pub(super) fn width(&self) -> f32 {
         self.columns as f32 * SLOT
     }
     fn slot(&self, n: usize) -> (f32, f32) {
@@ -83,7 +85,7 @@ impl Layout {
         )
     }
     /// The page arrows: backward, then forward.
-    fn arrows(&self) -> [(f32, f32); 2] {
+    pub(super) fn arrows(&self) -> [(f32, f32); 2] {
         [
             (self.grid.0, self.arrows_y),
             (self.grid.0 + self.width() - 12.0, self.arrows_y),
@@ -92,7 +94,7 @@ impl Layout {
 }
 
 #[cfg(feature = "mods")]
-fn inside(p: (f32, f32), [x, y, w, h]: [f32; 4]) -> bool {
+pub(super) fn inside(p: (f32, f32), [x, y, w, h]: [f32; 4]) -> bool {
     p.0 >= x && p.1 >= y && p.0 < x + w && p.1 < y + h
 }
 
@@ -123,6 +125,12 @@ impl Game<'_> {
                     list.iter().map(|s| browser_stack(items, s)).collect()
                 });
             self.mods.browser.stacks = stacks;
+            // The same title again (the mod updating its buttons) keeps the page.
+            let old = self.mods.browser.recipes.take();
+            self.mods.browser.recipes =
+                self.mods.mods.browser_recipes(owner).map(|(title, list)| {
+                    super::mod_browser_recipes::Pages::new(items, title, list, old)
+                });
             self.mods.browser.of = Some((owner, version));
         }
         Some(owner)
@@ -159,8 +167,22 @@ impl Game<'_> {
             .div_ceil(layout.per_page())
             .max(1)
     }
+    /// The stack under the pointer on the panel, an item's or a recipe's,
+    /// as the mod sent it and as a stack.
+    fn browser_pointed_stack(&self, layout: &Layout) -> Option<(BrowserStack, ItemStack)> {
+        if self.mods.browser.recipes.is_some() {
+            let (_, _, sent, stack) = self.recipe_slot_hovered(layout)?;
+            return Some((sent, stack));
+        }
+        let (index, stack) = self.browser_hovered(layout)?;
+        let (_, _, items) = self.mods.mods.browser_items()?;
+        Some((items.get(index)?.clone(), stack))
+    }
     /// The panel's item under the pointer: its index and stack.
     fn browser_hovered(&self, layout: &Layout) -> Option<(usize, ItemStack)> {
+        if self.mods.browser.recipes.is_some() {
+            return None;
+        }
         let first = self.mods.browser.page * layout.per_page();
         (0..layout.per_page()).find_map(|n| {
             let (x, y) = layout.slot(n);
@@ -182,16 +204,9 @@ impl Game<'_> {
         search
     }
 
-    /// Draws the panel over the open container screen, then the carried
-    /// stack or the tooltip again so they stay on top of it.
-    pub(super) fn draw_mod_browser(&mut self, batch: &mut HudBatch) {
-        if self.browser_sync().is_none() {
-            return;
-        }
-        let Some(layout) = self.browser_layout(batch) else {
-            return;
-        };
-        let pages = self.browser_pages(&layout);
+    /// The items' page arrows and grid.
+    fn draw_browser_items(&mut self, batch: &mut HudBatch, layout: &Layout) {
+        let pages = self.browser_pages(layout);
         self.mods.browser.page = self.mods.browser.page.min(pages - 1);
         let page = self.mods.browser.page;
         let cursor = self.cursor;
@@ -255,6 +270,22 @@ impl Game<'_> {
                 horizon_client::widgets::Kind::Button,
             );
         }
+    }
+    /// Draws the panel over the open container screen, then the carried
+    /// stack or the tooltip again so they stay on top of it.
+    pub(super) fn draw_mod_browser(&mut self, batch: &mut HudBatch) {
+        if self.browser_sync().is_none() {
+            return;
+        }
+        let Some(layout) = self.browser_layout(batch) else {
+            return;
+        };
+        let cursor = self.cursor;
+        if self.mods.browser.recipes.is_some() {
+            self.draw_browser_recipes(batch, &layout);
+        } else {
+            self.draw_browser_items(batch, &layout);
+        }
         let hint = self.translate("gui.recipebook.search_hint", "Search...");
         let search = self.browser_search(&layout);
         // The hint shows in an empty box without focus, as the recipe book's.
@@ -264,8 +295,8 @@ impl Game<'_> {
         self.mods.browser.search = Some(search);
         if self.carried.is_some() {
             self.draw_carried(batch);
-        } else if let Some((_, stack)) = self.browser_hovered(&layout) {
-            let lines = self.stack_tooltip(&stack);
+        } else if let Some(stack) = self.browser_pointed_stack(&layout) {
+            let lines = self.stack_tooltip(&stack.1);
             self.draw_tooltip_lines(batch, &lines, cursor.0, cursor.1);
         } else {
             self.draw_slot_tooltip(batch);
@@ -301,6 +332,10 @@ impl Game<'_> {
             return true;
         }
         search.focused = false;
+        if self.mods.browser.recipes.is_some() {
+            return self.browser_recipes_press(&layout, owner, right)
+                || inside(cursor, layout.area);
+        }
         let pages = self.browser_pages(&layout);
         let page = self.mods.browser.page;
         let [back, forward] = layout.arrows();
@@ -405,7 +440,10 @@ impl Game<'_> {
             .browser_sync()
             .and_then(|_| self.browser_layout(&batch))
         {
-            Some(layout) if inside(self.cursor, layout.area) => self.browser_hovered(&layout)?.1,
+            // The panel's stacks as the mod sent them.
+            Some(layout) if inside(self.cursor, layout.area) => {
+                return Some(self.browser_pointed_stack(&layout)?.0);
+            }
             _ => {
                 let slot = self.slot_at(&batch, self.cursor.0, self.cursor.1)?;
                 self.slot_view(slot)?
@@ -422,7 +460,10 @@ impl Game<'_> {
 /// A mod's item as a stack: an item the game has, its components read as
 /// `/give` reads them (ones it can't read are left out).
 #[cfg(feature = "mods")]
-fn browser_stack(items: &horizon_client::items::Items, s: &BrowserStack) -> Option<ItemStack> {
+pub(super) fn browser_stack(
+    items: &horizon_client::items::Items,
+    s: &BrowserStack,
+) -> Option<ItemStack> {
     items.get(&s.item)?;
     let (damage, extra) = if s.components.is_empty() {
         (0, None)
diff --git a/crates/horizon-client/src/game/mod_browser_recipes.rs b/crates/horizon-client/src/game/mod_browser_recipes.rs
new file mode 100644
index 000000000..14848de90
--- /dev/null
+++ b/crates/horizon-client/src/game/mod_browser_recipes.rs
@@ -0,0 +1,419 @@
+//! `browser.set-recipes` (docs/mods.md): a mod's recipes shown in its item
+//! panel's place, laid out by the game with its own slots, arrows and
+//! buttons, paged to the panel's height, under a title and a back button.
+//! The mod hears clicks on their slots, their action buttons, the back
+//! button and page turns.
+use super::{
+    Game,
+    mod_browser::{Layout, browser_stack, inside},
+};
+use horizon_client::{
+    hud::{HudBatch, rgba},
+    items::ItemStack,
+};
+use horizon_mods::{BrowserEvent, BrowserLayout, BrowserRecipe, BrowserSlotClick, BrowserStack};
+use std::time::Instant;
+
+const SLOT: f32 = 18.0;
+/// The title row's height, and the gap under each recipe.
+const TITLE: f32 = 18.0;
+const GAP: f32 = 6.0;
+
+/// One recipe as the game draws it.
+pub(super) struct Shown {
+    layout: BrowserLayout,
+    width: usize,
+    height: usize,
+    /// Each slot's stacks (the result last), as the mod sent them and as
+    /// stacks; a stack the game doesn't have is left out of the cycle.
+    slots: Vec<Vec<(BrowserStack, ItemStack)>>,
+    note: String,
+    action: Option<bool>,
+}
+
+/// The recipes a panel shows, and its page.
+pub(super) struct Pages {
+    title: String,
+    recipes: Vec<Shown>,
+    page: usize,
+    since: Instant,
+}
+
+impl Pages {
+    pub(super) fn new(
+        items: &horizon_client::items::Items,
+        title: &str,
+        list: &[BrowserRecipe],
+        old: Option<Pages>,
+    ) -> Self {
+        let kept = old.filter(|o| o.title == title);
+        let cycle = |stacks: &[BrowserStack]| -> Vec<(BrowserStack, ItemStack)> {
+            stacks
+                .iter()
+                .filter_map(|s| Some((s.clone(), browser_stack(items, s)?)))
+                .collect()
+        };
+        let recipes = list
+            .iter()
+            .map(|r| {
+                let mut slots: Vec<_> = r.slots.iter().map(|s| cycle(s)).collect();
+                slots.push(cycle(&r.results));
+                Shown {
+                    layout: r.layout,
+                    width: r.width as usize,
+                    height: r.height as usize,
+                    slots,
+                    note: r.note.clone(),
+                    action: r.action,
+                }
+            })
+            .collect();
+        Self {
+            title: title.to_owned(),
+            recipes,
+            page: kept.as_ref().map_or(0, |o| o.page),
+            since: kept.map_or_else(Instant::now, |o| o.since),
+        }
+    }
+}
+
+impl Shown {
+    /// The inputs' block: its size and each input slot's place in it.
+    fn inputs(&self) -> ((f32, f32), Vec<(f32, f32)>) {
+        let row = |n: usize| (0..n).map(|i| (i as f32 * SLOT, 0.0)).collect();
+        match self.layout {
+            BrowserLayout::Grid => {
+                let (w, h) = (self.width.max(1), self.height.max(1));
+                let at = (0..w * h)
+                    .map(|i| ((i % w) as f32 * SLOT, (i / w) as f32 * SLOT))
+                    .collect();
+                ((w as f32 * SLOT, h as f32 * SLOT), at)
+            }
+            // The input over the flame.
+            BrowserLayout::Cooking => ((SLOT, 2.0 * SLOT), vec![(0.0, 0.0)]),
+            BrowserLayout::Single => ((SLOT, SLOT), row(1)),
+            BrowserLayout::Smithing => ((3.0 * SLOT, SLOT), row(3)),
+            BrowserLayout::Brewing => ((2.0 * SLOT, SLOT), row(2)),
+        }
+    }
+    /// The height of its slots, arrow and button, `room` wide.
+    fn block(&self, room: f32) -> f32 {
+        let h = self.inputs().0.1;
+        let (_, _, action) = self.places(room);
+        match self.action {
+            Some(_) => h.max(action.1 + 12.0),
+            None => h,
+        }
+    }
+    fn height(&self, room: f32) -> f32 {
+        let note = if self.note.is_empty() { 0.0 } else { 11.0 };
+        self.block(room) + note + GAP
+    }
+    /// Every slot's place from the recipe's corner (the result last), the
+    /// arrow's and the action button's: beside the result, or under it
+    /// when the panel is `room` wide and that doesn't fit.
+    fn places(&self, room: f32) -> (Vec<(f32, f32)>, (f32, f32), (f32, f32)) {
+        let ((w, h), mut at) = self.inputs();
+        // The mod's slots beyond the layout's are not shown.
+        at.truncate(self.slots.len() - 1);
+        let arrow = (w + 4.0, ((h - 16.0) / 2.0).floor());
+        let result = (w + 32.0, ((h - SLOT) / 2.0).floor());
+        let action = if result.0 + SLOT + 16.0 <= room {
+            (result.0 + SLOT + 4.0, ((h - 12.0) / 2.0).floor())
+        } else {
+            (result.0 + 3.0, result.1 + SLOT + 2.0)
+        };
+        while at.len() < self.slots.len() - 1 {
+            at.push((f32::NAN, f32::NAN));
+        }
+        at.push(result);
+        (at, arrow, action)
+    }
+}
+
+impl Game<'_> {
+    /// The first recipe of each page, filling the panel from the title row
+    /// to the search box.
+    fn recipe_pages(pages: &Pages, layout: &Layout) -> Vec<usize> {
+        let room = layout.search[1] - 4.0 - (layout.grid.1 + TITLE);
+        let mut starts = vec![0];
+        let mut used = 0.0;
+        for (i, r) in pages.recipes.iter().enumerate() {
+            let h = r.height(layout.width());
+            if used > 0.0 && used + h > room {
+                starts.push(i);
+                used = 0.0;
+            }
+            used += h;
+        }
+        starts
+    }
+    /// The recipes on the open page, each with its corner.
+    fn recipes_shown(&self, layout: &Layout) -> Vec<(usize, (f32, f32))> {
+        let Some(pages) = &self.mods.browser.recipes else {
+            return Vec::new();
+        };
+        let starts = Self::recipe_pages(pages, layout);
+        let page = pages.page.min(starts.len() - 1);
+        let end = starts.get(page + 1).copied().unwrap_or(pages.recipes.len());
+        let mut y = layout.grid.1 + TITLE;
+        (starts[page]..end)
+            .map(|i| {
+                let at = (layout.grid.0, y);
+                y += pages.recipes[i].height(layout.width());
+                (i, at)
+            })
+            .collect()
+    }
+    fn back_button(&self, layout: &Layout) -> ([f32; 4], String) {
+        let label = self.translate("gui.back", "Back");
+        let w = HudBatch::text_width(&self.gui.atlas, &label) + 8.0;
+        ([layout.grid.0, layout.grid.1, w, 14.0], label)
+    }
+    /// What a slot of a shown recipe holds now: its stacks cycle once a second.
+    fn recipe_slot_now(&self, recipe: usize, slot: usize) -> Option<&(BrowserStack, ItemStack)> {
+        let pages = self.mods.browser.recipes.as_ref()?;
+        let stacks = pages.recipes.get(recipe)?.slots.get(slot)?;
+        let n = pages.since.elapsed().as_secs() as usize;
+        stacks.get(n % stacks.len().max(1))
+    }
+    /// The recipe slot under the pointer: recipe, slot, and its stack now.
+    pub(super) fn recipe_slot_hovered(
+        &self,
+        layout: &Layout,
+    ) -> Option<(usize, usize, BrowserStack, ItemStack)> {
+        let pages = self.mods.browser.recipes.as_ref()?;
+        self.recipes_shown(layout)
+            .into_iter()
+            .find_map(|(i, (x, y))| {
+                let (at, _, _) = pages.recipes[i].places(layout.width());
+                at.iter().enumerate().find_map(|(k, &(sx, sy))| {
+                    if !inside(self.cursor, [x + sx, y + sy, SLOT, SLOT]) {
+                        return None;
+                    }
+                    let (mod_stack, stack) = self.recipe_slot_now(i, k)?.clone();
+                    Some((i, k, mod_stack, stack))
+                })
+            })
+    }
+
+    /// Draws the title row, the page's recipes and the page arrows.
+    pub(super) fn draw_browser_recipes(&mut self, batch: &mut HudBatch, layout: &Layout) {
+        let Some(pages) = &self.mods.browser.recipes else {
+            return;
+        };
+        let cursor = self.cursor;
+        let starts = Self::recipe_pages(pages, layout);
+        let page = pages.page.min(starts.len() - 1);
+        let (title, pages_n) = (pages.title.clone(), starts.len());
+        let (back, label) = self.back_button(layout);
+        let atlas = &self.gui.atlas;
+        let hover = inside(cursor, back);
+        let sprite = if hover {
+            "gui/sprites/widget/button_highlighted"
+        } else {
+            "gui/sprites/widget/button"
+        };
+        horizon_client::ui::nine_slice(
+            batch,
+            atlas,
+            sprite,
+            back[0],
+            back[1],
+            back[2],
+            back[3],
+            u32::MAX,
+        );
+        batch.text(atlas, &label, back[0] + 4.0, back[1] + 3.0, u32::MAX, true);
+        horizon_client::widgets::record(&label, back, true);
+        let room = layout.width() - back[2] - 4.0;
+        let fit = atlas.font.fit(&title, room);
+        let shown: String = title.chars().take(fit).collect();
+        batch.text(
+            atlas,
+            &shown,
+            back[0] + back[2] + 4.0,
+            back[1] + 3.0,
+            u32::MAX,
+            true,
+        );
+        if pages_n > 1 {
+            let labels = [
+                self.translate("gui.recipebook.previous_page", "Previous Page"),
+                self.translate("gui.recipebook.next_page", "Next Page"),
+            ];
+            let visible = [page > 0, page + 1 < pages_n];
+            let atlas = &self.gui.atlas;
+            for (((x, y), name), (label, visible)) in layout
+                .arrows()
+                .into_iter()
+                .zip(["page_backward", "page_forward"])
+                .zip(labels.iter().zip(visible))
+            {
+                if !visible {
+                    continue;
+                }
+                let suffix = if inside(cursor, [x, y, 12.0, 17.0]) {
+                    "_highlighted"
+                } else {
+                    ""
+                };
+                batch.sprite(
+                    atlas,
+                    &format!("gui/sprites/recipe_book/{name}{suffix}"),
+                    x,
+                    y,
+                );
+                horizon_client::widgets::record(label, [x, y, 12.0, 17.0], true);
+            }
+            let text = format!("{}/{pages_n}", page + 1);
+            let w = HudBatch::text_width(atlas, &text);
+            let x = (layout.grid.0 + (layout.width() - w) / 2.0).floor();
+            batch.text(atlas, &text, x, layout.arrows_y + 5.0, u32::MAX, true);
+        }
+        for (i, (x, y)) in self.recipes_shown(layout) {
+            let Some(r) = self.mods.browser.recipes.as_ref().map(|p| &p.recipes[i]) else {
+                break;
+            };
+            let (at, arrow, action) = r.places(layout.width());
+            let h = r.block(layout.width());
+            let (cooking, note, button) =
+                (r.layout == BrowserLayout::Cooking, r.note.clone(), r.action);
+            let atlas = &self.gui.atlas;
+            for &(sx, sy) in at.iter().filter(|p| p.0.is_finite()) {
+                batch.sprite(atlas, "gui/sprites/container/slot", x + sx, y + sy);
+            }
+            if cooking {
+                batch.sprite(
+                    atlas,
+                    "gui/sprites/container/furnace/lit_progress",
+                    x + 2.0,
+                    y + SLOT + 2.0,
+                );
+            }
+            batch.sprite(
+                atlas,
+                "gui/sprites/container/furnace/burn_progress",
+                x + arrow.0,
+                y + arrow.1,
+            );
+            if let Some(enabled) = button {
+                let rect = [x + action.0, y + action.1, 12.0, 12.0];
+                let sprite = match (enabled, inside(cursor, rect)) {
+                    (false, _) => "gui/sprites/widget/button_disabled",
+                    (true, true) => "gui/sprites/widget/button_highlighted",
+                    (true, false) => "gui/sprites/widget/button",
+                };
+                horizon_client::ui::nine_slice(
+                    batch,
+                    atlas,
+                    sprite,
+                    rect[0],
+                    rect[1],
+                    12.0,
+                    12.0,
+                    u32::MAX,
+                );
+                let color = if enabled {
+                    u32::MAX
+                } else {
+                    rgba(160, 160, 160, 255)
+                };
+                batch.text(atlas, "+", rect[0] + 3.0, rect[1] + 2.0, color, true);
+                horizon_client::widgets::record(&format!("+ {i}"), rect, enabled);
+            }
+            if !note.is_empty() {
+                batch.text(atlas, &note, x, y + h + 2.0, rgba(224, 224, 224, 255), true);
+            }
+            for (k, &(sx, sy)) in at.iter().enumerate().filter(|(_, p)| p.0.is_finite()) {
+                let Some((_, stack)) = self.recipe_slot_now(i, k).cloned() else {
+                    continue;
+                };
+                self.draw_item(batch, &stack, x + sx + 1.0, y + sy + 1.0);
+                if inside(cursor, [x + sx, y + sy, SLOT, SLOT]) {
+                    batch.fill(
+                        &self.gui.atlas,
+                        x + sx + 1.0,
+                        y + sy + 1.0,
+                        16.0,
+                        16.0,
+                        rgba(255, 255, 255, 128),
+                    );
+                }
+                let name = self.pack.names.display_item(&stack.item);
+                horizon_client::widgets::record_as(
+                    &format!("{name} {i}:{k}"),
+                    [x + sx + 1.0, y + sy + 1.0, 16.0, 16.0],
+                    true,
+                    horizon_client::widgets::Kind::Button,
+                );
+            }
+        }
+    }
+
+    /// A press on the recipes: true when it hit one of their parts.
+    pub(super) fn browser_recipes_press(
+        &mut self,
+        layout: &Layout,
+        owner: usize,
+        right: bool,
+    ) -> bool {
+        let Some(pages) = &self.mods.browser.recipes else {
+            return false;
+        };
+        let cursor = self.cursor;
+        let starts = Self::recipe_pages(pages, layout);
+        let page = pages.page.min(starts.len() - 1);
+        let [back_arrow, forward] = layout.arrows();
+        let turn = if page > 0 && inside(cursor, [back_arrow.0, back_arrow.1, 12.0, 17.0]) {
+            Some(page - 1)
+        } else if page + 1 < starts.len() && inside(cursor, [forward.0, forward.1, 12.0, 17.0]) {
+            Some(page + 1)
+        } else {
+            None
+        };
+        if let Some(to) = turn {
+            if let Some(p) = self.mods.browser.recipes.as_mut() {
+                p.page = to;
+            }
+            self.audio
+                .play("minecraft:ui.button.click", None, 0.25, 1.0);
+            self.mods
+                .mods
+                .browser_event(owner, BrowserEvent::Page(starts[to] as u32));
+            return true;
+        }
+        if inside(cursor, self.back_button(layout).0) {
+            self.audio
+                .play("minecraft:ui.button.click", None, 0.25, 1.0);
+            self.mods.mods.browser_event(owner, BrowserEvent::Back);
+            return true;
+        }
+        if let Some((recipe, slot, stack, _)) = self.recipe_slot_hovered(layout) {
+            let event = BrowserEvent::SlotClicked(BrowserSlotClick {
+                recipe: recipe as u32,
+                slot: slot as u32,
+                stack,
+                right,
+            });
+            self.mods.mods.browser_event(owner, event);
+            return true;
+        }
+        let action = self.recipes_shown(layout).into_iter().find(|&(i, (x, y))| {
+            let r = &pages.recipes[i];
+            let (_, _, (ax, ay)) = r.places(layout.width());
+            r.action.is_some() && inside(cursor, [x + ax, y + ay, 12.0, 12.0])
+        });
+        if let Some((i, _)) = action {
+            if pages.recipes[i].action == Some(true) {
+                self.audio
+                    .play("minecraft:ui.button.click", None, 0.25, 1.0);
+                self.mods
+                    .mods
+                    .browser_event(owner, BrowserEvent::Action(i as u32));
+            }
+            return true;
+        }
+        false
+    }
+}

From 8526305faa2a15aa0b3f737ad5b0c4ea5d0e9bc2 Mon Sep 17 00:00:00 2001
From: Senjin <senjin@hatchling.org>
Date: Mon, 26 Oct 2026 18:04:54 +0100
Subject: [PATCH 157/475] HDR: mark only the sun's and moon's discs, not their
 whole quads

The celestial pass wrote alpha 0 over each quad, so HDR output lifted a
square of bright daytime sky around the sun. It now draws premultiplied
(one, one), which looks the same, and its alpha is how much a texel adds;
the blend takes that off the frame's alpha, so only the discs shine. The
dim End sky, drawn by the same pass, stays unmarked. fs_celestial keeps
its own blend for lightning and additive entities.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/entity.wgsl | 17 +++++++++++++++--
 crates/horizon-client/src/gfx.rs      | 13 +++++++------
 2 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl
index 2e865dfb1..93c2a4105 100644
--- a/crates/horizon-client/src/entity.wgsl
+++ b/crates/horizon-client/src/entity.wgsl
@@ -208,9 +208,22 @@ fn linear_fog(d: f32, start: f32, end: f32) -> f32 {
     return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
 }
 
+fn celestial_color(in: Out) -> vec4<f32> {
+    return textureSample(atlas, atlas_sampler, in.uv) * in.color * in.light_color;
+}
 @fragment fn fs_celestial(in: Out) -> @location(0) vec4<f32> {
-    let color = textureSample(atlas, atlas_sampler, in.uv) * in.color * in.light_color;
-    return color;
+    return celestial_color(in);
+}
+
+// The sky's celestial pass (sun, moon, the End sky): fs_celestial's light,
+// premultiplied for an additive (one, one) blend, and as alpha how much of it
+// the texel adds, which the blend takes off the frame's alpha. HDR output
+// (hdr.wgsl) lifts only where that left it low: the sun's and moon's discs, not
+// the dark rest of their quads or the dim End sky.
+@fragment fn fs_sky_celestial(in: Out) -> @location(0) vec4<f32> {
+    let color = celestial_color(in);
+    let added = color.rgb * color.a;
+    return vec4(added, smoothstep(0.1, 0.3, max(added.r, max(added.g, added.b))));
 }
 
 // RenderPipelines.WATER_MASK: depth only (the pipeline masks the colour off).
diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index 904370c04..c18f2cb6c 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -1939,22 +1939,23 @@ impl Renderer {
             multisample: Default::default(),
             fragment: Some(wgpu::FragmentState {
                 module: &entity_shader,
-                entry_point: Some("fs_celestial"),
+                entry_point: Some("fs_sky_celestial"),
                 compilation_options: Default::default(),
                 targets: &[Some(wgpu::ColorTargetState {
                     format: config.format.remove_srgb_suffix(),
-                    // RenderPipelines.CELESTIAL: additive (src alpha, one). The
-                    // alpha goes to 0: HDR output (hdr.wgsl) lets the sun and
-                    // moon shine; nothing else reads the frame's alpha.
+                    // RenderPipelines.CELESTIAL: additive (src alpha, one), with
+                    // the colour premultiplied in fs_sky_celestial. Its alpha is
+                    // how much a texel adds: HDR output (hdr.wgsl) lets the sun's
+                    // and moon's discs shine; nothing else reads the frame's alpha.
                     blend: Some(wgpu::BlendState {
                         color: wgpu::BlendComponent {
-                            src_factor: wgpu::BlendFactor::SrcAlpha,
+                            src_factor: wgpu::BlendFactor::One,
                             dst_factor: wgpu::BlendFactor::One,
                             operation: wgpu::BlendOperation::Add,
                         },
                         alpha: wgpu::BlendComponent {
                             src_factor: wgpu::BlendFactor::Zero,
-                            dst_factor: wgpu::BlendFactor::Zero,
+                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
                             operation: wgpu::BlendOperation::Add,
                         },
                     }),

From e8ae26c27016790f088eb6b4eeb1650ac5dffee5 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:09:01 +0100
Subject: [PATCH 158/475] Carry the exploding mob's kind with its blast and
 anger bees at guests too

---
 .../examples/probe/mob_ai_probe.rs            |  2 +-
 crates/horizon-client/src/game/beehives.rs    | 34 ++++++++++++++++---
 crates/horizon-client/src/game/creatures.rs   |  9 +++--
 crates/horizon-client/src/mobs.rs             |  4 ++-
 crates/horizon-client/src/mobs/hostile.rs     |  1 +
 crates/horizon-client/src/mobs/sulfur_cube.rs |  1 +
 crates/horizon-client/src/mobs/wither.rs      |  1 +
 7 files changed, 41 insertions(+), 11 deletions(-)

diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs
index ecdf02901..2f3cc70da 100644
--- a/crates/horizon-client/examples/probe/mob_ai_probe.rs
+++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs
@@ -580,7 +580,7 @@ fn player_hurt(player: Option<&PlayerView>, e: &MobEvent) -> bool {
     match e {
         MobEvent::AttackPlayer(amount, _) | MobEvent::DamagePlayer { amount, .. } => *amount > 0.0,
         // ServerExplosion.hurtEntities: within twice the radius every hit does damage.
-        MobEvent::Explode(at, radius) => {
+        MobEvent::Explode(at, radius, _) => {
             let d = Vec3::new(at[0], at[1], at[2])
                 .distance_squared(p.position)
                 .sqrt();
diff --git a/crates/horizon-client/src/game/beehives.rs b/crates/horizon-client/src/game/beehives.rs
index 258610f5e..1335377c5 100644
--- a/crates/horizon-client/src/game/beehives.rs
+++ b/crates/horizon-client/src/game/beehives.rs
@@ -195,7 +195,8 @@ impl Game<'_> {
         self.anger_nearby_bees(at);
     }
     /// `BeehiveBlock.angerNearbyBees`: bees within 8 blocks (6 up and down)
-    /// without a target go for a player in the same box.
+    /// without a target go for a random player in the same box, the window's
+    /// own or a guest (`None` is the window's player).
     pub(super) fn anger_nearby_bees(&mut self, at: [i32; 3]) {
         let min = Vec3::new(
             f64::from(at[0]) - 8.0,
@@ -203,10 +204,24 @@ impl Game<'_> {
             f64::from(at[2]) - 8.0,
         );
         let area = Aabb::new(min, Vec3::new(min.x + 17.0, min.y + 13.0, min.z + 17.0));
-        if !self
+        let mut players: Vec<Option<u32>> = Vec::new();
+        if self
             .player_view()
             .is_some_and(|p| p.bounds.intersects(area))
         {
+            players.push(None);
+        }
+        if let Some(host) = self.lan.as_ref() {
+            players.extend(
+                host.hub
+                    .guests
+                    .iter()
+                    .filter(|g| host.hub.here(g) && g.loaded && !g.dead)
+                    .filter(|g| super::lan_mobs::guest_bounds(g).intersects(area))
+                    .map(|g| Some(g.conn)),
+            );
+        }
+        if players.is_empty() {
             return;
         }
         let mut bees: Vec<usize> = (0..self.mobs.len())
@@ -219,9 +234,20 @@ impl Game<'_> {
             .collect();
         bees.retain(|&i| self.mobs[i].ai.target.is_none());
         for i in bees {
-            // Util.getRandom over the one player.
-            let _ = self.world.random.next_int_bound(1);
+            // Util.getRandom over the players.
+            let pick = self
+                .world
+                .random
+                .next_int_bound(players.len() as i32)
+                .unwrap_or(0) as usize;
             self.mobs[i].ai.target = Some(Who::Player);
+            // The player a mob sees is its guest binding, else the window's.
+            if let Some(host) = self.lan.as_mut() {
+                match players[pick] {
+                    Some(conn) => host.mob_players.insert(self.mobs[i].id, conn),
+                    None => host.mob_players.remove(&self.mobs[i].id),
+                };
+            }
         }
     }
 }
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 6e6610dcc..fd0f5f5de 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -901,7 +901,7 @@ impl Game<'_> {
                     owner,
                 } => self.add_fangs(at, yaw, delay, owner),
                 MobEvent::Shoot(..) => {}
-                MobEvent::Explode(at, radius) => {
+                MobEvent::Explode(at, radius, species) => {
                     // The exploding mob causes the damage (Creeper.explodeCreeper).
                     let source_mob = self
                         .mobs
@@ -916,10 +916,9 @@ impl Game<'_> {
                     }
                     self.combat.explosion_source = source_mob;
                     // Only a creeper or a wither empties the hives it blows up.
-                    let empties_hives = source_mob
-                        .and_then(|id| self.mobs.iter().find(|m| m.id == id))
-                        .is_some_and(|m| matches!(m.species(), Species::Creeper | Species::Wither));
-                    let result = if empties_hives {
+                    // The creeper is already gone from the list, so the event
+                    // carries its kind.
+                    let result = if matches!(species, Species::Creeper | Species::Wither) {
                         self.with_hive_emptying_blast(|g| g.explode(at, radius))
                     } else {
                         self.explode(at, radius)
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 1b5dddbe7..a97d3514e 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -965,7 +965,9 @@ pub enum MobEvent {
         owner: u32,
     },
     Shoot([f64; 3], [f64; 3]),
-    Explode([f64; 3], f32),
+    /// The centre, the radius and the kind of the mob blowing up (it may be
+    /// gone from the list by the time the blast is handled).
+    Explode([f64; 3], f32, Species),
     /// Melee or ranged damage to another mob.
     AttackMob {
         target: u32,
diff --git a/crates/horizon-client/src/mobs/hostile.rs b/crates/horizon-client/src/mobs/hostile.rs
index 0d3feaa6c..8ad69b030 100644
--- a/crates/horizon-client/src/mobs/hostile.rs
+++ b/crates/horizon-client/src/mobs/hostile.rs
@@ -180,6 +180,7 @@ pub fn creeper_tick(m: &mut Mob, events: &mut Vec<MobEvent>) {
         events.push(MobEvent::Explode(
             [m.position.x, m.position.y, m.position.z],
             radius,
+            m.species(),
         ));
         m.removed = true;
     }
diff --git a/crates/horizon-client/src/mobs/sulfur_cube.rs b/crates/horizon-client/src/mobs/sulfur_cube.rs
index 00b846b86..2af0d7362 100644
--- a/crates/horizon-client/src/mobs/sulfur_cube.rs
+++ b/crates/horizon-client/src/mobs/sulfur_cube.rs
@@ -370,6 +370,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         events.push(MobEvent::Explode(
             [m.position.x, m.position.y + 0.0625, m.position.z],
             power,
+            m.species(),
         ));
         m.removed = true;
         return;
diff --git a/crates/horizon-client/src/mobs/wither.rs b/crates/horizon-client/src/mobs/wither.rs
index 6702686c5..7f1fc0db2 100644
--- a/crates/horizon-client/src/mobs/wither.rs
+++ b/crates/horizon-client/src/mobs/wither.rs
@@ -221,6 +221,7 @@ pub fn custom_server_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEven
             events.push(MobEvent::Explode(
                 [m.position.x, m.eye_y(), m.position.z],
                 7.0,
+                m.species(),
             ));
             // Global level event 1023.
             if !m.silent {

From de141bb7cb6ad3260a9dff083fc7ad35dd2cf8cc Mon Sep 17 00:00:00 2001
From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com>
Date: Mon, 26 Oct 2026 17:11:51 +0000
Subject: [PATCH 159/475] Fix recipe book settings persistence on the server

Send open/filter changes to the authoritative player's recipe book and cover packet settings plus save/reopen in both single-player modes.

Co-Authored-By: OpenCode GPT-6.1 Sol <noreply@opencode.ai>
---
 .../examples/probe/recipe_book_fixture.rs     | 23 ++++++-
 crates/horizon-client/src/game/agent.rs       |  3 +
 crates/horizon-client/src/game/recipe_book.rs | 18 +++++
 crates/horizon-client/src/lan/hub.rs          | 10 +++
 crates/horizon-client/tests/lan_bot.rs        | 69 +++++++++++++++++++
 crates/horizon-protocol/src/packets/play.rs   |  1 +
 .../horizon-protocol/src/packets/recipes.rs   | 27 ++++++++
 .../parity/VanillaRecipeBookOracle.java       | 21 +++++-
 tools/lan_e2e.py                              | 59 ++++++++++++++++
 tools/test_recipe_book_parity.py              | 11 ++-
 10 files changed, 236 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/examples/probe/recipe_book_fixture.rs b/crates/horizon-client/examples/probe/recipe_book_fixture.rs
index ce2afe624..2dda3b109 100644
--- a/crates/horizon-client/examples/probe/recipe_book_fixture.rs
+++ b/crates/horizon-client/examples/probe/recipe_book_fixture.rs
@@ -5,6 +5,10 @@
 //!
 //! usage: recipe_book_fixture RESOURCES CASES OUTPUT
 use horizon_client::recipe_book::{BookType, RecipeIndex, Settings};
+use horizon_protocol::{
+    buf::{Codec, Reader, Writer},
+    packets::recipes::RecipeBookChangeSettings,
+};
 use horizon_world::nbt::Tag;
 use serde_json::Value;
 use std::{collections::BTreeSet, fs, path::Path};
@@ -93,8 +97,23 @@ pub fn main() -> horizon_client::Result<()> {
                         _ => BookType::Smoker,
                     }
                     .index();
-                    book.open[i] = op["open"].as_bool().unwrap_or(false);
-                    book.filtering[i] = op["filtering"].as_bool().unwrap_or(false);
+                    let packet = RecipeBookChangeSettings {
+                        book_type: i as i32,
+                        open: op["open"].as_bool().unwrap_or(false),
+                        filtering: op["filtering"].as_bool().unwrap_or(false),
+                    };
+                    let mut wire = Writer::new();
+                    RecipeBookChangeSettings::write(&packet, &mut wire);
+                    extra = format!(
+                        " packet={}",
+                        wire.data
+                            .iter()
+                            .map(|b| format!("{b:02x}"))
+                            .collect::<String>()
+                    );
+                    let decoded = RecipeBookChangeSettings::read(&mut Reader::new(&wire.data))?;
+                    book.open[decoded.book_type as usize] = decoded.open;
+                    book.filtering[decoded.book_type as usize] = decoded.filtering;
                 }
                 "save" => {
                     let tag = book.write();
diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs
index 0d2d218ab..1433e92e8 100644
--- a/crates/horizon-client/src/game/agent.rs
+++ b/crates/horizon-client/src/game/agent.rs
@@ -686,9 +686,12 @@ impl Game<'_> {
             // the recipe buttons of the page, page arrows, filter and tabs.
             let book = self.recipe_book_targets();
             if !book.is_empty() {
+                let (open, filtering) = self.recipe_book_flags().unwrap_or_default();
                 v["recipe_book"] = json!({
                     "targets": book.iter().map(|t| t.rect).collect::<Vec<_>>(),
                     "known": self.recipe_book_known(),
+                    "open": open,
+                    "filtering": filtering,
                 });
             }
             v["slot_ids"] = json!(
diff --git a/crates/horizon-client/src/game/recipe_book.rs b/crates/horizon-client/src/game/recipe_book.rs
index 96e12d79b..bf0d1c370 100644
--- a/crates/horizon-client/src/game/recipe_book.rs
+++ b/crates/horizon-client/src/game/recipe_book.rs
@@ -590,6 +590,7 @@ impl Game<'_> {
         if inside(cursor, bx, by, 20.0, 18.0) {
             let open = !self.book_open(book_type);
             self.level.recipe_book.open[book_type.index()] = open;
+            self.send_book_settings(book_type);
             if !open {
                 self.recipe_ui.overlay = None;
             }
@@ -675,6 +676,7 @@ impl Game<'_> {
         if inside(cursor, xo + 110.0, yo + 12.0, 26.0, 16.0) {
             let filtering = !self.book_filtering(book_type);
             self.level.recipe_book.filtering[book_type.index()] = filtering;
+            self.send_book_settings(book_type);
             self.recipe_ui.page = 0;
             self.audio
                 .play("minecraft:ui.button.click", None, 0.25, 1.0);
@@ -695,6 +697,22 @@ impl Game<'_> {
         }
         false
     }
+    /// `RecipeBookComponent.sendUpdateSettings`: the server owns the saved book.
+    fn send_book_settings(&self, book_type: BookType) {
+        self.send(
+            horizon_protocol::packets::play::Serverbound::RecipeBookChangeSettings(
+                horizon_protocol::packets::recipes::RecipeBookChangeSettings {
+                    book_type: book_type.index() as i32,
+                    open: self.book_open(book_type),
+                    filtering: self.book_filtering(book_type),
+                },
+            ),
+        );
+    }
+    pub(super) fn recipe_book_flags(&self) -> Option<(bool, bool)> {
+        let book = self.active_book()?;
+        Some((self.book_open(book), self.book_filtering(book)))
+    }
     /// How many displays the client's book holds.
     pub(super) fn recipe_book_known(&self) -> usize {
         self.recipe_ui.client.displays().len()
diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs
index b462536b9..dc0dbe89d 100644
--- a/crates/horizon-client/src/lan/hub.rs
+++ b/crates/horizon-client/src/lan/hub.rs
@@ -1930,6 +1930,7 @@ impl Hub {
                 | S::PlayerLoaded(_)
                 | S::ChunkBatchReceived(_)
                 | S::ClientInformation(_)
+                | S::RecipeBookChangeSettings(_)
                 | S::ClientTickEnd(_)
                 | S::KeepAlive(_) => false,
                 S::MovePlayerPos(p) => self.moved_far(i, [p.x, p.y, p.z]),
@@ -1996,6 +1997,15 @@ impl Hub {
                     g.max_unacknowledged = 10;
                 }
                 S::ClientTickEnd(_) => self.guests[i].position_this_tick = false,
+                // ServerGamePacketListenerImpl.handleRecipeBookChangeSettingsPacket.
+                S::RecipeBookChangeSettings(p) => {
+                    if let Some(book) = crate::recipe_book::BookType::ALL.get(p.book_type as usize)
+                    {
+                        let settings = &mut self.guests[i].recipe_book;
+                        settings.open[book.index()] = p.open;
+                        settings.filtering[book.index()] = p.filtering;
+                    }
+                }
                 S::ClientInformation(info) => {
                     let g = &mut self.guests[i];
                     g.view_distance =
diff --git a/crates/horizon-client/tests/lan_bot.rs b/crates/horizon-client/tests/lan_bot.rs
index 34e8265a1..81ec192f5 100644
--- a/crates/horizon-client/tests/lan_bot.rs
+++ b/crates/horizon-client/tests/lan_bot.rs
@@ -278,6 +278,75 @@ fn run<T: Send + 'static>(
     handle.join().unwrap().unwrap()
 }
 
+#[test]
+fn recipe_settings_packets_update_only_the_players_book_and_survive_save() {
+    let Some(resources) = resources() else {
+        return;
+    };
+    let mut s = server(&resources);
+    let port = s.hub.lan.port;
+    let _bot = run(&mut s, move || connect(port, "RecipeSettings", true));
+    let deadline = Instant::now() + Duration::from_secs(5);
+    while s.hub.guests.is_empty() {
+        s.tick(&[]);
+        assert!(Instant::now() < deadline, "guest did not join");
+        thread::yield_now();
+    }
+    for book in 0..4 {
+        for flags in 0..4 {
+            let open = flags & 1 != 0;
+            let filtering = flags & 2 != 0;
+            let before = s.hub.guests[0].recipe_book.clone();
+            // Vanilla's wire payload: RecipeBookType VarInt, open, filtering.
+            let packet = S::decode(
+                horizon_protocol::ids::play::serverbound::RECIPE_BOOK_CHANGE_SETTINGS,
+                &[book, u8::from(open), u8::from(filtering)],
+            )
+            .unwrap();
+            s.hub.guests[0].inbox.push_back(packet);
+            s.tick(&[]);
+            let settings = &s.hub.guests[0].recipe_book;
+            for i in 0..4 {
+                assert_eq!(
+                    settings.open[i],
+                    if i == usize::from(book) {
+                        open
+                    } else {
+                        before.open[i]
+                    }
+                );
+                assert_eq!(
+                    settings.filtering[i],
+                    if i == usize::from(book) {
+                        filtering
+                    } else {
+                        before.filtering[i]
+                    }
+                );
+            }
+            let mut saved = horizon_client::save::Level::default();
+            horizon_client::lan::playerdata::store(&s.hub.guests[0], &mut saved);
+            let mut reopened = horizon_client::save::Level::default();
+            reopened.read_player(&saved.player_tag());
+            assert_eq!(reopened.recipe_book.open, settings.open);
+            assert_eq!(reopened.recipe_book.filtering, settings.filtering);
+        }
+    }
+    for book_type in [-1, 4] {
+        let mut wire = horizon_protocol::buf::Writer::new();
+        wire.varint(book_type);
+        wire.bool(true);
+        wire.bool(true);
+        assert!(
+            S::decode(
+                horizon_protocol::ids::play::serverbound::RECIPE_BOOK_CHANGE_SETTINGS,
+                &wire.data,
+            )
+            .is_err()
+        );
+    }
+}
+
 #[test]
 fn sprint_commands_survive_keyboard_input_changes() {
     let Some(resources) = resources() else {
diff --git a/crates/horizon-protocol/src/packets/play.rs b/crates/horizon-protocol/src/packets/play.rs
index 67373cf4b..1c20ed36c 100644
--- a/crates/horizon-protocol/src/packets/play.rs
+++ b/crates/horizon-protocol/src/packets/play.rs
@@ -2219,6 +2219,7 @@ packet_enum!(Serverbound, crate::ids::play::serverbound {
     ChatCommandSigned(ChatCommandSigned) = CHAT_COMMAND_SIGNED,
     ChatSessionUpdate(ChatSessionUpdate) = CHAT_SESSION_UPDATE,
     PlaceRecipe(super::recipes::PlaceRecipe) = PLACE_RECIPE,
+    RecipeBookChangeSettings(super::recipes::RecipeBookChangeSettings) = RECIPE_BOOK_CHANGE_SETTINGS,
     ChunkBatchReceived(ChunkBatchReceived) = CHUNK_BATCH_RECEIVED,
     ClientCommand(ClientCommand) = CLIENT_COMMAND,
     ClientInformation(ClientInformation) = CLIENT_INFORMATION,
diff --git a/crates/horizon-protocol/src/packets/recipes.rs b/crates/horizon-protocol/src/packets/recipes.rs
index c289b8943..dcbe5ffa0 100644
--- a/crates/horizon-protocol/src/packets/recipes.rs
+++ b/crates/horizon-protocol/src/packets/recipes.rs
@@ -500,6 +500,33 @@ impl Codec<RecipeBookSettings> for RecipeBookSettings {
     }
 }
 
+/// ServerboundRecipeBookChangeSettingsPacket: the active book's open and
+/// filtering flags, with its `RecipeBookType` ordinal as a VarInt.
+#[derive(Clone, Debug, PartialEq)]
+pub struct RecipeBookChangeSettings {
+    pub book_type: i32,
+    pub open: bool,
+    pub filtering: bool,
+}
+impl Codec<RecipeBookChangeSettings> for RecipeBookChangeSettings {
+    fn read(r: &mut Reader) -> Result<Self> {
+        let book_type = r.varint()?;
+        if !(0..4).contains(&book_type) {
+            return Err(crate::Error::new("invalid recipe book type"));
+        }
+        Ok(Self {
+            book_type,
+            open: r.bool()?,
+            filtering: r.bool()?,
+        })
+    }
+    fn write(v: &Self, w: &mut Writer) {
+        w.varint(v.book_type);
+        w.bool(v.open);
+        w.bool(v.filtering);
+    }
+}
+
 /// ClientboundPlaceGhostRecipePacket: the recipe to show faded in a menu
 /// whose items were missing.
 #[derive(Clone, Debug, PartialEq)]
diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRecipeBookOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRecipeBookOracle.java
index 60640010b..2cf9d7d48 100644
--- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRecipeBookOracle.java
+++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRecipeBookOracle.java
@@ -1,12 +1,15 @@
 package dev.horizonlab.parity;
 
 import com.google.gson.*;
+import io.netty.buffer.Unpooled;
 import java.io.PrintWriter;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.*;
 import java.util.*;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.nbt.*;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.protocol.game.ServerboundRecipeBookChangeSettingsPacket;
 import net.minecraft.resources.Identifier;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.server.level.ServerPlayer;
@@ -102,8 +105,22 @@ public final class VanillaRecipeBookOracle {
                                 count = kind.equals("give") ? book.addRecipes(holders, player) : book.removeRecipes(holders, player);
                             }
                             case "seen" -> book.removeHighlight(key(op.get("id").getAsString()));
-                            case "set" -> book.setBookSetting(RecipeBookType.valueOf(op.get("type").getAsString()),
-                                op.get("open").getAsBoolean(), op.get("filtering").getAsBoolean());
+                            case "set" -> {
+                                var packet = new ServerboundRecipeBookChangeSettingsPacket(
+                                    RecipeBookType.valueOf(op.get("type").getAsString()),
+                                    op.get("open").getAsBoolean(), op.get("filtering").getAsBoolean());
+                                var buf = new FriendlyByteBuf(Unpooled.buffer());
+                                try {
+                                    ServerboundRecipeBookChangeSettingsPacket.STREAM_CODEC.encode(buf, packet);
+                                    byte[] wire = new byte[buf.readableBytes()];
+                                    buf.getBytes(buf.readerIndex(), wire);
+                                    extra = " packet=" + HexFormat.of().formatHex(wire);
+                                    var decoded = ServerboundRecipeBookChangeSettingsPacket.STREAM_CODEC.decode(buf);
+                                    book.setBookSetting(decoded.getBookType(), decoded.isOpen(), decoded.isFiltering());
+                                } finally {
+                                    buf.release();
+                                }
+                            }
                             case "save" -> {
                                 saved = (CompoundTag) ServerRecipeBook.Packed.CODEC.encodeStart(NbtOps.INSTANCE, book.pack()).getOrThrow();
                                 extra = compound(saved);
diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index 0ec7218d8..1866a6ee3 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -5877,6 +5877,65 @@ CHECKS += ['recipe_removal']
 CHECK_FNS.update(recipe_removal=check_recipe_removal)
 
 
+def check_recipe_settings(host, guest, out):
+    """RecipeBookComponent sends both settings to the server; each player's
+    own book keeps them when the authoritative world saves and reopens (#2290)."""
+    def inventory(game):
+        back_to_game(game)
+        game.raw('key', 'e', 'tap')
+        game.wait(5)
+        return game('screen')['recipe_book']
+
+    def flags(book):
+        return {'open': book['open'], 'filtering': book['filtering']}
+
+    def set_flags(game, opened, filtering):
+        book = inventory(game)
+        if not book['open']:
+            game.raw('click-at', *centre(book['targets'][0]))
+            game.wait(5)
+            book = game('screen')['recipe_book']
+        if book['filtering'] != filtering:
+            target = next(t for t in book['targets'] if t[2:] == [26.0, 16.0])
+            game.raw('click-at', *centre(target))
+            game.wait(5)
+        if not opened:
+            book = game('screen')['recipe_book']
+            game.raw('click-at', *centre(book['targets'][0]))
+            game.wait(5)
+        actual = flags(game('screen')['recipe_book'])
+        assert actual == {'open': opened, 'filtering': filtering}, f'{game.name}: {actual}'
+        game.shot(out, 'recipe-settings-before')
+        back_to_game(game)
+        return actual
+
+    # Deliberately different settings ensure neither player's book overwrites the other's.
+    before = {host.name: set_flags(host, True, True),
+              guest.name: set_flags(guest, False, True)}
+    host.wait(20)
+    guest.raw('disconnect')
+    host.raw('pause')
+    host.raw('click-button', 'Save and Quit to Title')
+    host.raw('wait-for', 'screen', 'title', '--timeout', 120)
+    host.raw('open', 'Lan')
+    host('wait_ready', seconds=400)
+    port = host.raw('lan', 'open', 0, 'commands')['port']
+    guest.raw('connect', f'127.0.0.1:{port}', GUEST_NAME)
+    guest.raw('wait-for', 'loaded', '--timeout', 300)
+    guest.wait(20)
+    after = {}
+    for game in (host, guest):
+        after[game.name] = flags(inventory(game))
+        game.shot(out, 'recipe-settings-reopened')
+        back_to_game(game)
+    assert after == before, f'saved recipe settings reset: before={before}, after={after}'
+    return {'before': before, 'reopened': after}
+
+
+CHECKS += ['recipe_settings']
+CHECK_FNS.update(recipe_settings=check_recipe_settings)
+
+
 def check_shulker_bullets(host, guest, out):
     """ShulkerAttackGoal's bullets reach ClientPacketListener.handleAddEntity, then the existing
     projectile renderer and interpolation, with distinct ids from the server's entity counter."""
diff --git a/tools/test_recipe_book_parity.py b/tools/test_recipe_book_parity.py
index c25f180ac..291adeb86 100644
--- a/tools/test_recipe_book_parity.py
+++ b/tools/test_recipe_book_parity.py
@@ -5,8 +5,9 @@ Each case runs a sequence of operations on a fresh book: awarding recipes
 (advancement rewards, /recipe give, crafting; special recipes are never
 learnt, and the count is the displays added), taking them back, the client
 having seen a highlighted recipe, the open and filter settings of the four
-book types, and saving and loading the player's recipeBook compound (with
-unknown ids dropped, and a compound missing a list ignored). The Java oracle
+book types (through the serverbound settings packet's codec), and saving and
+loading the player's recipeBook compound (with unknown ids dropped, and a
+compound missing a list ignored). The Java oracle
 (VanillaRecipeBookOracle) drives ServerRecipeBook and its codec;
 examples/probe/recipe_book_fixture drives horizon_client::recipe_book. After each
 operation the count, the known and highlighted recipes, the settings and
@@ -35,6 +36,12 @@ def main():
     ids = sorted('minecraft:' + p.stem for p in (lib.RESOURCES / 'data/minecraft/recipe').glob('*.json'))
     rng = random.Random(args.seed)
     cases = []
+    # Every book and flag combination crosses the wire, then survives a save/load.
+    for book_type in TYPES:
+        for opened in (False, True):
+            for filtering in (False, True):
+                cases.append({'ops': [{'op': 'set', 'type': book_type, 'open': opened,
+                                       'filtering': filtering}, {'op': 'save'}, {'op': 'load'}]})
     for _ in range(args.cases):
         ops, known = [], set()
         for _ in range(rng.randrange(1, 12)):

From 61ff050927187a07dc52c5083ac46e24d58ef230 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 18:11:56 +0100
Subject: [PATCH 160/475] mods: drop the sandbox test's unused LEVEL import

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-mods/tests/sandbox.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs
index a5e95ddfa..96842e439 100644
--- a/crates/horizon-mods/tests/sandbox.rs
+++ b/crates/horizon-mods/tests/sandbox.rs
@@ -205,7 +205,7 @@ fn undeclared_capabilities_are_refused() {
 /// from the functions they import.
 #[test]
 fn a_mod_for_a_newer_horizon_is_refused() {
-    use horizon_mods::api_level::{LEVEL, imports, needed};
+    use horizon_mods::api_level::{imports, needed};
     use wit_parser::{ManglingAndAbi, Resolve};
     let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
     let wit = std::fs::read_to_string(root.join("crates/horizon-mod-sdk/wit/horizon.wit"))

From 7a3a19697a75e9f7bcf42da70d9f665b7937239c Mon Sep 17 00:00:00 2001
From: socksprox <info@shadowfly.net>
Date: Mon, 26 Oct 2026 18:13:22 +0100
Subject: [PATCH 161/475] Resolve dynamic head profiles, and re-upload evicted
 skins

Player heads whose profile carries only a name or only a UUID
(ResolvableProfile.Dynamic) resolved to nothing, so heads some servers
send that way kept the default skin. Adds skins::Resolver
(ProfileResolver.Cached: profiles/getByName then
session/getProfileById through the services discovery document, on
background threads) used by placed heads, head items and mannequins; the
profile-derived DefaultPlayerSkin stands in until the download lands,
with the name's offline UUID keying it for name-only profiles.

A skin evicted from the atlas's 128 slots could never return: the decoded
image was dropped and show_skin simply failed. The downloader now keeps
the images (and the disk cache backs them), and again queues the upload
again where the tab list, level players, mannequins and heads notice the
missing sprite.

profile_tag keeps id so id-only and name+id profiles survive into the
item data JSON, and the player-head item fallback matches vanilla's
slim/steve (was wide/steve).

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 crates/horizon-client/src/auth.rs             |   2 +-
 .../horizon-client/src/block_entity_render.rs |   9 +-
 crates/horizon-client/src/containers.rs       |  16 +-
 crates/horizon-client/src/game.rs             |   4 +
 .../src/game/block_entity_anims.rs            |  31 +-
 crates/horizon-client/src/game/item_draw.rs   |  18 +-
 crates/horizon-client/src/game/remote.rs      |  41 +-
 .../horizon-client/src/item_render/special.rs |   2 +-
 crates/horizon-client/src/item_sync.rs        |  11 +
 crates/horizon-client/src/skins.rs            | 512 +++++++++++++++++-
 10 files changed, 601 insertions(+), 45 deletions(-)

diff --git a/crates/horizon-client/src/auth.rs b/crates/horizon-client/src/auth.rs
index b899ea5d5..a86992735 100644
--- a/crates/horizon-client/src/auth.rs
+++ b/crates/horizon-client/src/auth.rs
@@ -179,7 +179,7 @@ fn agent() -> ureq::Agent {
 }
 
 /// The discovery document, fetched once per game (a failure is retried next time).
-fn discovery() -> Result<Arc<serde_json::Value>, JoinError> {
+pub(crate) fn discovery() -> Result<Arc<serde_json::Value>, JoinError> {
     static CACHE: Mutex<Option<Arc<serde_json::Value>>> = Mutex::new(None);
     if let Some(d) = CACHE.lock().unwrap().clone() {
         return Ok(d);
diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs
index 28a876d80..a6f7b1991 100644
--- a/crates/horizon-client/src/block_entity_render.rs
+++ b/crates/horizon-client/src/block_entity_render.rs
@@ -734,7 +734,7 @@ pub struct Scene<'a> {
     /// The skin sprite a `player_head` shows at a position (`SkullBlockRenderer`
     /// profile → skin): a downloaded `skins/<sha1>` slot or the profile's
     /// `DefaultPlayerSkin` fallback; None keeps `SKIN_BY_TYPE` (`DefaultPlayerSkin.getDefaultTexture`, slim steve).
-    pub skull: &'a dyn Fn([i32; 3]) -> Option<&'a str>,
+    pub skull: &'a dyn Fn([i32; 3]) -> Option<String>,
     /// Font glyph cell (none for blank glyphs such as the space) and advance.
     pub glyph: &'a dyn Fn(char) -> (Option<Rect>, f32),
 }
@@ -1286,11 +1286,12 @@ impl BlockEntityRenderer {
                 };
                 // SkullBlockRenderer.getRenderType: the profile's skin when it
                 // resolves, `SKIN_BY_TYPE` (steve) otherwise.
-                let texture = if *kind == SkullType::Player {
-                    (scene.skull)(pos).unwrap_or(texture)
+                let skin = if *kind == SkullType::Player {
+                    (scene.skull)(pos)
                 } else {
-                    texture
+                    None
                 };
+                let texture = skin.as_deref().unwrap_or(texture);
                 let (Some(model), Some(paint)) =
                     (self.models.get(model), paint(texture, 0xFFFFFF, packed))
                 else {
diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs
index 6aba0970e..e93626584 100644
--- a/crates/horizon-client/src/containers.rs
+++ b/crates/horizon-client/src/containers.rs
@@ -187,6 +187,9 @@ impl Skull {
 #[derive(Clone, Debug)]
 pub struct SkullSkin {
     pub download: Option<(String, String)>,
+    /// `ResolvableProfile.nameOrId` when the profile is `Dynamic` (a name or
+    /// an id only): the key `skins::Resolver` resolves it by.
+    pub dynamic: Option<crate::skins::NameOrId>,
     pub fallback: &'static str,
 }
 impl SkullSkin {
@@ -195,10 +198,21 @@ impl SkullSkin {
             let location = crate::skins::skin_location(&crate::skins::texture_hash(&url)?);
             Some((url, location))
         });
+        // A `Dynamic` profile (a name or id only) resolves through the
+        // services when the skull is drawn.
+        let dynamic = crate::skins::dynamic_nbt(profile);
         // DefaultPlayerSkin.get(id), or getDefaultSkin (slim steve) without an id.
         let fallback = crate::skins::profile_uuid_nbt(profile)
+            .or_else(|| {
+                crate::skins::nbt_text(profile.get("name"))
+                    .map(|name| horizon_protocol::crypto::offline_uuid(&name))
+            })
             .map_or("entity/player/slim/steve", crate::tab_list::default_skin);
-        Self { download, fallback }
+        Self {
+            download,
+            dynamic,
+            fallback,
+        }
     }
 }
 /// The skull and head blocks (`SkullBlock`, `WallSkullBlock`): every
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 755a00f6f..734a06df5 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -1471,6 +1471,9 @@ struct Game<'a> {
     /// Player skin downloads, and which skin each atlas skin slot holds
     /// (least recently shown first).
     skin_downloads: RefCell<horizon_client::skins::Downloader>,
+    /// `ProfileResolver.Cached`: `Dynamic` profiles (name- or id-only heads
+    /// and mannequins) resolve through the services in the background.
+    skin_profiles: RefCell<horizon_client::skins::Resolver>,
     skin_slots: Vec<(String, usize)>,
     /// Atlas trim slots in use: (sprite name, slot), least recently drawn first.
     trim_slots: Vec<(String, usize)>,
@@ -12411,6 +12414,7 @@ impl<'a> Game<'a> {
                     .unwrap_or_default()
                     .join("assets/skins"),
             )),
+            skin_profiles: RefCell::new(horizon_client::skins::Resolver::new()),
             skin_slots: Vec::new(),
             trim_slots: Vec::new(),
             cart_models: prepared.cart_models,
diff --git a/crates/horizon-client/src/game/block_entity_anims.rs b/crates/horizon-client/src/game/block_entity_anims.rs
index 3d452596e..d384238cc 100644
--- a/crates/horizon-client/src/game/block_entity_anims.rs
+++ b/crates/horizon-client/src/game/block_entity_anims.rs
@@ -474,21 +474,38 @@ impl Game<'_> {
     /// the player head at `pos`. The skin download is started here; while it
     /// is in flight (or when it cannot be got) the profile's default skin
     /// stands in. A head with no profile answers None: `SKIN_BY_TYPE`.
-    pub(super) fn skull_skin_at(&self, pos: [i32; 3]) -> Option<&str> {
+    pub(super) fn skull_skin_at(&self, pos: [i32; 3]) -> Option<String> {
         let Some(BlockEntity::Skull(skull)) =
             self.world.block_entities.get(&(pos[0], pos[1], pos[2]))
         else {
             return None;
         };
         let skin = skull.skin.as_ref()?;
-        if let Some((url, location)) = &skin.download {
-            self.skin_downloads
-                .borrow_mut()
-                .state(skins::Kind::Skin, url);
-            if self.gui.atlas.sprites.contains_key(location) {
+        // The texture a packed or resolved `textures` property fetches: the
+        // download of a static profile, or the one the services answer for a
+        // `Dynamic` (name- or id-only) profile.
+        let download = skin.download.clone().or_else(|| {
+            let key = skin.dynamic.as_ref()?;
+            let skins::Resolve::Done(Some(profile)) = self.skin_profiles.borrow_mut().state(key)
+            else {
+                return None;
+            };
+            let (value, signature) = profile.textures()?;
+            let url = skins::unpack(&value, signature, &skins::TEXTURE_URIS).skin?;
+            let location = skins::skin_location(&skins::texture_hash(&url)?);
+            Some((url, location))
+        });
+        if let Some((url, location)) = download {
+            let mut downloads = self.skin_downloads.borrow_mut();
+            if self.gui.atlas.sprites.contains_key(&location) {
+                let _ = downloads.state(skins::Kind::Skin, &url);
                 return Some(location);
             }
+            // Its slot was evicted: offer the image again.
+            if downloads.state(skins::Kind::Skin, &url) == skins::Download::Ready {
+                downloads.again(&location);
+            }
         }
-        Some(skin.fallback)
+        Some(skin.fallback.to_owned())
     }
 }
diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs
index 1d79f077d..7bf60e3c0 100644
--- a/crates/horizon-client/src/game/item_draw.rs
+++ b/crates/horizon-client/src/game/item_draw.rs
@@ -129,6 +129,7 @@ pub(super) struct Host<'a> {
     banners: &'a horizon_client::banner::Banners,
     sprites: &'a HashMap<String, Rect>,
     skins: &'a RefCell<horizon_client::skins::Downloader>,
+    profiles: &'a RefCell<horizon_client::skins::Resolver>,
 }
 impl SpecialHost for Host<'_> {
     fn banner_texture(&self, pattern: &str) -> Option<String> {
@@ -144,14 +145,14 @@ impl SpecialHost for Host<'_> {
     fn player_skin(&self, profile: &Value) -> Option<String> {
         // SkullBlockRenderer.getPlayerSkin: SkinManager.getInsecureSkinInformation
         // accepts a texture property without a signature, unlike the tab list.
-        let url = horizon_client::skins::profile_skin_url(profile)?;
-        let location =
-            horizon_client::skins::skin_location(&horizon_client::skins::texture_hash(&url)?);
-        let _ = self
-            .skins
-            .borrow_mut()
-            .state(horizon_client::skins::Kind::Skin, &url);
-        self.sprites.contains_key(&location).then_some(location)
+        // A `Dynamic` profile (a name or id only) resolves through the
+        // services (`PlayerSkinRenderCache.getOrDefault`).
+        Some(horizon_client::skins::head_skin(
+            profile,
+            &mut self.profiles.borrow_mut(),
+            &mut self.skins.borrow_mut(),
+            |location| self.sprites.contains_key(location),
+        ))
     }
 }
 
@@ -194,6 +195,7 @@ impl Game<'_> {
             banners: &self.res.stations().banners,
             sprites: &self.gui.atlas.sprites,
             skins: &self.skin_downloads,
+            profiles: &self.skin_profiles,
         }
     }
     /// The client level as item models read it.
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3ef87c201..3628b9773 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -2778,7 +2778,7 @@ impl Game<'_> {
                 resolved.push((uuid, skin));
             }
         }
-        resolved.retain(|(_, skin)| !skin.starts_with("skins/") || self.show_skin(skin));
+        resolved.retain(|(_, skin)| !skin.starts_with("skins/") || self.again_skin(skin));
         let Some((level, skins, own)) = self.remote.as_mut().map(|r| {
             r.skins = resolved.into_iter().collect();
             (
@@ -2817,11 +2817,9 @@ impl Game<'_> {
             .iter()
             .filter(|m| &*m.kind.id == "minecraft:mannequin" && m.profile.is_some())
             .map(|m| {
-                let t = m
-                    .profile
-                    .as_ref()
-                    .and_then(|p| p.properties.iter().find(|p| p.name == "textures"));
-                let textures = t.map_or_else(Default::default, |t| {
+                let profile = m.profile.as_ref();
+                let t = profile.and_then(|p| p.properties.iter().find(|p| p.name == "textures"));
+                let textures = if let Some(t) = t {
                     let signature = if t.signature.is_some() {
                         horizon_client::skins::Signature::Signed
                     } else {
@@ -2832,7 +2830,30 @@ impl Game<'_> {
                         signature,
                         &horizon_client::skins::TEXTURE_URIS,
                     )
-                });
+                } else {
+                    // `ResolvableProfile.resolveProfile`: no `textures` and
+                    // only a name or an id resolves through the services.
+                    let key = profile.and_then(|p| match (&p.name, p.uuid) {
+                        (Some(name), None) => {
+                            Some(horizon_client::skins::NameOrId::Name(name.clone()))
+                        }
+                        (None, Some(id)) => Some(horizon_client::skins::NameOrId::Id(id)),
+                        _ => None,
+                    });
+                    key.and_then(|key| match self.skin_profiles.borrow_mut().state(&key) {
+                        horizon_client::skins::Resolve::Done(Some(profile)) => {
+                            profile.textures().map(|(value, signature)| {
+                                horizon_client::skins::unpack(
+                                    &value,
+                                    signature,
+                                    &horizon_client::skins::TEXTURE_URIS,
+                                )
+                            })
+                        }
+                        _ => None,
+                    })
+                    .unwrap_or_default()
+                };
                 (m.id, textures)
             })
             .collect();
@@ -2847,7 +2868,7 @@ impl Game<'_> {
             resolved.push((id, skin));
         }
         for (id, skin) in resolved {
-            let skin = skin.filter(|s| !s.starts_with("skins/") || self.show_skin(s));
+            let skin = skin.filter(|s| !s.starts_with("skins/") || self.again_skin(s));
             if let Some(mob) = self
                 .mobs
                 .iter_mut()
@@ -2897,6 +2918,10 @@ impl Game<'_> {
         self.skin_slots.push(e);
         true
     }
+    /// `show_skin`, or — its slot evicted — the image queued for upload again.
+    fn again_skin(&mut self, location: &str) -> bool {
+        self.show_skin(location) || self.skin_downloads.borrow_mut().again(location)
+    }
     /// ChatType decoration: `chat.translation_key` with sender/content parameters.
     /// ChatType.Bound.decorate: the chat type's translation, with the
     /// sender, the target and the message as its parameters, in its style.
diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs
index d42378db1..9e69e9d44 100644
--- a/crates/horizon-client/src/item_render/special.rs
+++ b/crates/horizon-client/src/item_render/special.rs
@@ -498,7 +498,7 @@ pub(super) fn submit(
             let skin = (!argument.is_null())
                 .then(|| host.player_skin(argument))
                 .flatten()
-                .unwrap_or_else(|| "entity/player/wide/steve".to_owned());
+                .unwrap_or_else(|| "entity/player/slim/steve".to_owned());
             part("player", &none, &skin, white, Foil::None);
         }
         SpecialKind::Trident => {
diff --git a/crates/horizon-client/src/item_sync.rs b/crates/horizon-client/src/item_sync.rs
index fc35e15e7..01d90246f 100644
--- a/crates/horizon-client/src/item_sync.rs
+++ b/crates/horizon-client/src/item_sync.rs
@@ -229,6 +229,17 @@ fn profile_tag(p: &Profile) -> Tag {
     if let Some(name) = &p.name {
         entries.push(("name", Tag::String(name.as_str().into())));
     }
+    if let Some(id) = p.id {
+        entries.push((
+            "id",
+            Tag::IntArray(vec![
+                (id >> 96) as i32,
+                (id >> 64) as i32,
+                (id >> 32) as i32,
+                id as i32,
+            ]),
+        ));
+    }
     entries.push(("properties", Tag::List(properties)));
     Tag::compound(entries)
 }
diff --git a/crates/horizon-client/src/skins.rs b/crates/horizon-client/src/skins.rs
index ee6851e00..239e1c3ac 100644
--- a/crates/horizon-client/src/skins.rs
+++ b/crates/horizon-client/src/skins.rs
@@ -116,20 +116,9 @@ pub fn unpack(value: &str, signature: Signature, valid_uris: &[&str]) -> Texture
 /// heads and mannequins read their profile this way, and `SkinManager` lets
 /// those textures be unsigned (`getInsecureSkinInformation`).
 pub fn profile_skin_url(profile: &serde_json::Value) -> Option<String> {
-    let value = profile
-        .get("properties")?
-        .as_array()?
-        .iter()
-        .find_map(|p| {
-            if p.get("name")?.as_str()? == "textures" {
-                p.get("value")?.as_str()
-            } else {
-                None
-            }
-        })?;
-    unpack(value, Signature::Unsigned, &TEXTURE_URIS).skin
+    let (value, signature) = parse_profile(profile).textures?;
+    unpack(&value, signature, &TEXTURE_URIS).skin
 }
-
 /// `profile_skin_url` on a block entity's `profile` NBT (`SkullBlockEntity`):
 /// the same `properties` list, held as a compound. A name-only profile (a
 /// string tag) has no properties and no skin URL.
@@ -164,13 +153,329 @@ pub fn profile_uuid_nbt(profile: &horizon_world::nbt::Tag) -> Option<u128> {
     }
 }
 
-fn nbt_text(tag: Option<&horizon_world::nbt::Tag>) -> Option<String> {
+pub(crate) fn nbt_text(tag: Option<&horizon_world::nbt::Tag>) -> Option<String> {
     match tag {
         Some(horizon_world::nbt::Tag::String(s)) => Some(s.to_string_lossy()),
         _ => None,
     }
 }
 
+/// `Either<String, UUID>`: the key a `Dynamic` `ResolvableProfile` resolves
+/// by (`ResolvableProfile.nameOrId`).
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum NameOrId {
+    Name(String),
+    Id(u128),
+}
+
+/// `GameProfile` as `fetchProfile` returns it: the account's id, name and
+/// property map (its `textures` property is the skin).
+#[derive(Clone, Debug)]
+pub struct ResolvedProfile {
+    pub id: u128,
+    pub name: String,
+    /// `(name, value, signature)` properties.
+    pub properties: Vec<(String, String, Option<String>)>,
+}
+impl ResolvedProfile {
+    /// `SessionService.getPackedTextures`: the `textures` property.
+    pub fn textures(&self) -> Option<(String, Signature)> {
+        self.properties
+            .iter()
+            .find(|(n, _, _)| n == "textures")
+            .map(|(_, v, s)| {
+                (
+                    v.clone(),
+                    if s.is_some() {
+                        Signature::Signed
+                    } else {
+                        Signature::Unsigned
+                    },
+                )
+            })
+    }
+}
+
+/// Where a `Dynamic` profile's resolution stands (`resolveProfile`'s future).
+#[derive(Clone, Debug)]
+pub enum Resolve {
+    Pending,
+    /// The services' answer: `None` for no profile or no answer, which the
+    /// cache holds like any result (`Optional.empty`).
+    Done(Option<ResolvedProfile>),
+}
+
+/// `ProfileResolver.Cached`: resolves a `Dynamic` profile through the
+/// services — `profileCacheByName` asks `profiles`/`getByName` for the id,
+/// `profileCacheById` asks `session`/`getProfileById` for the profile —
+/// at most 256 entries kept 10 minutes after their last use, fetched on
+/// background threads.
+pub struct Resolver {
+    entries: std::collections::HashMap<NameOrId, Entry>,
+    done: std::sync::mpsc::Receiver<(NameOrId, Option<ResolvedProfile>)>,
+    send: std::sync::mpsc::Sender<(NameOrId, Option<ResolvedProfile>)>,
+    last_sweep: std::time::Instant,
+}
+struct Entry {
+    touched: std::time::Instant,
+    /// `None` while the fetch is in flight.
+    resolved: Option<Option<ResolvedProfile>>,
+}
+/// `ProfileResolver.Cached`'s cache bounds.
+const MAX_PROFILES: usize = 256;
+const PROFILE_TTL: std::time::Duration = std::time::Duration::from_secs(10 * 60);
+
+/// `StringUtil.isValidPlayerName` (the check `fetchByName` makes first).
+fn valid_player_name(name: &str) -> bool {
+    name.encode_utf16().count() <= 16 && name.encode_utf16().all(|c| c > 32 && c < 127)
+}
+
+/// `fetchByNameOrId`: `getByName` answers `{id, name}`; `getProfileById`
+/// (`fetchProfile(id, requireSecure)`) answers `{id, name, properties}` —
+/// asked `unsigned=false` so the `textures` property is signed.
+fn resolve_profile(key: &NameOrId, doc: &serde_json::Value) -> Option<ResolvedProfile> {
+    let id = match key {
+        NameOrId::Id(id) => *id,
+        NameOrId::Name(name) => {
+            let url = crate::auth::endpoint(doc, "profiles", "getByName")?
+                .replace("{name}", &name.to_lowercase());
+            let body = http_get(&url)?;
+            let v: serde_json::Value = serde_json::from_slice(&body).ok()?;
+            crate::auth::parse_uuid(v.get("id")?.as_str()?)?
+        }
+    };
+    let url = crate::auth::endpoint(doc, "session", "getProfileById")?
+        .replace("{profileId}", &format!("{id:032x}"));
+    let separator = if url.contains('?') { '&' } else { '?' };
+    let body = http_get(&format!("{url}{separator}unsigned=false"))?;
+    let v: serde_json::Value = serde_json::from_slice(&body).ok()?;
+    Some(ResolvedProfile {
+        id: crate::auth::parse_uuid(v.get("id")?.as_str()?)?,
+        name: v.get("name")?.as_str()?.to_owned(),
+        properties: v
+            .get("properties")?
+            .as_array()?
+            .iter()
+            .map(|p| {
+                Some((
+                    p.get("name")?.as_str()?.to_owned(),
+                    p.get("value")?.as_str()?.to_owned(),
+                    p.get("signature")
+                        .and_then(|s| s.as_str())
+                        .map(str::to_owned),
+                ))
+            })
+            .collect::<Option<Vec<_>>>()?,
+    })
+}
+
+impl Default for Resolver {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl Resolver {
+    pub fn new() -> Self {
+        let (send, done) = std::sync::mpsc::channel();
+        Self {
+            entries: Default::default(),
+            done,
+            send,
+            last_sweep: std::time::Instant::now(),
+        }
+    }
+    /// `CacheBuilder.expireAfterAccess` with `maximumSize`.
+    fn sweep(&mut self) {
+        if self.last_sweep.elapsed() < std::time::Duration::from_secs(30) {
+            return;
+        }
+        self.last_sweep = std::time::Instant::now();
+        self.entries
+            .retain(|_, e| e.touched.elapsed() < PROFILE_TTL);
+        while self.entries.len() > MAX_PROFILES
+            && let Some(oldest) = self
+                .entries
+                .iter()
+                .min_by_key(|(_, e)| e.touched)
+                .map(|(k, _)| k.clone())
+        {
+            self.entries.remove(&oldest);
+        }
+    }
+    /// How the resolution of `key` stands, starting it the first time.
+    pub fn state(&mut self, key: &NameOrId) -> Resolve {
+        while let Ok((key, resolved)) = self.done.try_recv() {
+            self.entries.insert(
+                key,
+                Entry {
+                    touched: std::time::Instant::now(),
+                    resolved: Some(resolved),
+                },
+            );
+        }
+        self.sweep();
+        if let Some(entry) = self.entries.get_mut(key) {
+            entry.touched = std::time::Instant::now();
+            return match &entry.resolved {
+                Some(resolved) => Resolve::Done(resolved.clone()),
+                None => Resolve::Pending,
+            };
+        }
+        // `fetchByName` refuses an invalid name without a fetch; like every
+        // other empty answer that is the cached result.
+        let resolved = matches!(key, NameOrId::Name(name) if !valid_player_name(name));
+        self.entries.insert(
+            key.clone(),
+            Entry {
+                touched: std::time::Instant::now(),
+                resolved: resolved.then_some(None),
+            },
+        );
+        if resolved {
+            return Resolve::Done(None);
+        }
+        let (key, send) = (key.clone(), self.send.clone());
+        std::thread::spawn(move || {
+            let resolved = crate::auth::discovery()
+                .ok()
+                .and_then(|doc| resolve_profile(&key, &doc));
+            let _ = send.send((key, resolved));
+        });
+        Resolve::Pending
+    }
+}
+
+/// `ResolvableProfile` (an item's `minecraft:profile` component, a skull's
+/// `profile` tag): the `textures` property it carries, the key a `Dynamic`
+/// profile resolves by, and `partialProfile.id` — the fallback skin's key.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ProfileInfo {
+    /// `GameProfile.id` (`DefaultPlayerSkin.get`).
+    pub id: u128,
+    /// The `textures` property's value and signature state, when present.
+    pub textures: Option<(String, Signature)>,
+    /// `Dynamic` profiles resolve by name or id.
+    pub dynamic: Option<NameOrId>,
+}
+
+/// A profile's `id`: `UUIDUtil.CODEC` (an int array of four, or a UUID
+/// string).
+fn profile_id(v: &serde_json::Value) -> Option<u128> {
+    match v {
+        serde_json::Value::Array(a) => {
+            let ints: Option<Vec<i64>> = a.iter().map(|x| x.as_i64()).collect();
+            let i = ints?;
+            (i.len() == 4).then(|| {
+                ((i[0] as u32 as u128) << 96)
+                    | ((i[1] as u32 as u128) << 64)
+                    | ((i[2] as u32 as u128) << 32)
+                    | i[3] as u32 as u128
+            })
+        }
+        serde_json::Value::String(s) => crate::auth::parse_uuid(s),
+        _ => None,
+    }
+}
+
+/// `ResolvableProfile`'s read of a `profile` value: a bare name is
+/// `createUnresolved` (the `PLAYER_NAME` codec's alternative), a compound
+/// `name` + `id` + `properties` (`Partial.MAP_CODEC` or a `GameProfile`).
+pub fn parse_profile(v: &serde_json::Value) -> ProfileInfo {
+    if let serde_json::Value::String(name) = v {
+        return ProfileInfo {
+            id: horizon_protocol::crypto::offline_uuid(name),
+            textures: None,
+            dynamic: valid_player_name(name).then(|| NameOrId::Name(name.clone())),
+        };
+    }
+    let name = v.get("name").and_then(|n| n.as_str()).map(str::to_owned);
+    let id = v.get("id").and_then(profile_id);
+    let properties = v.get("properties").and_then(|p| p.as_array());
+    let textures = properties
+        .into_iter()
+        .flatten()
+        .find(|p| p.get("name").and_then(|n| n.as_str()) == Some("textures"))
+        .and_then(|p| {
+            Some((
+                p.get("value")?.as_str()?.to_owned(),
+                if p.get("signature").is_some() {
+                    Signature::Signed
+                } else {
+                    Signature::Unsigned
+                },
+            ))
+        });
+    // `ResolvableProfile.create`: a Partial is Dynamic with no properties
+    // and exactly one of a name or an id.
+    let dynamic =
+        (properties.is_none_or(|p| p.is_empty()) && name.is_some() != id.is_some()).then(|| {
+            name.as_deref().map_or_else(
+                || NameOrId::Id(id.unwrap()),
+                |n| NameOrId::Name(n.to_owned()),
+            )
+        });
+    ProfileInfo {
+        // `createPartialProfile`: the id, else the name's offline UUID, else nil.
+        id: id
+            .or_else(|| name.as_deref().map(horizon_protocol::crypto::offline_uuid))
+            .unwrap_or(0),
+        textures,
+        dynamic,
+    }
+}
+
+/// `ResolvableProfile.create`'s `Dynamic` key from a skull's `profile` tag:
+/// a bare name string is `createUnresolved`, and a compound without
+/// properties and with exactly one of a name or an id is `Dynamic`.
+pub fn dynamic_nbt(profile: &horizon_world::nbt::Tag) -> Option<NameOrId> {
+    if let horizon_world::nbt::Tag::String(s) = profile {
+        let name = s.to_string_lossy();
+        return valid_player_name(&name).then_some(NameOrId::Name(name));
+    }
+    if matches!(profile.get("properties"), Some(horizon_world::nbt::Tag::List(l)) if !l.is_empty())
+    {
+        return None;
+    }
+    match (nbt_text(profile.get("name")), profile_uuid_nbt(profile)) {
+        (Some(name), None) => Some(NameOrId::Name(name)),
+        (None, Some(id)) => Some(NameOrId::Id(id)),
+        _ => None,
+    }
+}
+
+/// `PlayerSkinRenderCache.getOrDefault` for a head: the resolved skin once
+/// its texture is in the atlas (`atlas`), else `partialProfile`'s default.
+pub fn head_skin(
+    profile: &serde_json::Value,
+    resolver: &mut Resolver,
+    downloads: &mut Downloader,
+    atlas: impl Fn(&str) -> bool,
+) -> String {
+    let p = parse_profile(profile);
+    let property = p.textures.or_else(|| {
+        let key = p.dynamic.as_ref()?;
+        match resolver.state(key) {
+            Resolve::Done(Some(profile)) => profile.textures(),
+            _ => None,
+        }
+    });
+    if let Some((value, signature)) = property
+        && let Some(url) = unpack(&value, signature, &TEXTURE_URIS).skin
+        && let Some(hash) = texture_hash(&url)
+    {
+        let location = skin_location(&hash);
+        match downloads.state(Kind::Skin, &url) {
+            Download::Ready if atlas(&location) => return location,
+            // Its slot was evicted: offer the image again.
+            Download::Ready => {
+                downloads.again(&location);
+            }
+            _ => {}
+        }
+    }
+    crate::tab_list::default_skin(p.id).to_owned()
+}
+
 /// `MinecraftProfileTexture.getHash`: the base name of the URL's path.
 pub fn texture_hash(url: &str) -> Option<String> {
     let rest = url.split_once("://")?.1;
@@ -313,7 +618,16 @@ pub struct Downloader {
     done: std::sync::mpsc::Receiver<((Kind, String), Option<Vec<u8>>)>,
     send: std::sync::mpsc::Sender<((Kind, String), Option<Vec<u8>>)>,
     ready: Vec<(String, Vec<u8>)>,
+    /// Locations already in `ready`, so `again` does not double-queue.
+    queued: std::collections::HashSet<String>,
+    /// Decoded skin images by location, kept so a skin evicted from the
+    /// atlas uploads again (`again`); the disk cache backs anything dropped.
+    images: std::collections::HashMap<String, Vec<u8>>,
+    image_order: std::collections::VecDeque<String>,
 }
+/// `images` is bounded only so a long session on a busy server does not grow
+/// without end; the disk cache holds everything it drops.
+const MAX_SKIN_IMAGES: usize = 1024;
 impl Downloader {
     pub fn new(root: std::path::PathBuf) -> Self {
         let (send, done) = std::sync::mpsc::channel();
@@ -323,6 +637,9 @@ impl Downloader {
             done,
             send,
             ready: Vec::new(),
+            queued: Default::default(),
+            images: Default::default(),
+            image_order: Default::default(),
         }
     }
     /// How the download of `url` stands, starting it the first time.
@@ -331,7 +648,9 @@ impl Downloader {
             let state = match image {
                 Some(rgba) => {
                     if key.0 == Kind::Skin {
-                        self.ready.push((skin_location(&key.1), rgba));
+                        let location = skin_location(&key.1);
+                        self.remember(location.clone(), rgba.clone());
+                        self.ready.push((location, rgba));
                     }
                     Download::Ready
                 }
@@ -370,8 +689,48 @@ impl Downloader {
         });
         Download::Pending
     }
+    /// Keeps a decoded skin for `again`, dropping the oldest past the bound.
+    fn remember(&mut self, location: String, rgba: Vec<u8>) {
+        if !self.images.contains_key(&location) {
+            self.image_order.push_back(location.clone());
+            while self.image_order.len() > MAX_SKIN_IMAGES
+                && let Some(old) = self.image_order.pop_front()
+            {
+                self.images.remove(&old);
+            }
+        }
+        self.images.insert(location, rgba);
+    }
+    /// A ready skin whose atlas slot was evicted (`show_skin` answered no):
+    /// its image for upload again, from memory or the disk cache.
+    pub fn again(&mut self, location: &str) -> bool {
+        if self.queued.contains(location) {
+            return true;
+        }
+        let Some(digest) = location.strip_prefix("skins/") else {
+            return false;
+        };
+        let image = self.images.get(location).cloned().or_else(|| {
+            let file = self
+                .root
+                .join(if digest.len() > 2 { &digest[..2] } else { "xx" })
+                .join(digest);
+            let (w, h, rgba) = crate::hud::decode_bytes(&std::fs::read(&file).ok()?).ok()?;
+            process_legacy_skin(w, h, &rgba)
+        });
+        let Some(image) = image else {
+            return false;
+        };
+        self.remember(location.to_owned(), image.clone());
+        self.queued.insert(location.to_owned());
+        self.ready.push((location.to_owned(), image));
+        true
+    }
     /// Skins that finished since the last call: texture id and 64x64 RGBA.
     pub fn take_ready(&mut self) -> Vec<(String, Vec<u8>)> {
+        for (location, _) in &self.ready {
+            self.queued.remove(location);
+        }
         std::mem::take(&mut self.ready)
     }
 }
@@ -452,6 +811,129 @@ pub fn sha1(data: &[u8]) -> [u8; 20] {
 
 #[cfg(test)]
 mod tests {
+    #[test]
+    fn profiles_parse_like_resolvable_profiles() {
+        use super::{NameOrId, Signature, parse_profile};
+        // A bare name is `createUnresolved`: dynamic by name, and its partial
+        // id is the name's offline UUID.
+        let p = parse_profile(&serde_json::json!("Notch"));
+        assert_eq!(p.dynamic, Some(NameOrId::Name("Notch".into())));
+        assert_eq!(p.id, horizon_protocol::crypto::offline_uuid("Notch"));
+        assert!(p.textures.is_none());
+        // A name-only compound resolves the same way.
+        let p = parse_profile(&serde_json::json!({"name": "Notch"}));
+        assert_eq!(p.dynamic, Some(NameOrId::Name("Notch".into())));
+        // An id-only compound resolves by id (int array or UUID string).
+        let id = 0x0123_4567_89ab_cdef_0123_4567_89ab_cdef_u128;
+        let ints: Vec<i64> = [
+            (id >> 96) as i32 as i64,
+            (id >> 64) as i32 as i64,
+            (id >> 32) as i32 as i64,
+            id as i32 as i64,
+        ]
+        .into();
+        let p = parse_profile(&serde_json::json!({"id": ints}));
+        assert_eq!(p.dynamic, Some(NameOrId::Id(id)));
+        let p = parse_profile(&serde_json::json!({"id": "01234567-89ab-cdef-0123-4567abcdef00"}));
+        assert_eq!(
+            p.dynamic,
+            Some(NameOrId::Id(0x0123_4567_89ab_cdef_0123_4567_abcd_ef00))
+        );
+        // Name and id but no properties is Static: it never resolves, and its
+        // default skin keys off the id.
+        let p = parse_profile(&serde_json::json!({"name": "Notch", "id": ints}));
+        assert!(p.dynamic.is_none());
+        assert_eq!(p.id, id);
+        // A `textures` property makes it Static (unsigned and signed).
+        let p = parse_profile(&serde_json::json!({
+            "properties": [{"name": "textures", "value": "v"}]
+        }));
+        assert!(p.dynamic.is_none());
+        assert_eq!(p.textures, Some(("v".into(), Signature::Unsigned)));
+        let p = parse_profile(&serde_json::json!({
+            "properties": [{"name": "textures", "value": "v", "signature": "s"}]
+        }));
+        assert_eq!(p.textures, Some(("v".into(), Signature::Signed)));
+        // Empty properties leave it dynamic.
+        let p = parse_profile(&serde_json::json!({"name": "Notch", "properties": []}));
+        assert_eq!(p.dynamic, Some(NameOrId::Name("Notch".into())));
+    }
+
+    /// `getByName` and `getProfileById` answer from the services the
+    /// discovery document names; a profile resolves through both.
+    #[test]
+    fn profiles_resolve_through_the_services() {
+        use std::io::{BufRead, BufReader, Write};
+        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+        let base = format!("http://{}", listener.local_addr().unwrap());
+        std::thread::spawn(move || {
+            let reply = |status: &str, body: &str| {
+                format!(
+                    "HTTP/1.1 {status}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+                    body.len()
+                )
+            };
+            for stream in listener.incoming().take(3) {
+                let mut stream = stream.unwrap();
+                let mut line = String::new();
+                let mut reader = BufReader::new(stream.try_clone().unwrap());
+                reader.read_line(&mut line).unwrap();
+                while reader.read_line(&mut String::new()).unwrap() > 2 {}
+                let body = if line.contains("/users/profiles/minecraft/") {
+                    r#"{"id":"069a79f444e94726a5befca90e38aaf5","name":"Notch"}"#
+                } else if line.contains("/session/minecraft/profile/")
+                    && line.contains("unsigned=false")
+                {
+                    r#"{"id":"069a79f444e94726a5befca90e38aaf5","name":"Notch","properties":[{"name":"textures","value":"dmFsdWU=","signature":"c2ln"}]}"#
+                } else {
+                    "{}"
+                };
+                stream.write_all(reply("200 OK", body).as_bytes()).unwrap();
+            }
+        });
+        let doc = serde_json::json!({"discovery": {
+            "profiles": {"endpoints": {"getByName": {"uri": format!("{base}/users/profiles/minecraft/{{name}}")}}},
+            "session": {"endpoints": {"getProfileById": {"uri": format!("{base}/session/minecraft/profile/{{profileId}}")}}},
+        }});
+        let resolved =
+            super::resolve_profile(&super::NameOrId::Name("Notch".into()), &doc).unwrap();
+        assert_eq!(resolved.id, 0x069a_79f4_44e9_4726_a5be_fca9_0e38_aaf5);
+        assert_eq!(resolved.name, "Notch");
+        assert_eq!(
+            resolved.properties,
+            vec![(
+                "textures".to_owned(),
+                "dmFsdWU=".to_owned(),
+                Some("c2ln".to_owned())
+            )]
+        );
+        let by_id = super::resolve_profile(&super::NameOrId::Id(resolved.id), &doc).unwrap();
+        assert_eq!(by_id.name, "Notch");
+        // A discovery without `profiles`/`getByName` resolves no name.
+        let doc = serde_json::json!({"discovery": {
+            "session": {"endpoints": {"getProfileById": {"uri": format!("{base}/session/minecraft/profile/{{profileId}}")}}},
+        }});
+        assert!(super::resolve_profile(&super::NameOrId::Name("Notch".into()), &doc).is_none());
+    }
+
+    /// A skin evicted from the atlas re-uploads (`again`), once per ask.
+    #[test]
+    fn evicted_skins_upload_again() {
+        let mut d = super::Downloader::new(std::env::temp_dir().join("horizon-test-skins"));
+        d.remember("skins/abc".into(), vec![1, 2, 3]);
+        assert!(d.again("skins/abc"));
+        assert!(!d.again("skins/missing"));
+        // Once queued, more asks do not pile up uploads.
+        assert!(d.again("skins/abc"));
+        assert_eq!(
+            d.take_ready(),
+            vec![("skins/abc".to_owned(), vec![1, 2, 3])]
+        );
+        assert!(d.take_ready().is_empty());
+        assert!(d.again("skins/abc"));
+        assert_eq!(d.take_ready().len(), 1);
+    }
+
     #[test]
     fn profile_components_supply_unsigned_head_skins() {
         let value = "eyJ0ZXh0dXJlcyI6IHsiU0tJTiI6IHsidXJsIjogImh0dHBzOi8vdGV4dHVyZXMubWluZWNyYWZ0Lm5ldC90ZXh0dXJlL2FiYzEyMyJ9fX0=";

From 0300ad8922780e964b1bab11488aed8b6bdb77f1 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:13:33 +0100
Subject: [PATCH 162/475] Keep the current attack target regardless of
 invisibility

---
 crates/horizon-client/src/mobs/goals.rs       | 27 +++++++++++++++----
 .../horizon-client/src/mobs/monster_brain.rs  |  3 +++
 2 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs
index c44614571..2341c11d4 100644
--- a/crates/horizon-client/src/mobs/goals.rs
+++ b/crates/horizon-client/src/mobs/goals.rs
@@ -588,21 +588,38 @@ impl Mob {
         if p.creative || p.allies.contains(&self.id) {
             return false;
         }
-        self.player_in_range(w, range, check_sight)
+        self.player_in_range(w, range, check_sight, true)
+    }
+    /// forCombat().ignoreInvisibilityTesting() for the player: the check for
+    /// a target the mob already has, which ignores the visibility scaling.
+    pub fn can_keep_target_player(&mut self, w: &MobWorld, range: f64) -> bool {
+        let Some(p) = &w.player else { return false };
+        if p.creative || p.allies.contains(&self.id) {
+            return false;
+        }
+        self.player_in_range(w, range, true, false)
     }
     /// TargetingConditions.forNonCombat().range(range).test for the player
     /// (seen by anyone, within range scaled by visibility, in sight).
     pub fn can_see_player(&mut self, w: &MobWorld, range: f64) -> bool {
-        self.player_in_range(w, range, true)
+        self.player_in_range(w, range, true, true)
     }
-    fn player_in_range(&mut self, w: &MobWorld, range: f64, check_sight: bool) -> bool {
+    /// `scale` is `TargetingConditions.testInvisible`: scale the range by
+    /// the player's visibility.
+    fn player_in_range(
+        &mut self,
+        w: &MobWorld,
+        range: f64,
+        check_sight: bool,
+        scale: bool,
+    ) -> bool {
         let Some(p) = &w.player else { return false };
         if !p.alive || p.spectator {
             return false;
         }
         // LivingEntity.getVisibilityPercent
-        let mut visibility = p.visibility_percent();
-        if let Some(head) = &p.head {
+        let mut visibility = if scale { p.visibility_percent() } else { 1.0 };
+        if let Some(head) = p.head.as_ref().filter(|_| scale) {
             let skull = match self.species() {
                 Species::Zombie | Species::Husk | Species::Drowned | Species::ZombieVillager => {
                     "minecraft:zombie_head"
diff --git a/crates/horizon-client/src/mobs/monster_brain.rs b/crates/horizon-client/src/mobs/monster_brain.rs
index 9456c00a1..4990913eb 100644
--- a/crates/horizon-client/src/mobs/monster_brain.rs
+++ b/crates/horizon-client/src/mobs/monster_brain.rs
@@ -359,11 +359,14 @@ fn can_attack(m: &Mob, w: &MobWorld, who: Who) -> bool {
 /// `Sensor.isEntityAttackable`: `TargetingConditions.forCombat()` within the
 /// follow range, in sight.
 fn attackable(m: &mut Mob, w: &MobWorld, who: Who) -> bool {
+    // The current ATTACK_TARGET is tested with ignoreInvisibilityTesting.
+    let current = mem_ref(m).attack_target.value() == Some(who);
     let range = m.attrs.follow_range;
     if !can_attack(m, w, who) {
         return false;
     }
     match who {
+        Who::Player if current => m.can_keep_target_player(w, range),
         Who::Player => m.can_target_player(w, range, true),
         Who::Mob(id) => {
             let Some(s) = w.seen(id) else { return false };

From 004ad993d9e77d8262094afea01b2351b1bf3403 Mon Sep 17 00:00:00 2001
From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com>
Date: Mon, 26 Oct 2026 17:16:15 +0000
Subject: [PATCH 163/475] Reject boarding a horse with an existing mob
 passenger

Fixes #1759

Co-Authored-By: OpenAI Codex GPT-6.1 Sol <noreply@openai.com>
---
 crates/horizon-client/src/game/mounts.rs | 11 ++++++
 tools/lan_e2e.py                         | 47 +++++++++++++++++++++++-
 2 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/mounts.rs b/crates/horizon-client/src/game/mounts.rs
index fa4bbc209..7da98135f 100644
--- a/crates/horizon-client/src/game/mounts.rs
+++ b/crates/horizon-client/src/game/mounts.rs
@@ -175,6 +175,17 @@ impl Game<'_> {
             return true;
         }
         // doPlayerRide
+        // Entity.canAddPassenger: ordinary horses have one seat. Camels
+        // override that capacity; equipment and feeding above are separate.
+        if !matches!(species, Species::Camel | Species::CamelHusk)
+            && self.mobs.iter().any(|passenger| {
+                passenger.extra.mount == Some(self.mobs[index].id)
+                    && !passenger.removed
+                    && passenger.alive()
+            })
+        {
+            return false;
+        }
         let m = &mut self.mobs[index];
         m.extra.flag = false;
         m.extra.counter = 0;
diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index c508a67d6..f179a201c 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -299,7 +299,7 @@ CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'si
           'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles',
           'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects',
           'portals', 'distance', 'growth', 'doors', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'hands',
-          'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption',
+          'lightning', 'riding', 'occupied_horse', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption',
           'breath', 'lava', 'levels', 'drops', 'underwater', 'fireworks']
 
 
@@ -4199,6 +4199,49 @@ def check_riding(host, guest, out):
     return result
 
 
+def check_occupied_horse(host, guest, out):
+    """#1759: a mob passenger fills a zombie horse's seat, for both real players."""
+    spots = apart(host, guest)
+    result = {}
+    tag = 'occupied_horse'
+    host('command', command='time set midnight')
+    for label, player in (('host', host), ('guest', guest)):
+        x, y, z = spots[label]
+        at = (x + 0.5, y, z + 2.5)
+        player('command', command='gamemode creative')
+        player('command', command='clear @s')
+        result[label] = {}
+        for occupied in (True, False):
+            passengers = ',Passengers:[{id:"minecraft:zombie",NoAI:1b,PersistenceRequired:1b}]' if occupied else ''
+            try:
+                player('command', command=f'summon minecraft:zombie_horse {at[0]} {y} {at[2]} '
+                                         f'{{Tame:1b,NoAI:1b,NoGravity:1b,Tags:["{tag}"]{passengers}}}')
+                player.wait(5)
+                horse = next(m for m in player.raw('mobs', 16)['near']
+                             if m['kind'] == 'minecraft:zombie_horse' and m['health'] > 0
+                             and math.dist(m['pos'], at) < 0.1)
+                if occupied:
+                    # Assert the setup too: a missing passenger would make this a false positive.
+                    passengers_nbt = player('command', command=f'data get entity @e[tag={tag},limit=1] Passengers')
+                    assert 'minecraft:zombie' in json.dumps(passengers_nbt), passengers_nbt
+                player.raw('look-at', at[0], y + 0.8, at[2])
+                player.raw('mouse', 'right', 'click')
+                player.wait(10)
+                riding = player('status').get('riding')
+                expected = None if occupied else horse['id']
+                assert riding == expected, f'{label}: occupied={occupied}, riding={riding}, expected={expected}'
+                result[label]['occupied' if occupied else 'free'] = riding
+                player.shot(out, f'occupied-horse-{label}-{occupied}')
+                if not occupied:
+                    hold(player, 'shift', 5)
+            finally:
+                player('command', command=f'kill @e[tag={tag}]')
+                player('command', command=f'kill @e[type=minecraft:zombie,x={x},y={y},z={z},distance=..6]')
+                player('command', command=f'tp @s {x + 0.5} {y} {z + 0.5} 0 0')
+                player.wait(25)
+    return result
+
+
 # Mount inventories: (kind, summon NBT, what goes in by shift-click and the menu slot it lands
 # in: 700 the saddle, 701 the body armour or carpet, 710 the chest's first slot).
 MOUNT_MENUS = [
@@ -4688,7 +4731,7 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour,
              'barter': check_barter, 'worn': check_worn, 'kills': check_kills,
              'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder,
              'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'hands': check_hands,
-             'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts,
+             'lightning': check_lightning, 'riding': check_riding, 'occupied_horse': check_occupied_horse, 'mounts': check_mounts,
              'worldspawn': check_world_spawn, 'beds': check_beds, 'shield': check_shield, 'deathmining': check_death_mining,
              'contacts': check_contacts, 'absorption': check_absorption, 'breath': check_breath,
              'lava': check_lava, 'levels': check_levels, 'drops': check_drops,

From a6d2eb9d6421d1bbf54c4fb366438a70682946de Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:17:27 +0100
Subject: [PATCH 164/475] Shulkers keep their body still while the head turns

---
 crates/horizon-client/src/mobs/control.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/crates/horizon-client/src/mobs/control.rs b/crates/horizon-client/src/mobs/control.rs
index 3df557362..70a40b23f 100644
--- a/crates/horizon-client/src/mobs/control.rs
+++ b/crates/horizon-client/src/mobs/control.rs
@@ -389,6 +389,13 @@ impl Mob {
     }
     /// BodyRotationControl.clientTick (Mob.tickHeadTurn).
     pub fn body_rotation_tick(&mut self) {
+        // Shulker.ShulkerBodyRotationControl.clientTick is empty: the body
+        // stays at 0 (recreateFromPacket), only the head turns.
+        if self.species() == super::Species::Shulker {
+            self.body_yaw = 0.0;
+            self.previous_body_yaw = 0.0;
+            return;
+        }
         let dx = self.position.x - self.previous.x;
         let dz = self.position.z - self.previous.z;
         let max = self.kind.max_head_y_rot;

From 442d52a038aa50a715e5517d59f3a1d78ec075e6 Mon Sep 17 00:00:00 2001
From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com>
Date: Mon, 26 Oct 2026 17:19:04 +0000
Subject: [PATCH 165/475] Release notes: preserve wrapped known issues

Co-Authored-By: OpenCode agentrouter/gpt-6.1-sol <noreply@opencode.ai>
---
 tests/test_release_train.py | 28 ++++++++++++++++++++++++++--
 tools/release_train.py      | 12 +++++++++++-
 2 files changed, 37 insertions(+), 3 deletions(-)

diff --git a/tests/test_release_train.py b/tests/test_release_train.py
index 56064fa42..58fc591b1 100644
--- a/tests/test_release_train.py
+++ b/tests/test_release_train.py
@@ -219,10 +219,34 @@ class ReleaseTrainTests(unittest.TestCase):
     def test_known_issues_are_the_bullets_of_the_file(self):
         with tempfile.TemporaryDirectory() as temp:
             path = Path(temp, "known-issues.md")
-            path.write_text("# Known issues\n\nSome text.\n\n- One.\n- Two, with **bold**.\n  continued\n")
-            self.assertEqual(train.known_issues(path), ["- One.", "- Two, with **bold**."])
+            path.write_text("# Known issues\n\nSome text.\n\n- One.\n- Two, with **bold**.  \n"
+                            "  continued with `code`\n\tand a [link](https://example.com).  \n- Three.\n")
+            self.assertEqual(train.known_issues(path),
+                             ["- One.", "- Two, with **bold**. continued with `code` and a [link](https://example.com).",
+                              "- Three."])
             self.assertEqual(train.known_issues(Path(temp, "missing.md")), [])
 
+    def test_known_issues_do_not_include_unrelated_text(self):
+        with tempfile.TemporaryDirectory() as temp:
+            path = Path(temp, "known-issues.md")
+            for separator in ["\n", "  \n", "# Heading\n", "Some text.\n"]:
+                with self.subTest(separator=separator):
+                    path.write_text("  Intro.\n- One.\n  continued.\n" + separator + "  Not an issue.\n- Two.\n")
+                    self.assertEqual(train.known_issues(path), ["- One. continued.", "- Two."])
+            path.write_text("# Known issues\n\nNo issues.\n")
+            self.assertEqual(train.known_issues(path), [])
+            path.write_text("")
+            self.assertEqual(train.known_issues(path), [])
+
+    def test_notes_keep_the_wrapped_shaderpacks_issue(self):
+        with tempfile.TemporaryDirectory() as temp:
+            path = Path(temp, "known-issues.md")
+            path.write_text("- Shader packs have been removed for now. Packs in your\n"
+                            "  `shaderpacks` folder are left where they are.\n")
+            _, body = train.notes("game", "v0.2.70", [pr(1)], train.known_issues(path))
+            self.assertIn("### Known issues\n- Shader packs have been removed for now. Packs in your "
+                          "`shaderpacks` folder are left where they are.\n", body)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tools/release_train.py b/tools/release_train.py
index 48d4d46cf..1e4fa5a19 100644
--- a/tools/release_train.py
+++ b/tools/release_train.py
@@ -347,7 +347,17 @@ def bullet(pr):
 def known_issues(path=ROOT / "docs" / "known-issues.md"):
     if not path.exists():
         return []
-    return [line.rstrip() for line in path.read_text().splitlines() if line.startswith("- ")]
+    issues = []
+    in_bullet = False
+    for line in path.read_text().splitlines():
+        if line.startswith("- "):
+            issues.append(line.rstrip())
+            in_bullet = True
+        elif in_bullet and line.startswith((" ", "\t")) and line.strip():
+            issues[-1] += " " + line.strip()
+        else:
+            in_bullet = False
+    return issues
 
 
 def line_intro(kind, version, previous):

From f661443fa993eb4d26649cb6b7c9c67d76cd683e Mon Sep 17 00:00:00 2001
From: rdbtCVS <87152661+rdbtCVS@users.noreply.github.com>
Date: Mon, 26 Oct 2026 17:22:50 +0000
Subject: [PATCH 166/475] Read LAN passenger fixture output through the host

Co-Authored-By: OpenAI Codex GPT-6.1 Sol <noreply@openai.com>
---
 tools/lan_e2e.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index f179a201c..f16e6312b 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -4222,7 +4222,7 @@ def check_occupied_horse(host, guest, out):
                              and math.dist(m['pos'], at) < 0.1)
                 if occupied:
                     # Assert the setup too: a missing passenger would make this a false positive.
-                    passengers_nbt = player('command', command=f'data get entity @e[tag={tag},limit=1] Passengers')
+                    passengers_nbt = host('command', command=f'data get entity @e[tag={tag},limit=1] Passengers')
                     assert 'minecraft:zombie' in json.dumps(passengers_nbt), passengers_nbt
                 player.raw('look-at', at[0], y + 0.8, at[2])
                 player.raw('mouse', 'right', 'click')

From 5589edb118c0a9152c2dabb2ff22bfaf5aae5b3c Mon Sep 17 00:00:00 2001
From: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Mon, 26 Oct 2026 18:26:50 +0100
Subject: [PATCH 167/475] Server packs: swallow gameplay input while the reload
 progress shows

The progress overlay only changed drawing: a pack pushed while playing
left movement, attack and use live behind it. Input events are now
dropped while the staged reload runs (as vanilla's LoadingOverlay does),
and start_pack_reload releases held keys and mouse buttons up front so
nothing keeps acting across the frame it covers.

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 crates/horizon-client/src/game.rs              | 13 +++++++++++++
 crates/horizon-client/src/game/server_packs.rs |  7 +++++++
 2 files changed, 20 insertions(+)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index abaa639eb..e5ab50256 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -11314,6 +11314,19 @@ impl ApplicationHandler for Game<'_> {
         {
             return;
         }
+        // The pack reload's progress overlay takes no input
+        // (`LoadingOverlay`): `start_pack_reload` released what was held.
+        if self.server_packs.reload.is_some()
+            && !matches!(
+                &event,
+                WindowEvent::CloseRequested
+                    | WindowEvent::Focused(_)
+                    | WindowEvent::Resized(_)
+                    | WindowEvent::RedrawRequested
+            )
+        {
+            return;
+        }
         if self.pending_save.is_some() {
             match event {
                 WindowEvent::CloseRequested => {
diff --git a/crates/horizon-client/src/game/server_packs.rs b/crates/horizon-client/src/game/server_packs.rs
index 12b73f4f9..d0769b894 100644
--- a/crates/horizon-client/src/game/server_packs.rs
+++ b/crates/horizon-client/src/game/server_packs.rs
@@ -407,6 +407,13 @@ impl Game<'_> {
             return;
         };
         self.server_packs.active = server.clone();
+        // The overlay swallows input until the apply (`LoadingOverlay`):
+        // release what is held so nothing keeps acting while it covers the
+        // frame (`KeyMapping.releaseAll` when a screen opens).
+        self.keys.clear();
+        self.physical_keys.clear();
+        self.left = false;
+        self.right = false;
         let vanilla = self.vanilla_root();
         if self.ui.vanilla_root.as_os_str().is_empty() {
             self.ui.vanilla_root = vanilla.clone();

From db13c68585d2f491e0329f6897279176bf18d8ec Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 18:28:26 +0100
Subject: [PATCH 168/475] mods: recipes.place and recipes.give, a recipe
 viewer's actions

recipes.place(book-id, all) is the recipe book's click: in the open
inventory's or crafting table's grid it sends ServerboundPlaceRecipePacket
on a server, or places it in this world, refused as handlePlaceRecipe
refuses it (no crafting screen, a recipe the player's book doesn't hold, an
impossible one); a recipe missing items shows as a ghost. recipes.give(stack)
gives a creative player the stack as the creative inventory does; a server
hears it as SetCreativeModeSlot through the inventory's sync. Both answer at
once from the tick's snapshot (placing, creative, known) and take at most 36
calls a hook call.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/cargo-horizon-mod/src/check.rs         |  4 ++
 crates/horizon-client/src/game/mod_recipes.rs | 18 ++++++
 crates/horizon-client/src/game/mods.rs        | 14 ++++
 crates/horizon-client/src/game/recipe_book.rs | 28 ++++++++
 crates/horizon-mod-sdk/wit/horizon.wit        | 11 ++++
 crates/horizon-mods/src/api_level.rs          |  4 +-
 crates/horizon-mods/src/manifest.rs           |  4 +-
 crates/horizon-mods/src/runtime.rs            | 63 ++++++++++++++++++
 crates/horizon-mods/tests/sandbox.rs          | 43 ++++++++++++-
 crates/horizon-mods/tests/ui_guest/src/lib.rs | 64 +++++++++++++++++--
 docs/api/mods-reference.md                    |  4 +-
 docs/api/stability.md                         |  2 +-
 docs/mods.md                                  |  2 +-
 13 files changed, 251 insertions(+), 10 deletions(-)

diff --git a/crates/cargo-horizon-mod/src/check.rs b/crates/cargo-horizon-mod/src/check.rs
index 33095a115..cb3981955 100644
--- a/crates/cargo-horizon-mod/src/check.rs
+++ b/crates/cargo-horizon-mod/src/check.rs
@@ -268,6 +268,10 @@ fn play(path: &Path, report: &mut Report) -> Result<(), String> {
             Output::Stopped { reason, .. } => return Err(format!("it stopped: {reason}")),
             Output::OpenScreen { .. } => "opened a screen".to_string(),
             Output::CloseScreen { .. } => "closed its screen".to_string(),
+            Output::PlaceRecipe { book_id, all } => {
+                format!("placed recipe {book_id}{}", if all { " (all)" } else { "" })
+            }
+            Output::Give { item, count, .. } => format!("gave {count} {item}"),
             Output::Shake { strength, seconds } => {
                 format!("shook the camera: {strength:.2} for {seconds:.1} s")
             }
diff --git a/crates/horizon-client/src/game/mod_recipes.rs b/crates/horizon-client/src/game/mod_recipes.rs
index f02eb6424..0f65b0b42 100644
--- a/crates/horizon-client/src/game/mod_recipes.rs
+++ b/crates/horizon-client/src/game/mod_recipes.rs
@@ -70,6 +70,24 @@ fn recipe(id: String, kind: RecipeKind) -> Recipe {
 }
 
 impl Game<'_> {
+    /// `recipes.give`: a creative player takes the stack as from the
+    /// creative inventory; a server hears it as `SetCreativeModeSlot`
+    /// through the inventory's sync, and refuses it unless creative.
+    pub(super) fn mod_give(&mut self, item: &str, count: u32, components: &str) {
+        if !self.creative || self.res.items().get(item).is_none() {
+            return;
+        }
+        let (damage, extra) = horizon_client::item_data::command_components(components)
+            .map_or((0, None), |tag| {
+                horizon_client::item_data::decode_components(Some(&tag))
+            });
+        let _ = self.give(ItemStack {
+            item: item.into(),
+            count,
+            damage,
+            extra,
+        });
+    }
     /// Capability `recipes`'s tables and known displays for this tick's
     /// snapshot; nothing while no running mod reads them.
     pub(super) fn mod_recipes(&mut self) -> (Option<Arc<Recipes>>, Arc<[i32]>) {
diff --git a/crates/horizon-client/src/game/mods.rs b/crates/horizon-client/src/game/mods.rs
index 40298a922..147a01df3 100644
--- a/crates/horizon-client/src/game/mods.rs
+++ b/crates/horizon-client/src/game/mods.rs
@@ -434,6 +434,8 @@ impl Game<'_> {
             view_hit: self.mod_view_hit(),
             recipes,
             known_recipes,
+            placing: self.mod_recipe_screen(),
+            creative: self.creative,
         }
     }
     /// The first block along the player's view within
@@ -646,6 +648,18 @@ impl Game<'_> {
                     self.mods.shake.add(strength, seconds);
                     continue;
                 }
+                Output::PlaceRecipe { book_id, all } => {
+                    self.mod_place_recipe(book_id, all);
+                    continue;
+                }
+                Output::Give {
+                    item,
+                    count,
+                    components,
+                } => {
+                    self.mod_give(&item, count, &components);
+                    continue;
+                }
                 Output::CloseScreen { owner } => {
                     if self.mods.screen.as_ref().is_some_and(|s| s.owner == owner) {
                         self.close_mod_screen(false);
diff --git a/crates/horizon-client/src/game/recipe_book.rs b/crates/horizon-client/src/game/recipe_book.rs
index 045abeb6f..024d45734 100644
--- a/crates/horizon-client/src/game/recipe_book.rs
+++ b/crates/horizon-client/src/game/recipe_book.rs
@@ -845,6 +845,34 @@ impl Game<'_> {
         self.recipe_ui.ghost.clear();
         self.place_recipe(book_type, entry_index, use_max);
     }
+    /// Whether the open screen takes `recipes.place`: a crafting grid's
+    /// book (the inventory's or a crafting table's).
+    #[cfg(feature = "mods")]
+    pub(super) fn mod_recipe_screen(&self) -> bool {
+        self.screen == Screen::Inventory
+            && self.active_book() == Some(BookType::Crafting)
+            && !self.spectator()
+    }
+    /// `recipes.place`: the book's click on the recipe with this display
+    /// id, refused as `handlePlaceRecipe` refuses it (no crafting screen,
+    /// not in the player's book; an impossible one in `place_recipe`).
+    #[cfg(feature = "mods")]
+    pub(super) fn mod_place_recipe(&mut self, display_id: i32, all: bool) {
+        if !self.mod_recipe_screen() || !self.recipe_ui.client.displays().contains(&display_id) {
+            return;
+        }
+        self.ensure_book();
+        let Some(index) = self
+            .recipe_ui
+            .book
+            .as_ref()
+            .and_then(|b| b.entries.iter().position(|e| e.display_id == display_id))
+        else {
+            return;
+        };
+        self.recipe_ui.ghost.clear();
+        self.place_recipe(BookType::Crafting, index, all);
+    }
     /// `ServerboundPlaceRecipePacket`: the server places the recipe
     /// (`ServerPlaceRecipe` on the menu engine) and answers with a ghost
     /// recipe when the items are missing.
diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit
index 4896c3e21..897f669e5 100644
--- a/crates/horizon-mod-sdk/wit/horizon.wit
+++ b/crates/horizon-mod-sdk/wit/horizon.wit
@@ -507,6 +507,17 @@ interface recipes {
     all: func() -> list<recipe>;
     /// The `book-id`s of the recipes the player's recipe book holds now.
     known: func() -> list<s32>;
+    /// Places a recipe in the open screen's grid as a click in the recipe
+    /// book does (`ServerboundPlaceRecipePacket`): the inventory's grid or
+    /// a crafting table. `all` places as many as the items allow, as with
+    /// Shift. Refused while no such screen is open, for a recipe the
+    /// player's book doesn't hold and for one that can't be placed; one
+    /// missing items shows as a ghost in the grid, as in the book.
+    place: func(book-id: s32, all: bool) -> result<_, string>;
+    /// Creative mode only: gives the player the stack, as taking it from
+    /// the creative inventory does (`ServerboundSetCreativeModeSlot`): the
+    /// selected slot first, then the hotbar, then the inventory.
+    give: func(stack: stack) -> result<_, string>;
 }
 
 /// Capability `ui` (experimental): a recipe viewer's panel beside the
diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs
index 7bb87b674..87984da02 100644
--- a/crates/horizon-mods/src/api_level.rs
+++ b/crates/horizon-mods/src/api_level.rs
@@ -13,7 +13,7 @@ pub const LEVEL: u32 = 5;
 /// level. Level 0 is the contract of Horizon 0.2.67 to 0.2.69. A new
 /// function takes the next level and raises [`LEVEL`] (the `api_reference`
 /// test fails until it is listed here).
-pub const FUNCTIONS: [(&str, u32); 40] = [
+pub const FUNCTIONS: [(&str, u32); 42] = [
     ("log.write", 0),
     ("game.get-player", 0),
     ("game.get-clock", 0),
@@ -51,6 +51,8 @@ pub const FUNCTIONS: [(&str, u32); 40] = [
     ("recipes.items", 4),
     ("recipes.all", 4),
     ("recipes.known", 4),
+    ("recipes.place", 5),
+    ("recipes.give", 5),
     ("browser.set-items", 5),
     ("browser.poll", 5),
     ("browser.set-recipes", 5),
diff --git a/crates/horizon-mods/src/manifest.rs b/crates/horizon-mods/src/manifest.rs
index 4c12fd805..6b2cfdf03 100644
--- a/crates/horizon-mods/src/manifest.rs
+++ b/crates/horizon-mods/src/manifest.rs
@@ -158,7 +158,9 @@ impl Capability {
                 "see the keys you hold and your clicks, take over the use button on its own items and the mouse wheel, and add keys"
             }
             Capability::Players => "see who is on the server and message them",
-            Capability::Recipes => "read the game's recipes and items, and which recipes you know",
+            Capability::Recipes => {
+                "read the game's recipes and items and which recipes you know, place recipes in your crafting grid and, in creative mode, give you items"
+            }
         }
     }
     /// The capability a component import needs, `Ok(None)` for one every
diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs
index 43c9e3fac..fed4e5c4f 100644
--- a/crates/horizon-mods/src/runtime.rs
+++ b/crates/horizon-mods/src/runtime.rs
@@ -156,6 +156,10 @@ pub struct Snapshot {
     pub recipes: Option<Arc<Recipes>>,
     /// The `book-id`s of the recipes the player's book holds.
     pub known_recipes: Arc<[i32]>,
+    /// The open screen takes recipes (`recipes.place`).
+    pub placing: bool,
+    /// The player is in creative mode (`recipes.give`).
+    pub creative: bool,
 }
 
 /// Capability `recipes`'s tables: `items` in the registry's order, which
@@ -220,6 +224,15 @@ pub enum Output {
     CloseScreen { owner: usize },
     /// `render.shake`: strength 0 to 1, fading out over `seconds` (≤ 10).
     Shake { strength: f32, seconds: f32 },
+    /// `recipes.place`: the recipe book's click on this display id, all of
+    /// it when `all`.
+    PlaceRecipe { book_id: i32, all: bool },
+    /// `recipes.give`: a stack for a creative player.
+    Give {
+        item: String,
+        count: u32,
+        components: String,
+    },
 }
 
 /// A mod's text panel, drawn every frame until it changes.
@@ -329,6 +342,8 @@ struct BrowserState {
 static BROWSER_VERSION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
 /// Items a panel may hold, and events kept for `browser.poll`.
 const BROWSER_ITEMS: usize = 8192;
+/// `recipes.place` and `give` calls a hook call may make.
+const RECIPE_ACTIONS: usize = 36;
 /// Recipes `set-recipes` may show, slots in one, and stacks a slot cycles.
 const BROWSER_RECIPES: usize = 256;
 const RECIPE_SLOTS: usize = 9;
@@ -1307,6 +1322,54 @@ impl recipes::Host for State {
     fn known(&mut self) -> Vec<i32> {
         self.snapshot.known_recipes.to_vec()
     }
+    fn place(&mut self, book_id: i32, all: bool) -> Result<(), String> {
+        self.recipe_action()?;
+        if !self.snapshot.placing {
+            return Err("no screen that takes recipes is open".into());
+        }
+        if !self.snapshot.known_recipes.contains(&book_id) {
+            return Err(format!(
+                "recipe {book_id} is not in the player's recipe book"
+            ));
+        }
+        self.out.push(Output::PlaceRecipe { book_id, all });
+        Ok(())
+    }
+    fn give(&mut self, stack: RecipeStack) -> Result<(), String> {
+        self.recipe_action()?;
+        if !self.snapshot.creative {
+            return Err("only in creative mode".into());
+        }
+        let item = self
+            .snapshot
+            .recipes
+            .as_ref()
+            .and_then(|r| r.items.get(stack.item as usize))
+            .ok_or_else(|| format!("no item {}", stack.item))?
+            .id
+            .clone();
+        self.out.push(Output::Give {
+            item,
+            count: stack.count.clamp(1, 99),
+            components: clip_to(stack.components, 4096),
+        });
+        Ok(())
+    }
+}
+impl State {
+    /// `recipes.place` and `give` take at most [`RECIPE_ACTIONS`] a call.
+    fn recipe_action(&self) -> Result<(), String> {
+        let done = self
+            .out
+            .iter()
+            .filter(|o| matches!(o, Output::PlaceRecipe { .. } | Output::Give { .. }))
+            .count();
+        if done < RECIPE_ACTIONS {
+            Ok(())
+        } else {
+            Err(format!("at most {RECIPE_ACTIONS} places and gives a call"))
+        }
+    }
 }
 impl State {
     /// Queues a chat line unless the call already sent [`CHAT_PER_CALL`].
diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs
index 081884dc2..ea8cc0536 100644
--- a/crates/horizon-mods/tests/sandbox.rs
+++ b/crates/horizon-mods/tests/sandbox.rs
@@ -1059,8 +1059,9 @@ fn recipes_reads_the_tables() {
     recipes[1].kind = RecipeKind::Brewing;
     recipes[1].results[0].components =
         "[minecraft:potion_contents={potion:\"minecraft:swiftness\"}]".into();
+    let mods_recipes = Some(std::sync::Arc::new(Recipes { items, recipes }));
     mods.set_snapshot(Snapshot {
-        recipes: Some(std::sync::Arc::new(Recipes { items, recipes })),
+        recipes: mods_recipes.clone(),
         known_recipes: vec![1, 5, 9].into(),
         ..Snapshot::default()
     });
@@ -1091,6 +1092,46 @@ fn recipes_reads_the_tables() {
             .all(|e| e.status == horizon_mods::Status::Running),
         "it ran out of fuel"
     );
+    // Actions: refused without a crafting screen, for an unknown recipe,
+    // and outside creative mode.
+    assert_eq!(
+        said(&mut mods, "recipe_place minecraft:recipe_5"),
+        ["place minecraft:recipe_5: no screen that takes recipes is open"]
+    );
+    let mut snap = Snapshot {
+        recipes: mods_recipes.clone(),
+        known_recipes: vec![1, 5, 9].into(),
+        placing: true,
+        ..Snapshot::default()
+    };
+    mods.set_snapshot(snap.clone());
+    assert_eq!(
+        said(&mut mods, "recipe_place minecraft:recipe_6"),
+        ["place minecraft:recipe_6: recipe 6 is not in the player's recipe book"]
+    );
+    assert!(mods.command("recipe_place minecraft:recipe_5 all"));
+    assert_eq!(
+        mods.drain()[0],
+        Output::PlaceRecipe {
+            book_id: 5,
+            all: true
+        }
+    );
+    assert_eq!(
+        said(&mut mods, "recipe_give minecraft:item_7 3"),
+        ["give minecraft:item_7: only in creative mode"]
+    );
+    snap.creative = true;
+    mods.set_snapshot(snap);
+    assert!(mods.command("recipe_give minecraft:item_7 3"));
+    assert_eq!(
+        mods.drain()[0],
+        Output::Give {
+            item: "minecraft:item_7".into(),
+            count: 3,
+            components: String::new()
+        }
+    );
     // Without the game's tables (no mod read them yet): empty, not a trap.
     mods.set_snapshot(Snapshot::default());
     assert_eq!(
diff --git a/crates/horizon-mods/tests/ui_guest/src/lib.rs b/crates/horizon-mods/tests/ui_guest/src/lib.rs
index 751169565..2b1646614 100644
--- a/crates/horizon-mods/tests/ui_guest/src/lib.rs
+++ b/crates/horizon-mods/tests/ui_guest/src/lib.rs
@@ -12,7 +12,9 @@
 //! items, `/browser` alone empties it) and registers the keys `recipe` (R)
 //! and `uses` (U); `/browser_poll` says what the player did on it;
 //! `/browser_recipes ID` shows the recipes making ID (`/browser_recipes`
-//! alone: the items again).
+//! alone: the items again). `/recipe_place ID [all]` places that recipe
+//! with `recipes.place`; `/recipe_give ITEM [COUNT]` gives with
+//! `recipes.give`.
 use horizon_mod_sdk::{
     Mod, Registration, browser, chat, command, game,
     input::{self, Event},
@@ -69,7 +71,11 @@ fn shapes() -> Vec<Shape> {
     ]
 }
 
-struct Guest;
+struct Guest {
+    /// `/recipe_place ID [all] later`: placed on the first tick a crafting
+    /// screen is open.
+    pending: Option<(i32, bool, String)>,
+}
 
 fn widgets() -> Vec<Widget> {
     vec![
@@ -113,12 +119,15 @@ impl Mod for Guest {
             "browser",
             "browser_poll",
             "browser_recipes",
+            "recipe_place",
+            "recipe_give",
             "corner",
             "readings",
         ]
         .into_iter()
-        .fold(Registration::new(), Registration::command);
-        Ok((Guest, hooks))
+        .fold(Registration::new(), Registration::command)
+        .on_tick();
+        Ok((Guest { pending: None }, hooks))
     }
     fn command(&mut self, name: &str, args: &str) -> Result<Option<String>, String> {
         match name {
@@ -367,6 +376,44 @@ impl Mod for Guest {
                 browser::set_recipes(&format!("Recipes for {args}"), &views);
                 chat::show(&format!("recipes shown: {}", views.len()));
             }
+            "recipe_place" => {
+                let mut words = args.split_whitespace();
+                let id = words.next().unwrap_or_default();
+                let rest: Vec<&str> = words.collect();
+                let all = rest.contains(&"all");
+                let book = recipes::all()
+                    .iter()
+                    .find(|r| r.id == id)
+                    .map(|r| r.book_id);
+                if let Some(b) = book.filter(|_| rest.contains(&"later")) {
+                    self.pending = Some((b, all, id.to_owned()));
+                    chat::show(&format!("place {id}: waiting"));
+                    return Ok(None);
+                }
+                chat::show(&match book.map(|b| recipes::place(b, all)) {
+                    Some(Ok(())) => format!("place {id}: ok"),
+                    Some(Err(e)) => format!("place {id}: {e}"),
+                    None => format!("place {id}: no such recipe"),
+                });
+            }
+            "recipe_give" => {
+                let mut words = args.split_whitespace();
+                let id = words.next().unwrap_or_default();
+                let count = words.next().and_then(|c| c.parse().ok()).unwrap_or(1);
+                let item = recipes::items().iter().position(|i| i.id == id);
+                let result = item.map(|i| {
+                    recipes::give(&recipes::Stack {
+                        item: i as u32,
+                        count,
+                        components: String::new(),
+                    })
+                });
+                chat::show(&match result {
+                    Some(Ok(())) => format!("give {id}: ok"),
+                    Some(Err(e)) => format!("give {id}: {e}"),
+                    None => format!("give {id}: no such item"),
+                });
+            }
             "browser_poll" => {
                 let stack = |s: &browser::Stack| format!("{} x{}{}", s.item, s.count, s.components);
                 // A hook shows at most 8 chat lines: the count, then the first 7.
@@ -402,6 +449,15 @@ impl Mod for Guest {
         }
         Ok(None)
     }
+    fn tick(&mut self, _tick: u64) {
+        if let Some((book, all, id)) = self.pending.take() {
+            match recipes::place(book, all) {
+                Err(e) if e.starts_with("no screen") => self.pending = Some((book, all, id)),
+                Ok(()) => chat::show(&format!("place {id}: ok")),
+                Err(e) => chat::show(&format!("place {id}: {e}")),
+            }
+        }
+    }
     fn ui_select(&mut self, id: u32, row: u32) {
         chat::show(&format!("selected {id}:{row}"));
     }
diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md
index 6af12fa5b..b79ea5247 100644
--- a/docs/api/mods-reference.md
+++ b/docs/api/mods-reference.md
@@ -17,7 +17,7 @@ The contract between Horizon and its mods: the WIT package `horizon:mods@0.1.0`,
 | `render` | [`render`](#render) | draw on your screen, shake and zoom the camera |
 | `input` | [`input`](#input) | see the keys you hold and your clicks, take over the use button on its own items and the mouse wheel, and add keys |
 | `players` | [`players`](#players) | see who is on the server and message them |
-| `recipes` | [`recipes`](#recipes) | read the game's recipes and items, and which recipes you know |
+| `recipes` | [`recipes`](#recipes) | read the game's recipes and items and which recipes you know, place recipes in your crafting grid and, in creative mode, give you items |
 
 ## World `horizon-mod`
 
@@ -530,6 +530,8 @@ The station a recipe is made at.
 | `items` | `func() -> list<item>` | Every item, in the registry's order: `stack.item` indexes this list. |
 | `all` | `func() -> list<recipe>` | Every recipe: the book's in its order, then campfire, stonecutting, smithing and brewing. They don't change while a world is open. |
 | `known` | `func() -> list<s32>` | The `book-id`s of the recipes the player's recipe book holds now. |
+| `place` | `func(book-id: s32, all: bool) -> result<_, string>` | Places a recipe in the open screen's grid as a click in the recipe book does (`ServerboundPlaceRecipePacket`): the inventory's grid or a crafting table. `all` places as many as the items allow, as with Shift. Refused while no such screen is open, for a recipe the player's book doesn't hold and for one that can't be placed; one missing items shows as a ghost in the grid, as in the book. |
+| `give` | `func(stack: stack) -> result<_, string>` | Creative mode only: gives the player the stack, as taking it from the creative inventory does (`ServerboundSetCreativeModeSlot`): the selected slot first, then the hotbar, then the inventory. |
 
 ## `browser`
 
diff --git a/docs/api/stability.md b/docs/api/stability.md
index 1314d9813..616767689 100644
--- a/docs/api/stability.md
+++ b/docs/api/stability.md
@@ -38,7 +38,7 @@ don't import it); faster, or fixing behaviour to what the reference already says
 
 A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every
 function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`):
-level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`, level 3 `command.run-quiet`, level 4 `recipes` (`items`, `all`, `known`), level 5 `browser` (`set-items`, `poll`, `set-recipes`). A mod needs the level of
+level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`, level 3 `command.run-quiet`, level 4 `recipes` (`items`, `all`, `known`), level 5 `browser` (`set-items`, `poll`, `set-recipes`) and `recipes.place` and `recipes.give`. A mod needs the level of
 the newest function it imports (a component imports only the functions it calls). The level is read from the file,
 never declared:
 
diff --git a/docs/mods.md b/docs/mods.md
index bbd14dc84..706e48bd6 100644
--- a/docs/mods.md
+++ b/docs/mods.md
@@ -91,7 +91,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3.
 | `ui` | `ui` | `open-screen`, `close-screen`, `set-settings`: a screen the mod owns and a page in Options > Mods, of text, button, item and list widgets the game lays out and draws with its own menus' code; `browser.set-items`, `browser.poll`: a recipe viewer's panel of items right of the inventory and container screens (not the creative one), which the game pages and draws with its own slots and search box, and the mod hears its clicks, its searches and the mod's own keys (`input.register-key`) pressed over any item on the screen; `browser.set-recipes`: recipes in the panel's place (crafting grids, cooking, stonecutting, smithing and brewing layouts, their slots cycling through their stacks, a note and an action button each), paged by the game, with clicks on their slots, action buttons, page turns and a back button. **Experimental:** the manifest needs `experimental = ["ui"]` |
 | `render` | `render` | `set-hud(shapes)`: up to 1024 fills, four-cornered shapes, GUI sprites, items and text, kept on the HUD (over the hotbar, under chat and screens, hidden with F1) until replaced; `set-corner(corner, w, h, shapes)`: a box the game places in a corner, stacked with its overlays and other panels, as `hud`'s panels are; `text-width(text)`; `frame-stats()`: the game's FPS, min and 1% low; `gui-size()`; `shake(strength, seconds)`: the view turns, the player doesn't, scaled by Distortion Effects; `set-zoom(zoom)`: the field of view divided by up to 10, eased or at once, with slower turning, while playing and not through a spyglass (the strongest of several mods' zooms counts); `set-minimap(minimap)`: a map of the world around the player in a corner, as a map item colours it (the floor underground and under roofs), square or round, turning with the player or north up, with the player's arrow; the game keeps its tiles within its own frame budget (one map at a time, the first loaded mod's). The game's own HUD renderer draws them: a mod never supplies shader code. **Experimental:** `experimental = ["render"]` |
 | `input` | `input` | `claim-items(ids)`: the use button on those items is the mod's (`use-start`, `use-stop` with the ticks held; the game doesn't place, eat or swing); `register-key(name, label, key)`: up to 16 keys (`key.keyboard.r`), heard while playing as `key-down` / `key-up` (the game's own mapping on that key still runs; a screen opening lets held keys up), mouse buttons as `key.mouse.4`. The player rebinds them on the mod's page in Options > Mods, where the game lists them first as Key Binds rows (click, then press a key or mouse button; Esc binds none), even for a mod without `ui`; the choice is kept in `horizon-mods.txt` (`key.<mod>.<name>:key.keyboard.z`) and wins over `register-key`'s default; `claim-wheel(on)`: the wheel's steps become `wheel` events and the hotbar doesn't move (the one input a mod takes from the game; a mod's keys never do); `held()`; `mapping(name)`: a movement or click mapping's key label and whether it is held; `clicks-per-second()`; `poll()` returns the events, at most 256 kept. **Experimental:** `experimental = ["input"]` |
-| `recipes` | `recipes` | `items()`: every item in the registry's order, with its name in the player's language and its tags; `all()`: every recipe (crafting, smelting, blasting, smoking, campfire, stonecutting, smithing, brewing), its slots as the stacks that fit each, its results, cooking time and experience, and the recipe book's id for it; `known()`: the book ids the player's recipe book holds. The recipes are the world's in single player and on Horizon's servers, vanilla 26.3's on any other server (a client is sent no others), while `known` follows that server's book. The game makes the tables once, when a mod first reads them. **Experimental:** `experimental = ["recipes"]` |
+| `recipes` | `recipes` | `items()`: every item in the registry's order, with its name in the player's language and its tags; `all()`: every recipe (crafting, smelting, blasting, smoking, campfire, stonecutting, smithing, brewing), its slots as the stacks that fit each, its results, cooking time and experience, and the recipe book's id for it; `known()`: the book ids the player's recipe book holds; `place(book-id, all)`: the recipe book's click on a recipe, in the open inventory's or crafting table's grid (refused for a recipe the player's book doesn't hold, as vanilla's server refuses it); `give(stack)`: in creative mode, the stack into the player's inventory, as from the creative inventory. The recipes are the world's in single player and on Horizon's servers, vanilla 26.3's on any other server (a client is sent no others), while `known` follows that server's book. The game makes the tables once, when a mod first reads them. **Experimental:** `experimental = ["recipes"]` |
 
 | Hook (export) | When |
 |---|---|

From 077da2e06b16bcfded6224765b838c3177b45d38 Mon Sep 17 00:00:00 2001
From: socksprox <info@shadowfly.net>
Date: Mon, 26 Oct 2026 18:30:09 +0100
Subject: [PATCH 169/475] Queue the first skin upload as well as re-uploads
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The completed-download push into ready never marked the location queued,
so an again() before the next take_ready() put the same skin in twice:
store_skin allocated two slots, and evicting one removed the sprite while
show_skin still found the other entry — the skin never uploaded again.

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 crates/horizon-client/src/skins.rs | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/skins.rs b/crates/horizon-client/src/skins.rs
index 239e1c3ac..740208973 100644
--- a/crates/horizon-client/src/skins.rs
+++ b/crates/horizon-client/src/skins.rs
@@ -649,8 +649,7 @@ impl Downloader {
                 Some(rgba) => {
                     if key.0 == Kind::Skin {
                         let location = skin_location(&key.1);
-                        self.remember(location.clone(), rgba.clone());
-                        self.ready.push((location, rgba));
+                        self.queue(location, rgba);
                     }
                     Download::Ready
                 }
@@ -701,6 +700,13 @@ impl Downloader {
         }
         self.images.insert(location, rgba);
     }
+    /// An image off to the atlas: remembered for `again` and marked queued
+    /// so nothing uploads the same location twice.
+    fn queue(&mut self, location: String, rgba: Vec<u8>) {
+        self.remember(location.clone(), rgba.clone());
+        self.queued.insert(location.clone());
+        self.ready.push((location, rgba));
+    }
     /// A ready skin whose atlas slot was evicted (`show_skin` answered no):
     /// its image for upload again, from memory or the disk cache.
     pub fn again(&mut self, location: &str) -> bool {
@@ -721,9 +727,7 @@ impl Downloader {
         let Some(image) = image else {
             return false;
         };
-        self.remember(location.to_owned(), image.clone());
-        self.queued.insert(location.to_owned());
-        self.ready.push((location.to_owned(), image));
+        self.queue(location.to_owned(), image);
         true
     }
     /// Skins that finished since the last call: texture id and 64x64 RGBA.
@@ -932,6 +936,11 @@ mod tests {
         assert!(d.take_ready().is_empty());
         assert!(d.again("skins/abc"));
         assert_eq!(d.take_ready().len(), 1);
+        // The first upload marks the location queued too: an `again` before
+        // `take_ready` does not put the same skin in the atlas twice.
+        d.queue("skins/def".into(), vec![4]);
+        assert!(d.again("skins/def"));
+        assert_eq!(d.take_ready(), vec![("skins/def".to_owned(), vec![4])]);
     }
 
     #[test]

From 2c8b933be483bcf6d44437fb0763facfee707095 Mon Sep 17 00:00:00 2001
From: socksprox <info@shadowfly.net>
Date: Mon, 26 Oct 2026 18:30:53 +0100
Subject: [PATCH 170/475] Apply vanilla's view scale to entity render distance

Entity.shouldRenderAtSqrDistance scales the bounding box's mean edge
by 64 * viewScale, and LevelExtractor sets viewScale to the entity
distance option times clamp(renderDistance / 8, 1, 2.5). Horizon used
the option alone, so above render distance 8 entities vanished sooner
than vanilla: a chicken at 32 blocks instead of 48 at the default 12.
RemotePlayer's box also counts ten times.

Fixes #2273

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 crates/horizon-client/src/game/boats.rs          |  2 +-
 crates/horizon-client/src/game/creatures.rs      | 13 ++++++++++---
 crates/horizon-client/src/game/cushions.rs       |  3 +--
 crates/horizon-client/src/game/entity_culling.rs | 16 +++++++++++++---
 crates/horizon-client/src/game/frames.rs         |  5 +++--
 crates/horizon-client/src/game/minecarts.rs      |  5 ++---
 crates/horizon-client/src/game/paintings.rs      |  3 +--
 crates/horizon-client/src/game/text_displays.rs  |  3 ++-
 crates/horizon-client/src/game/tnt.rs            |  2 +-
 crates/horizon-client/src/game/trident.rs        |  2 +-
 10 files changed, 35 insertions(+), 19 deletions(-)

diff --git a/crates/horizon-client/src/game/boats.rs b/crates/horizon-client/src/game/boats.rs
index 06dfab22d..7e80f6f58 100644
--- a/crates/horizon-client/src/game/boats.rs
+++ b/crates/horizon-client/src/game/boats.rs
@@ -862,7 +862,7 @@ impl Game<'_> {
         let a = alpha as f32;
         let range = super::entity_culling::default_range(
             glam::DVec3::new(WIDTH, HEIGHT, WIDTH),
-            self.settings.entity_distance,
+            self.view_scale(),
         );
         for b in &self.boats {
             let entity_start = out.len();
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index a2ed7fd66..f8c28732a 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -3032,7 +3032,7 @@ impl Game<'_> {
     pub(super) fn mob_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec<Vertex>) {
         let atlas = &self.gui.atlas;
         let lookup = |name: &str| atlas.sprites.get(name).map(|r| [r.u0, r.v0, r.u1, r.v1]);
-        let scale = f64::from(self.settings.entity_distance);
+        let scale = self.view_scale();
         for mob in &self.mobs {
             let entity_start = out.len();
             // Entity.DATA_SHARED_FLAGS_ID invisible: only the name tag draws.
@@ -3041,9 +3041,16 @@ impl Game<'_> {
             }
             let d = glam::DVec3::new(mob.position.x, mob.position.y, mob.position.z) - camera;
             // Entity.shouldRenderAtSqrDistance: 64 times the bounding box's
-            // mean edge, scaled by the entity distance option.
+            // mean edge, scaled by the view scale. RemotePlayer's box counts
+            // ten times.
             let (w, h, _) = mob.dims();
-            let range = (w + h + w) / 3.0 * 64.0 * scale;
+            let edge = (w + h + w) / 3.0
+                * if &*mob.kind.id == "minecraft:player" {
+                    10.0
+                } else {
+                    1.0
+                };
+            let range = edge * 64.0 * scale;
             if d.length_squared() >= range * range {
                 continue;
             }
diff --git a/crates/horizon-client/src/game/cushions.rs b/crates/horizon-client/src/game/cushions.rs
index 0847321d6..216e2cc1b 100644
--- a/crates/horizon-client/src/game/cushions.rs
+++ b/crates/horizon-client/src/game/cushions.rs
@@ -455,8 +455,7 @@ impl Game<'_> {
                 glam::DVec3::new(lo.x, lo.y, lo.z),
                 glam::DVec3::new(hi.x, hi.y, hi.z),
             );
-            let range =
-                super::entity_culling::default_range(hi - lo, self.settings.entity_distance);
+            let range = super::entity_culling::default_range(hi - lo, self.view_scale());
             if !self.entity_in_view(camera, (lo + hi) / 2.0, range, lo, hi) {
                 continue;
             }
diff --git a/crates/horizon-client/src/game/entity_culling.rs b/crates/horizon-client/src/game/entity_culling.rs
index 66fbaa3e4..4377b2f8d 100644
--- a/crates/horizon-client/src/game/entity_culling.rs
+++ b/crates/horizon-client/src/game/entity_culling.rs
@@ -60,12 +60,22 @@ impl Game<'_> {
     }
 }
 
+impl Game<'_> {
+    /// Entity.setViewScale (LevelExtractor.extractVisibleEntities): the entity
+    /// distance option times the render distance's boost — 1 at 8 chunks, 2.5
+    /// at 20 or more (`streaming.radius` is the effective render distance).
+    pub(super) fn view_scale(&self) -> f64 {
+        (f64::from(self.streaming.radius) / 8.0).clamp(1.0, 2.5)
+            * f64::from(self.settings.entity_distance)
+    }
+}
+
 /// Entity.shouldRenderAtSqrDistance's default range: 64 times the bounding
-/// box's mean edge, scaled by the entity distance option.
-pub(super) fn default_range(size: glam::DVec3, view_scale: f32) -> f64 {
+/// box's mean edge, scaled by the view scale.
+pub(super) fn default_range(size: glam::DVec3, view_scale: f64) -> f64 {
     let edge = (size.x + size.y + size.z) / 3.0;
     let edge = if edge.is_nan() { 1.0 } else { edge };
-    edge * 64.0 * f64::from(view_scale)
+    edge * 64.0 * view_scale
 }
 
 impl Game<'_> {
diff --git a/crates/horizon-client/src/game/frames.rs b/crates/horizon-client/src/game/frames.rs
index d08c5f283..b4e6bb158 100644
--- a/crates/horizon-client/src/game/frames.rs
+++ b/crates/horizon-client/src/game/frames.rs
@@ -311,8 +311,9 @@ impl Game<'_> {
         let sprites = &self.gui.atlas.sprites;
         let mut maps: Vec<(i32, glam::Mat4, u32)> = Vec::new();
         let mut items: Vec<(ItemStack, u32, glam::Mat4, u8)> = Vec::new();
-        // ItemFrame.shouldRenderAtSqrDistance: 1024 blocks at 100%.
-        let range = 16.0 * 64.0 * f64::from(self.settings.entity_distance);
+        // ItemFrame.shouldRenderAtSqrDistance: 1024 blocks at a view scale
+        // of 1.
+        let range = 16.0 * 64.0 * self.view_scale();
         for f in &self.item_frames {
             let entity_start = out.len();
             let map = f.item.as_ref().and_then(super::maps::map_id);
diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index 072059e49..781dd6b7c 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -1340,9 +1340,8 @@ impl Game<'_> {
             return;
         };
         // Entity.shouldRenderAtSqrDistance: 64 times the bounding box's mean
-        // edge, scaled by the entity distance option.
-        let range =
-            (WIDTH + HEIGHT + WIDTH) / 3.0 * 64.0 * f64::from(self.settings.entity_distance);
+        // edge, scaled by the view scale.
+        let range = (WIDTH + HEIGHT + WIDTH) / 3.0 * 64.0 * self.view_scale();
         for c in &self.carts {
             let entity_start = out.len();
             let Some(model) = self.cart_models.models.get(&c.kind) else {
diff --git a/crates/horizon-client/src/game/paintings.rs b/crates/horizon-client/src/game/paintings.rs
index 321e59f7d..1b839f5b0 100644
--- a/crates/horizon-client/src/game/paintings.rs
+++ b/crates/horizon-client/src/game/paintings.rs
@@ -267,8 +267,7 @@ impl Game<'_> {
             // measured from the box's centre (HangingEntity's position).
             let (lo, hi) = p.bounds();
             let (lo, hi) = (glam::DVec3::from(lo), glam::DVec3::from(hi));
-            let range =
-                super::entity_culling::default_range(hi - lo, self.settings.entity_distance);
+            let range = super::entity_culling::default_range(hi - lo, self.view_scale());
             if !self.entity_in_view(camera, (lo + hi) / 2.0, range, lo, hi) {
                 continue;
             }
diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs
index 45bd64fa7..587db3382 100644
--- a/crates/horizon-client/src/game/text_displays.rs
+++ b/crates/horizon-client/src/game/text_displays.rs
@@ -164,11 +164,12 @@ impl Game<'_> {
         } else {
             [self.yaw, self.pitch]
         };
+        let scale = self.view_scale();
         for display in self.text_displays.values_mut() {
             display.last_progress = display.progress(partial as f32);
             let d = display.shown.blend(&display.from, display.last_progress);
             let position = display.previous.lerp(display.position, partial);
-            let range = f64::from(d.view_range) * 64.0 * f64::from(self.settings.entity_distance);
+            let range = f64::from(d.view_range) * 64.0 * scale;
             if position.distance_squared(camera) >= range * range || d.text.is_empty() {
                 continue;
             }
diff --git a/crates/horizon-client/src/game/tnt.rs b/crates/horizon-client/src/game/tnt.rs
index 6bd2ae956..177e3bf80 100644
--- a/crates/horizon-client/src/game/tnt.rs
+++ b/crates/horizon-client/src/game/tnt.rs
@@ -252,7 +252,7 @@ impl Game<'_> {
         }
         let range = super::entity_culling::default_range(
             glam::DVec3::splat(PrimedTnt::SIZE),
-            self.settings.entity_distance,
+            self.view_scale(),
         );
         for t in &self.tnts {
             // EntityRenderer.shouldRender.
diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs
index c31094596..cfb8d807c 100644
--- a/crates/horizon-client/src/game/trident.rs
+++ b/crates/horizon-client/src/game/trident.rs
@@ -419,7 +419,7 @@ impl Game<'_> {
         let range = 10.0
             * super::entity_culling::default_range(
                 glam::DVec3::splat(2.0 * HALF),
-                self.settings.entity_distance,
+                self.view_scale(),
             );
         for t in &self.tridents {
             // EntityRenderer.shouldRender; ThrownTridentRenderer grows the box by 1.5.

From 1825b3991cae222b6aac29951b5542abfb7c7f8a Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 18:30:56 +0100
Subject: [PATCH 171/475] Campfires are no Container for droppers and hoppers

Since campfires got their block entity (#2015), the container lookup took
it for a zero-slot container: a dropper facing one kept its item instead of
dropping it, as vanilla's HopperBlockEntity.getContainerAt finds no Container
there. The dispense fixture also filled campfires through the generic slots,
which a campfire doesn't have, so block_removal saw them empty.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/dispense_fixture.rs | 5 +++++
 crates/horizon-client/src/game/machines.rs         | 6 ++++--
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/dispense_fixture.rs b/crates/horizon-client/src/game/dispense_fixture.rs
index 267f323c3..43f41d201 100644
--- a/crates/horizon-client/src/game/dispense_fixture.rs
+++ b/crates/horizon-client/src/game/dispense_fixture.rs
@@ -725,6 +725,11 @@ impl Game<'_> {
         match self.world.block_entities.get_mut(&p) {
             Some(BlockEntity::Jukebox(j)) => j.record = stack,
             Some(BlockEntity::Lectern(l)) => l.book = stack,
+            Some(BlockEntity::Campfire(c)) => {
+                if let Some(cell) = c.items.get_mut(slot) {
+                    *cell = stack;
+                }
+            }
             Some(e) => {
                 if let Some(cell) = e.slots_mut().get_mut(slot) {
                     *cell = stack;
diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs
index 8742962e9..bb936744b 100644
--- a/crates/horizon-client/src/game/machines.rs
+++ b/crates/horizon-client/src/game/machines.rs
@@ -159,8 +159,10 @@ impl Containers<'_> {
             });
         }
         let entity = self.world.block_entities.get(&pos)?;
-        // A beehive keeps bees, not items: it is no `Container`.
-        if matches!(entity, BlockEntity::Beehive(_)) {
+        // A beehive keeps bees, not items, and a campfire cooks its own: neither
+        // is a `Container` (HopperBlockEntity.getContainerAt), so a dropper drops
+        // in front of them and a hopper leaves them alone.
+        if matches!(entity, BlockEntity::Beehive(_) | BlockEntity::Campfire(_)) {
             return None;
         }
         let kind = match (entity, name) {

From 1862395e4b72d7ed7d5e6ee1769727ac38964031 Mon Sep 17 00:00:00 2001
From: Carlos Nunez <carlosnunez01010@gmail.com>
Date: Mon, 26 Oct 2026 13:32:44 -0400
Subject: [PATCH 172/475] Keep a leaving guest's play state until their
 statistics are saved

lan_crafting_left removed the guest's GuestPlay from host.play before
the leave_game award and save_guest_records ran, so a normal guest
disconnect awarded nothing and wrote no statistics. It now takes the
crafting table and workstation state out of the entry and leaves the
entry for HostEvent::Left to remove after saving.

New lan_e2e check `leave`: a guest leaves twice and the host's saved
statistics show leave_game 1, then 2. It fails on the previous commit
(0, then [0, 0]) and passes here.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .../horizon-client/src/game/lan_crafting.rs   | 10 +++---
 tools/lan_e2e.py                              | 35 +++++++++++++++++--
 2 files changed, 38 insertions(+), 7 deletions(-)

diff --git a/crates/horizon-client/src/game/lan_crafting.rs b/crates/horizon-client/src/game/lan_crafting.rs
index db6235c4d..839390529 100644
--- a/crates/horizon-client/src/game/lan_crafting.rs
+++ b/crates/horizon-client/src/game/lan_crafting.rs
@@ -576,16 +576,18 @@ impl Game<'_> {
     /// A guest left: what their crafting grids and workstation held goes back into their
     /// inventory before it is saved (dropped where they stood if full).
     pub(super) fn lan_crafting_left(&mut self, host: &mut LanHost, g: &mut Guest) {
-        let play = host.play.remove(&g.conn);
+        // The guest's play state stays: their statistics are awarded and saved
+        // after this (`HostEvent::Left`), which removes it.
+        let play = host.play.get_mut(&g.conn);
         let mut grid: Vec<ItemStack> = g.craft_grid.iter_mut().filter_map(Option::take).collect();
         g.craft_result = None;
         if let Some(play) = play {
-            if let Some((_, _, menu, _)) = play.crafting.table {
+            if let Some((_, _, menu, _)) = play.crafting.table.take() {
                 grid.extend((1..10).filter_map(|s| menu.slot(s).cloned()));
             }
             // A workstation's inputs too.
-            if let Some(station) = &play.station {
-                grid.extend(super::lan_stations::station_inputs(station));
+            if let Some(station) = play.station.take() {
+                grid.extend(super::lan_stations::station_inputs(&station));
             }
         }
         if grid.is_empty() {
diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index 866602c9b..2c8885b81 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -22,7 +22,7 @@ address. The script then checks, from both sides, what a guest's game used to ge
 - pvp:       the guest and the host hit each other with a sword; with the pvp game rule off, or on one
              team without friendly fire, nothing;
 - kills:     a pig the guest kills counts in the guest's killed statistic, not the host's (#484);
-
+- leave:     a guest who leaves has leave_game in their saved statistics, and again after the next leave;
 
 - arrows:    the guest and the host shoot each other with a bow; with the pvp game rule off, nothing (#484);
 - looks:     mobs look on both sides as the server has them (their synched data): a calf is a
@@ -290,7 +290,7 @@ ROOT = Path(__file__).resolve().parents[1]
 GUEST_NAME = 'Guest'
 # Match normal single player; --in-frame is the comparison path.
 SERVER_THREAD = True
-CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'doors', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'hands', 'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater']
+CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'leave', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles', 'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing', 'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth', 'doors', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'hands', 'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption', 'breath', 'lava', 'levels', 'drops', 'underwater']
 
 
 class Game:
@@ -1134,6 +1134,35 @@ def check_pvp(host, guest, out):
     return hits
 
 
+def leave_game_total(host):
+    """The leave_game statistic summed over the stats files the host's world holds."""
+    total = 0
+    for path in (host.work / 'saves' / 'Lan' / 'players' / 'stats').glob('*.json'):
+        custom = json.loads(path.read_text()).get('stats', {}).get('minecraft:custom', {})
+        total += custom.get('minecraft:leave_game', 0)
+    return total
+
+
+def check_leave(host, guest, out):
+    # PlayerList.remove awards Stats.LEAVE_GAME before it saves the player: a guest who leaves has it in
+    # their saved statistics, and it counts again the next time they leave.
+    port = host.raw('lan', 'status')['port']
+    before = leave_game_total(host)
+    counts = []
+    for _ in range(2):
+        guest.raw('disconnect')
+        for _ in range(20):
+            time.sleep(0.5)
+            if leave_game_total(host) > (counts[-1] if counts else before):
+                break
+        counts.append(leave_game_total(host))
+        guest.raw('connect', f'127.0.0.1:{port}', GUEST_NAME)
+        guest.raw('wait-for', 'loaded', '--timeout', 300)
+        guest.wait(20)
+    assert counts == [before + 1, before + 2], f'leave_game was {before}, then {counts} after two leaves'
+    return {'leave_game': counts}
+
+
 def check_kills(host, guest, out):
     # A mob the guest kills is the guest's kill (#484): LivingEntity.die credits lastHurtByPlayer, so the
     # killed statistic (and its scoreboard criterion) counts for the guest, not the host.
@@ -4616,7 +4645,7 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour,
              'light': check_light, 'plates': check_plates, 'swings': check_swings,
              'cracks': check_cracks, 'time': check_time, 'growth': check_growth, 'doors': check_doors,
              'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect,
-             'barter': check_barter, 'worn': check_worn, 'kills': check_kills,
+             'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'leave': check_leave,
              'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder,
              'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'hands': check_hands,
              'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts,

From 6a62ad67cce8fd23254f285ef6ba7881809216c7 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 18:39:46 +0100
Subject: [PATCH 173/475] mods: set-recipes takes a row of tabs, and the tab
 event says which one the player picked

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-mod-sdk/wit/horizon.wit        | 10 +++--
 crates/horizon-mods/src/runtime.rs            | 37 ++++++++++++++-----
 crates/horizon-mods/tests/sandbox.rs          | 10 +++--
 crates/horizon-mods/tests/ui_guest/src/lib.rs | 21 ++++++++++-
 docs/api/mods-reference.md                    |  3 +-
 5 files changed, 64 insertions(+), 17 deletions(-)

diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit
index 4896c3e21..5f8677df0 100644
--- a/crates/horizon-mod-sdk/wit/horizon.wit
+++ b/crates/horizon-mod-sdk/wit/horizon.wit
@@ -557,6 +557,8 @@ interface browser {
         page(u32),
         /// The back button of `set-recipes`.
         back,
+        /// The player picked the tab at this index of `set-recipes`' tabs.
+        tab(u32),
     }
     /// How the game lays out a recipe of `set-recipes`.
     enum layout {
@@ -590,9 +592,11 @@ interface browser {
     /// The panel's items, at most 8192 (an empty list hides the panel).
     set-items: func(items: list<stack>);
     /// Shows these recipes in the panel instead of its items, as many as
-    /// fit a page, under `title` and a back button; an empty list shows the
-    /// items again. At most 256 recipes.
-    set-recipes: func(title: string, recipes: list<recipe-view>);
+    /// fit a page, under `title` and a back button, with a row of `tabs`
+    /// (each an icon; `tab` is the selected one) between them; an empty
+    /// list of recipes shows the items again. At most 256 recipes and 16
+    /// tabs.
+    set-recipes: func(title: string, tabs: list<stack>, tab: u32, recipes: list<recipe-view>);
     /// What the player did on the panel since the last poll, at most 256
     /// kept.
     poll: func() -> list<event>;
diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs
index 43c9e3fac..3b3acf5db 100644
--- a/crates/horizon-mods/src/runtime.rs
+++ b/crates/horizon-mods/src/runtime.rs
@@ -323,15 +323,25 @@ struct BrowserState {
     /// across mods and reloads, so the game converts them once.
     version: u64,
     /// `set-recipes`' title and recipes, shown instead of the items.
-    recipes: Option<(String, Vec<BrowserRecipe>)>,
+    recipes: Option<RecipePage>,
     events: std::collections::VecDeque<BrowserEvent>,
 }
+/// What `browser.set-recipes` shows: a title, tabs (`tab` the selected
+/// one) and the recipes.
+#[derive(Clone, Debug)]
+pub struct RecipePage {
+    pub title: String,
+    pub tabs: Vec<BrowserStack>,
+    pub tab: u32,
+    pub recipes: Vec<BrowserRecipe>,
+}
 static BROWSER_VERSION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
 /// Items a panel may hold, and events kept for `browser.poll`.
 const BROWSER_ITEMS: usize = 8192;
 /// Recipes `set-recipes` may show, slots in one, and stacks a slot cycles.
 const BROWSER_RECIPES: usize = 256;
 const RECIPE_SLOTS: usize = 9;
+const RECIPE_TABS: usize = 16;
 const SLOT_STACKS: usize = 64;
 const BROWSER_EVENTS: usize = 256;
 impl BrowserState {
@@ -848,13 +858,11 @@ impl Mods {
             ))
         })
     }
-    /// The recipes mod `owner`'s panel shows instead of its items
-    /// (`browser.set-recipes`): the title and the recipes.
-    pub fn browser_recipes(&self, owner: usize) -> Option<(&str, &[BrowserRecipe])> {
+    /// What mod `owner`'s panel shows instead of its items
+    /// (`browser.set-recipes`).
+    pub fn browser_recipes(&self, owner: usize) -> Option<&RecipePage> {
         let b = &self.entries.get(owner)?.run.as_ref()?.store.data().browser;
-        b.recipes
-            .as_ref()
-            .map(|(title, list)| (title.as_str(), list.as_slice()))
+        b.recipes.as_ref()
     }
     /// The player did `event` on mod `owner`'s panel.
     pub fn browser_event(&mut self, owner: usize, event: BrowserEvent) {
@@ -1261,7 +1269,13 @@ impl browser::Host for State {
             .collect();
         self.browser.version = BROWSER_VERSION.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
     }
-    fn set_recipes(&mut self, title: String, recipes: Vec<BrowserRecipe>) {
+    fn set_recipes(
+        &mut self,
+        title: String,
+        tabs: Vec<BrowserStack>,
+        tab: u32,
+        recipes: Vec<BrowserRecipe>,
+    ) {
         let stack = |s: BrowserStack| BrowserStack {
             item: clip(s.item),
             components: clip_to(s.components, 4096),
@@ -1283,7 +1297,12 @@ impl browser::Host for State {
                     ..r
                 })
                 .collect();
-            (clip(title), recipes)
+            RecipePage {
+                title: clip(title),
+                tabs: tabs.into_iter().take(RECIPE_TABS).map(stack).collect(),
+                tab,
+                recipes,
+            }
         });
         self.browser.version = BROWSER_VERSION.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
     }
diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs
index 081884dc2..28fd73ec6 100644
--- a/crates/horizon-mods/tests/sandbox.rs
+++ b/crates/horizon-mods/tests/sandbox.rs
@@ -1196,9 +1196,13 @@ fn browser_lists_items_and_hears_the_player() {
         said(&mut mods, "browser_recipes minecraft:oak_planks"),
         ["recipes shown: 1"]
     );
-    let (title, recipes) = mods.browser_recipes(owner).unwrap();
-    assert_eq!(title, "Recipes for minecraft:oak_planks");
-    let r = &recipes[0];
+    let page = mods.browser_recipes(owner).unwrap();
+    assert_eq!(page.title, "Recipes for minecraft:oak_planks");
+    assert_eq!(
+        (page.tabs[0].item.as_str(), page.tab),
+        ("minecraft:crafting_table", 0)
+    );
+    let r = &page.recipes[0];
     assert_eq!(
         (r.layout, r.width, r.height, r.action),
         (BrowserLayout::Grid, 1, 1, Some(false))
diff --git a/crates/horizon-mods/tests/ui_guest/src/lib.rs b/crates/horizon-mods/tests/ui_guest/src/lib.rs
index 751169565..f879f4302 100644
--- a/crates/horizon-mods/tests/ui_guest/src/lib.rs
+++ b/crates/horizon-mods/tests/ui_guest/src/lib.rs
@@ -364,7 +364,25 @@ impl Mod for Guest {
                         }
                     })
                     .collect();
-                browser::set_recipes(&format!("Recipes for {args}"), &views);
+                // A tab per layout shown, the first selected.
+                let mut tabs: Vec<browser::Stack> = Vec::new();
+                for v in &views {
+                    let icon = match v.layout {
+                        browser::Layout::Grid => "minecraft:crafting_table",
+                        browser::Layout::Cooking => "minecraft:furnace",
+                        browser::Layout::Single => "minecraft:stonecutter",
+                        browser::Layout::Smithing => "minecraft:smithing_table",
+                        browser::Layout::Brewing => "minecraft:brewing_stand",
+                    };
+                    if !tabs.iter().any(|t| t.item == icon) {
+                        tabs.push(browser::Stack {
+                            item: icon.into(),
+                            count: 1,
+                            components: String::new(),
+                        });
+                    }
+                }
+                browser::set_recipes(&format!("Recipes for {args}"), &tabs, 0, &views);
                 chat::show(&format!("recipes shown: {}", views.len()));
             }
             "browser_poll" => {
@@ -389,6 +407,7 @@ impl Mod for Guest {
                         browser::Event::Action(i) => format!("action {i}"),
                         browser::Event::Page(first) => format!("page {first}"),
                         browser::Event::Back => "back".into(),
+                        browser::Event::Tab(i) => format!("tab {i}"),
                     });
                 }
             }
diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md
index 6af12fa5b..5e9593525 100644
--- a/docs/api/mods-reference.md
+++ b/docs/api/mods-reference.md
@@ -587,6 +587,7 @@ A click on a slot of a recipe the panel shows (`set-recipes`).
 | `action` | `u32` | The action button of the recipe at this index in `set-recipes`'s list. |
 | `page` | `u32` | The player turned the recipes' page (`set-recipes`): the index of the first recipe now shown. |
 | `back` |  | The back button of `set-recipes`. |
+| `tab` | `u32` | The player picked the tab at this index of `set-recipes`' tabs. |
 
 ### enum `layout`
 
@@ -617,7 +618,7 @@ A recipe to show. Each slot, and the result, cycles through its stacks, one a se
 | Function | Signature | What it does |
 | --- | --- | --- |
 | `set-items` | `func(items: list<stack>)` | The panel's items, at most 8192 (an empty list hides the panel). |
-| `set-recipes` | `func(title: string, recipes: list<recipe-view>)` | Shows these recipes in the panel instead of its items, as many as fit a page, under `title` and a back button; an empty list shows the items again. At most 256 recipes. |
+| `set-recipes` | `func(title: string, tabs: list<stack>, tab: u32, recipes: list<recipe-view>)` | Shows these recipes in the panel instead of its items, as many as fit a page, under `title` and a back button, with a row of `tabs` (each an icon; `tab` is the selected one) between them; an empty list of recipes shows the items again. At most 256 recipes and 16 tabs. |
 | `poll` | `func() -> list<event>` | What the player did on the panel since the last poll, at most 256 kept. |
 
 ## `players`

From 76d748caf8b5d5a5e8e5446c0533d862197f3cf3 Mon Sep 17 00:00:00 2001
From: Pavel Mikhailovin <pqhaz@MacBook-Air-Pavel.local>
Date: Mon, 26 Oct 2026 20:43:35 +0300
Subject: [PATCH 174/475] Server books: positional page indicator and
 component-list pages

The page indicator only replaced bare %s, but 26.3's en_us template is
"Page %1$s of %2$s"; it now goes through format_java like other
translations (BookViewScreen.getPageNumberMessage).

Pages sent as a component list (Hypixel through ViaVersion) were dropped
by item_data::read_text, which only took a string or a compound, so the
book opened blank. ComponentSerialization.CODEC also takes a list.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/books.rs |  9 ++++---
 crates/horizon-client/src/item_data.rs  | 35 ++++++++++++++++++++++++-
 2 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/game/books.rs b/crates/horizon-client/src/game/books.rs
index 2f38dffd9..b09803e49 100644
--- a/crates/horizon-client/src/game/books.rs
+++ b/crates/horizon-client/src/game/books.rs
@@ -1009,9 +1009,12 @@ impl Game<'_> {
             }
         };
         let indicator = |batch: &mut HudBatch, page: usize, count: usize| {
-            let text = tr("book.pageIndicator", "Page %s of %s")
-                .replacen("%s", &(page + 1).to_string(), 1)
-                .replacen("%s", &count.max(1).to_string(), 1);
+            // BookViewScreen.getPageNumberMessage: 26.3's en_us template is
+            // positional ("Page %1$s of %2$s").
+            let text = horizon_protocol::text::format_java(
+                &tr("book.pageIndicator", "Page %1$s of %2$s"),
+                &[(page + 1).to_string(), count.max(1).to_string()],
+            );
             let tw = HudBatch::text_width(atlas, &text);
             batch.text(atlas, &text, left + 148.0 - tw, top + 16.0, BLACK, false);
         };
diff --git a/crates/horizon-client/src/item_data.rs b/crates/horizon-client/src/item_data.rs
index ac624e85b..3d4fb11e5 100644
--- a/crates/horizon-client/src/item_data.rs
+++ b/crates/horizon-client/src/item_data.rs
@@ -305,7 +305,9 @@ fn read_text(t: &Tag) -> Option<String> {
         // A component's root `text` may be empty with the visible words in
         // `extra` (every legacy display name ViaVersion produces looks like
         // this), so flatten the whole component instead of reading one key.
-        Tag::Compound(_) => Some(crate::entity_nbt::name_text(t).plain()),
+        // ComponentSerialization.CODEC also takes a list (its first element
+        // styling the rest), as servers behind ViaVersion send book pages.
+        Tag::Compound(_) | Tag::List(_) => Some(crate::entity_nbt::name_text(t).plain()),
         _ => None,
     }
 }
@@ -899,6 +901,37 @@ mod tests {
         );
     }
 
+    #[test]
+    fn written_book_pages_may_be_component_lists() {
+        // A page as Hypixel sends it through ViaVersion: a list, not a compound.
+        let page = Tag::List(vec![
+            Tag::compound([("text", Tag::String("".into()))]),
+            Tag::compound([("text", Tag::String("Please read ".into()))]),
+            Tag::compound([("text", Tag::String("the rules".into()))]),
+        ]);
+        let book = Tag::compound([
+            (
+                "title",
+                Tag::compound([("raw", Tag::String("Rules".into()))]),
+            ),
+            ("author", Tag::String("Server".into())),
+            (
+                "pages",
+                Tag::List(vec![
+                    page,
+                    Tag::compound([("raw", Tag::String("Two".into()))]),
+                ]),
+            ),
+        ]);
+        let components = Tag::compound([("minecraft:written_book_content", book)]);
+        let (_, extra) = decode_components(Some(&components));
+        let pages = extra.and_then(|d| d.written.clone()).map(|w| w.pages);
+        assert_eq!(
+            pages,
+            Some(vec!["Please read the rules".to_owned(), "Two".to_owned()])
+        );
+    }
+
     #[test]
     fn banner_layers_and_shield_base_round_trip() {
         let mut stack = ItemStack::new("minecraft:shield", 1);

From e92937d956f8f2d5bb57bd945f80de91cece120c Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:44:23 +0100
Subject: [PATCH 175/475] Apply Slowness with Bane of Arthropods

Post-attack effects only handled ignite, so the apply_mob_effect effect of
Bane of Arthropods never did anything. Handle apply_mob_effect like vanilla.
---
 .../src/game/enchant_effects.rs               | 80 ++++++++++++++-----
 crates/horizon-client/src/game/potions.rs     |  2 +-
 2 files changed, 63 insertions(+), 19 deletions(-)

diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs
index 7cdb3e526..ac194dcba 100644
--- a/crates/horizon-client/src/game/enchant_effects.rs
+++ b/crates/horizon-client/src/game/enchant_effects.rs
@@ -153,8 +153,10 @@ impl Game<'_> {
             items: Some(self.res.items()),
             ..Default::default()
         };
-        // minecraft:post_attack ignite effects of the attacker's weapon (fire aspect).
+        // minecraft:post_attack effects of the attacker's weapon on the victim:
+        // ignite (fire aspect) and apply_mob_effect (bane of arthropods).
         let mut ignite = 0.0f32;
+        let mut mob_effects = Vec::new();
         for (id, level) in held.enchantments() {
             let Some(def) = self.res.stations().enchantments.get(id) else {
                 continue;
@@ -164,24 +166,33 @@ impl Game<'_> {
                 .into_iter()
                 .flatten()
             {
-                if effect["enchanted"] == "attacker"
-                    && effect["affected"] == "victim"
-                    && effect["effect"]["type"] == "minecraft:ignite"
+                let e = &effect["effect"];
+                let kind_of = e["type"].as_str();
+                if effect["enchanted"] != "attacker"
+                    || effect["affected"] != "victim"
+                    || !matches!(
+                        kind_of,
+                        Some("minecraft:ignite" | "minecraft:apply_mob_effect")
+                    )
                 {
-                    let mut random = self.world.random.clone();
-                    let ok = effect.get("requirements").is_none_or(|r| {
-                        self.res
-                            .stations()
-                            .enchantments
-                            .condition(r, *level, &ctx, &mut random)
-                    });
-                    self.world.random = random;
-                    if ok {
-                        ignite = ignite.max(horizon_client::enchant::level_value(
-                            &effect["effect"]["duration"],
-                            *level,
-                        ));
-                    }
+                    continue;
+                }
+                let mut random = self.world.random.clone();
+                let ok = effect.get("requirements").is_none_or(|r| {
+                    self.res
+                        .stations()
+                        .enchantments
+                        .condition(r, *level, &ctx, &mut random)
+                });
+                self.world.random = random;
+                if !ok {
+                    continue;
+                }
+                if kind_of == Some("minecraft:ignite") {
+                    ignite =
+                        ignite.max(horizon_client::enchant::level_value(&e["duration"], *level));
+                } else {
+                    mob_effects.push((e.clone(), *level));
                 }
             }
         }
@@ -191,8 +202,41 @@ impl Game<'_> {
         {
             m.ignite_for_ticks((ignite * 20.0) as i32);
         }
+        for (effect, level) in mob_effects {
+            self.apply_mob_effect(mob, &effect, level);
+        }
         self.post_attack_bursts(&held, &kind);
     }
+    /// `ApplyMobEffect.apply`: one of `to_apply` (a single id or a list) for a
+    /// random duration and amplifier between the level-based bounds.
+    fn apply_mob_effect(&mut self, mob: usize, effect: &serde_json::Value, level: u32) {
+        use horizon_client::enchant::level_value;
+        let Some(m) = self.mobs.get_mut(mob) else {
+            return;
+        };
+        let ids: Vec<&str> = match &effect["to_apply"] {
+            serde_json::Value::String(id) => vec![id.as_str()],
+            serde_json::Value::Array(list) => list.iter().filter_map(|v| v.as_str()).collect(),
+            _ => Vec::new(),
+        };
+        if ids.is_empty() {
+            return;
+        }
+        // HolderSet.getRandomElement, then Mth.randomBetween for both values.
+        let pick = m.random.next_int_bound(ids.len() as i32).unwrap_or(0) as usize;
+        let mut between = |min: &str, max: &str| {
+            let (lo, hi) = (
+                level_value(&effect[min], level),
+                level_value(&effect[max], level),
+            );
+            m.random.next_float() * (hi - lo) + lo
+        };
+        let ticks = (between("min_duration", "max_duration") * 20.0).round() as i32;
+        let amplifier = (between("min_amplifier", "max_amplifier").round() as i32).max(0);
+        if let Some(id) = super::potions::mob_effect_id(ids[pick]) {
+            m.add_effect(id, ticks, amplifier);
+        }
+    }
     /// `minecraft:post_attack` explode effects on the attacker (wind burst):
     /// a burst at the player's feet that only knocks back and triggers
     /// blocks (`ExplodeEffect` with `block_interaction: trigger`).
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index 13eae7d3e..834f6f708 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -28,7 +28,7 @@ pub(super) struct ThrownPotion {
     age: u32,
 }
 /// A mob's effect ids carry the `minecraft:` namespace.
-fn mob_effect_id(id: &str) -> Option<&'static str> {
+pub(super) fn mob_effect_id(id: &str) -> Option<&'static str> {
     use std::{collections::HashMap, sync::OnceLock};
     static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
     let id = id.trim_start_matches("minecraft:");

From 555ddb94bf8a20bf241dde847137fea335f2b2eb Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:45:13 +0100
Subject: [PATCH 176/475] Use the impaling entity tag for thrown tridents

The bonus went to every swimming or water-breathing mob, including undead,
blazes, ghasts and iron golems. Read the damage from the enchantment data so
only #sensitive_to_impaling mobs take it.
---
 crates/horizon-client/src/game/trident.rs | 29 +++++++++++++++++++----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs
index c31094596..9e7f9f65d 100644
--- a/crates/horizon-client/src/game/trident.rs
+++ b/crates/horizon-client/src/game/trident.rs
@@ -5,6 +5,7 @@
 use super::{Game, view_vector};
 use horizon_client::{
     collisions::SceneCollisions,
+    enchant::EffectContext,
     items::ItemStack,
     mesher::Vertex,
     mobs::{Damage, DamageKind, Who, anim::Poses},
@@ -305,11 +306,29 @@ impl Game<'_> {
                     }
                 }
                 if let Some((id, _)) = hit_mob {
-                    let impaling = t.stack.enchantment_level("minecraft:impaling") as f32;
-                    let aquatic = self.mobs.iter().find(|m| m.id == id).is_some_and(|m| {
-                        m.kind.flags.aquatic_swimmer || m.kind.flags.breathes_water
-                    });
-                    let damage = 8.0 + if aquatic { 2.5 * impaling } else { 0.0 };
+                    // ThrownTrident.getDamage: `EnchantmentHelper.modifyDamage` on 8
+                    // (impaling hits `#sensitive_to_impaling`, the aquatic tag).
+                    let victim = self
+                        .mobs
+                        .iter()
+                        .find(|m| m.id == id)
+                        .map(|m| m.kind.id.clone());
+                    let ctx = EffectContext {
+                        this: victim.as_deref(),
+                        attacker: Some("minecraft:player"),
+                        direct_attacker: Some("minecraft:trident"),
+                        is_direct: true,
+                        damage_type: Some("minecraft:trident"),
+                        items: Some(self.res.items()),
+                        ..Default::default()
+                    };
+                    let damage = self.res.stations().enchantments.modify_value(
+                        Some(&t.stack),
+                        "minecraft:damage",
+                        &ctx,
+                        &mut self.world.random,
+                        8.0,
+                    );
                     t.dealt_damage = true;
                     if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
                         let from = Some([t.position.x, t.position.y, t.position.z]);

From 564b230ab168a3be7c0e468ae546acd72fd8dc7e Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:45:13 +0100
Subject: [PATCH 177/475] Make a warden's hit disable the player's shield

A warden holds no weapon, so its blows never put the shield on cooldown. Warden.getSecondsToDisableBlocking is a flat 5 seconds, so use that when the attacker is a warden.
---
 crates/horizon-client/src/game/shield.rs | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/game/shield.rs b/crates/horizon-client/src/game/shield.rs
index c4f7f98d1..a26bc5d75 100644
--- a/crates/horizon-client/src/game/shield.rs
+++ b/crates/horizon-client/src/game/shield.rs
@@ -182,12 +182,17 @@ impl Game<'_> {
             return;
         };
         let (mx, mz) = (m.position.x, m.position.z);
-        let disable = m
-            .extra
-            .main_hand
-            .as_deref()
-            .and_then(|item| self.res.items().get(item))
-            .map_or(0.0, |i| i.disable_blocking_seconds);
+        // LivingEntity.getSecondsToDisableBlocking: the held weapon's value;
+        // Warden overrides it with a flat 5 seconds.
+        let disable = if m.species() == horizon_client::mobs::Species::Warden {
+            5.0
+        } else {
+            m.extra
+                .main_hand
+                .as_deref()
+                .and_then(|item| self.res.items().get(item))
+                .map_or(0.0, |i| i.disable_blocking_seconds)
+        };
         // Ravager.blockedByItem: stunned half the time (the defender pushed
         // apart), else the defender flung away; no roar in progress.
         if m.species() == horizon_client::mobs::Species::Ravager {

From dbef78bcb82f2b123f17c3358aa65aa7953a4f41 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:45:54 +0100
Subject: [PATCH 178/475] Apply Unbreaking to armor wear from Thorns

Thorns always cost the worn piece 2 durability. Run it through the same
durability loss as other wear so Unbreaking can cancel points.
---
 crates/horizon-client/src/game/enchant_effects.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs
index 7cdb3e526..4417f0df8 100644
--- a/crates/horizon-client/src/game/enchant_effects.rs
+++ b/crates/horizon-client/src/game/enchant_effects.rs
@@ -303,8 +303,10 @@ impl Game<'_> {
                 continue;
             }
             hits.push(1.0 + self.world.random.next_float() * 4.0);
+            // ChangeItemDamage -> ItemStack.hurtAndBreak: unbreaking applies.
+            let loss = self.durability_loss(&stack, 2);
             if let Some(s) = self.armor[slot].as_mut() {
-                s.damage += 2;
+                s.damage += loss;
                 if self
                     .res
                     .items()

From bf527e7a13ccf3b6477dbc49004086c44a8832a7 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:46:36 +0100
Subject: [PATCH 179/475] Apply knockback resistance to Punch arrows

---
 crates/horizon-client/src/game/creatures.rs | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 2b65a3289..38dd455c8 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2123,10 +2123,24 @@ impl Game<'_> {
                         hurt
                     }
                 };
-                // doKnockback: Punch pushes along the flight.
+                // doKnockback: Punch pushes along the flight, less the target's
+                // knockback resistance.
                 let flight = (p.velocity.x * p.velocity.x + p.velocity.z * p.velocity.z).sqrt();
-                if hurt && p.bonus.punch > 0 && flight > 1e-6 {
-                    let k = f64::from(p.bonus.punch) * 0.6 / flight;
+                let resistance = match who {
+                    Who::Player => self
+                        .player
+                        .as_mut()
+                        .and_then(|pl| pl.attribute("minecraft:knockback_resistance").ok())
+                        .unwrap_or(0.0),
+                    Who::Mob(id) => self
+                        .mobs
+                        .iter()
+                        .find(|m| m.id == id)
+                        .map_or(0.0, |m| m.attrs.knockback_resistance),
+                };
+                let push = f64::from(p.bonus.punch) * 0.6 * (1.0 - resistance).max(0.0);
+                if hurt && push > 0.0 && flight > 1e-6 {
+                    let k = push / flight;
                     self.handle_mob_events(vec![MobEvent::Push {
                         target: who,
                         velocity: [p.velocity.x * k, 0.1, p.velocity.z * k],

From c1844dfe57e5b3f02b90f9fabad813753aa7e7a4 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:46:37 +0100
Subject: [PATCH 180/475] Let mobs trample farmland when they land on it

A cow dropped onto farmland left it untouched. A landing mob now turns
farmland to dirt with chance fall distance - 0.5, when mob griefing is on and
the mob is big enough, and is lifted onto the dirt.
---
 crates/horizon-client/src/mobs/living.rs | 25 ++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs
index 394821ace..afd0c26db 100644
--- a/crates/horizon-client/src/mobs/living.rs
+++ b/crates/horizon-client/src/mobs/living.rs
@@ -440,11 +440,36 @@ impl Mob {
         }
         if self.on_ground {
             if self.fall_distance > 0.0 {
+                self.trample_farmland(w, events);
                 self.cause_fall_damage(events);
             }
             self.fall_distance = 0.0;
         }
     }
+    /// `FarmlandBlock.fallOn`: a landing on farmland turns it to dirt with
+    /// chance `fallDistance - 0.5`, if mobs may grief and the mob's
+    /// `width * width * height` is over 0.512. `Block.pushEntitiesUp` lifts
+    /// the mob onto the dirt, which is a full block.
+    fn trample_farmland(&mut self, w: &MobWorld, events: &mut Vec<MobEvent>) {
+        let p = self.block_on_legacy(w);
+        if w.block_name(p[0], p[1], p[2]) != "minecraft:farmland" {
+            return;
+        }
+        let roll = f64::from(self.random.next_float());
+        let Some(dirt) = w.registry.default_state("minecraft:dirt") else {
+            return;
+        };
+        if roll < self.fall_distance - 0.5
+            && w.mob_griefing
+            && self.width() * self.width() * self.height() > 0.512
+        {
+            events.push(MobEvent::SetBlock {
+                pos: p,
+                state: dirt,
+            });
+            self.position.y = self.position.y.max(f64::from(p[1]) + 1.0);
+        }
+    }
     /// Entity.updateFluidInteraction: the fluid state, then touching water
     /// resets the fall and entering it (after the first tick) splashes.
     pub(super) fn update_fluids(&mut self, w: &MobWorld, events: &mut Vec<MobEvent>) {

From 90501f9ab4ab5cb04e85d6aa5d032d25e8e6bda2 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:46:46 +0100
Subject: [PATCH 181/475] Keep leashed mobs and carrying endermen from
 despawning

Mob.requiresCustomPersistence also covers a leashed mob and an enderman holding a block, and the spawn caps skip such mobs. Gather the existing cases in one helper, add the missing ones, and use it for both the despawn check and the cap count.
---
 .../src/game/natural_spawning.rs              |  3 ++-
 crates/horizon-client/src/mobs/ai.rs          | 20 +++++++++++++------
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/crates/horizon-client/src/game/natural_spawning.rs b/crates/horizon-client/src/game/natural_spawning.rs
index 0035f5082..5afa72416 100644
--- a/crates/horizon-client/src/game/natural_spawning.rs
+++ b/crates/horizon-client/src/game/natural_spawning.rs
@@ -504,7 +504,8 @@ impl<'a> Game<'a> {
                         m.position.z.floor() as i32,
                     ],
                     is_mob: true,
-                    persistent: m.persistent,
+                    persistent: m.persistent
+                        || horizon_client::mobs::ai::requires_custom_persistence(m),
                 })
                 .collect();
             let players = players
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 2676c3a37..3b9a8ed04 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -1017,6 +1017,19 @@ pub fn despawn_check(m: &mut Mob, w: &MobWorld) -> bool {
     }
     true
 }
+/// `Mob.requiresCustomPersistence` and its overrides: a passenger or a leashed
+/// mob, a raider in a raid, an enderman carrying a block, a tame nautilus, a
+/// sulfur cube holding a block or let out of a bucket. The spawn caps do not
+/// count these mobs either (`NaturalSpawner.createState`).
+pub fn requires_custom_persistence(m: &Mob) -> bool {
+    super::riders::keeps_alive(m)
+        || m.extra.leash.is_some()
+        || super::raider::state(m).is_some_and(|s| s.raid_id.is_some())
+        || m.species() == Species::Enderman && m.extra.carried.is_some()
+        || super::nautilus::is_nautilus(m.species()) && m.extra.tame
+        || m.species() == Species::SulfurCube
+            && (super::sulfur_cube::has_body(m) || m.extra.scratch[3] != 0)
+}
 /// Mob.checkDespawn, before the tick (players are the only despawn
 /// reference). Returns false when the mob is discarded.
 fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool {
@@ -1032,12 +1045,7 @@ fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool {
         return true;
     };
     let d = m.distance_sqr(p);
-    // requiresCustomPersistence: raiders in a raid, a tame nautilus, a sulfur
-    // cube holding a block or let out of a bucket.
-    let persistent = m.persistent
-        || super::nautilus::is_nautilus(m.species()) && m.extra.tame
-        || m.species() == Species::SulfurCube
-            && (super::sulfur_cube::has_body(m) || m.extra.scratch[3] != 0);
+    let persistent = m.persistent || requires_custom_persistence(m);
     // removeWhenFarAway: animals, villagers, golems, patrols and raiders,
     // zombie villagers being cured and ridden mobs stay.
     let creature = m.kind.category == "creature";

From a4407a4bccccf75769926530e6ac8bd7b981de64 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:47:34 +0100
Subject: [PATCH 182/475] Elytra: Unbreaking for remote players, keep wall hit
 events on the server copy

---
 crates/horizon-client/src/game/lan_actions.rs |  8 ++++++--
 crates/horizon-client/src/motion.rs           | 15 +++++++++++++++
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index bbb0c37c0..cd0d2ea46 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -2326,9 +2326,13 @@ impl Game<'_> {
             }
             if (next / 10) % 2 == 0
                 && !creative
-                && let Some(elytra) = game.armor[1].as_mut()
+                && let Some(stack) = game.armor[1].clone()
             {
-                elytra.damage += 1;
+                // `ItemStack.hurtAndBreak`: Unbreaking can save the wear.
+                let loss = game.durability_loss(&stack, 1);
+                if let Some(elytra) = game.armor[1].as_mut() {
+                    elytra.damage += loss;
+                }
             }
             let ctx = game.player_context(None);
             game.post_game_event("minecraft:elytra_glide", at, ctx);
diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index 29e9d3e06..5f6db8248 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -311,6 +311,9 @@ pub struct PlayerMotion {
     /// it travels on the server: `isLocalInstanceAuthoritative` is false, so
     /// its moves check no fall damage.
     pub server_copy: bool,
+    /// The span of `events` a wall hit on the server's copy pushed (sound and
+    /// damage): `server_travel` keeps them while it drops the simulated moves.
+    pub wall_hit_events: Option<std::ops::Range<usize>>,
     /// A client's copy of its own player (`Level.isClientSide`): only the
     /// server hurts it (`Entity.hurt` does nothing on a client) and ticks its
     /// food (`ServerPlayer.tick`). Its hurt animation comes from the server.
@@ -480,6 +483,7 @@ impl PlayerMotion {
             freeze_immune: false,
             old_position: position,
             server_copy: false,
+            wall_hit_events: None,
             client_side: false,
             block_effects: true,
             powder_snow_entered: Vec::new(),
@@ -1073,7 +1077,14 @@ impl MotionWorld<'_, '_, '_> {
         p.server_copy = false;
         (p.position, p.ground, p.collision) = (position, ground, collision);
         (p.history, p.fall_distance, p.steps) = (history, fall_distance, steps);
+        // The wall hit is the server's own: its sound and damage events stay.
+        let kept: Vec<_> = p
+            .wall_hit_events
+            .take()
+            .map(|span| p.events.drain(span).collect())
+            .unwrap_or_default();
         p.events.truncate(events);
+        p.events.extend(kept);
         travelled
     }
     /// `LivingEntity.checkAutoSpinAttack`: the first living entity in the
@@ -1590,6 +1601,7 @@ impl MotionWorld<'_, '_, '_> {
             };
             let dmg = ((move_h - new_h) * 10.0 - 3.0) as f32;
             if dmg > 0.0 {
+                let first = self.player.events.len();
                 // getFallDamageSound((int) dmg)
                 let sound = if dmg as i32 > 4 {
                     crate::landing::SceneSound::BigFall
@@ -1612,6 +1624,9 @@ impl MotionWorld<'_, '_, '_> {
                     .ok_or("missing fly_into_wall damage type")?;
                 let rules = self.scene.health_rules;
                 self.player.hurt(&self.resources.health, rules, id, dmg)?;
+                if self.player.server_copy {
+                    self.player.wall_hit_events = Some(first..self.player.events.len());
+                }
             }
         }
         Ok(())

From 7569f9615a193b50443eaff428e126651a647ce2 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:47:58 +0100
Subject: [PATCH 183/475] Treat unbreakable items as undamageable in the anvil
 and grindstone

---
 crates/horizon-client/src/stations.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/horizon-client/src/stations.rs b/crates/horizon-client/src/stations.rs
index a307b35cf..3fa480656 100644
--- a/crates/horizon-client/src/stations.rs
+++ b/crates/horizon-client/src/stations.rs
@@ -151,8 +151,12 @@ pub struct AnvilResult {
     pub repair_item_count_cost: u32,
     pub only_renaming: bool,
 }
+/// `ItemStack.isDamageableItem`: durability, and not `minecraft:unbreakable`.
 pub fn is_damageable(items: &Items, stack: &ItemStack) -> bool {
     items.get(&stack.item).is_some_and(|i| i.max_damage > 0)
+        && stack
+            .data()
+            .is_none_or(|d| d.other("minecraft:unbreakable").is_none())
 }
 fn max_damage(items: &Items, stack: &ItemStack) -> i32 {
     items.get(&stack.item).map_or(0, |i| i.max_damage as i32)

From e60cbe8d4df0ad5ea87d571984f2bfd8119cfca8 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:48:03 +0100
Subject: [PATCH 184/475] Keep whole nugget stacks and picked-up enchantments
 on piglins

---
 crates/horizon-client/src/game/piglins.rs  | 24 ++++++++++++++--------
 crates/horizon-client/src/mobs/finalize.rs |  8 ++++++++
 2 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/crates/horizon-client/src/game/piglins.rs b/crates/horizon-client/src/game/piglins.rs
index 7e58620bf..edfd9a3a0 100644
--- a/crates/horizon-client/src/game/piglins.rs
+++ b/crates/horizon-client/src/game/piglins.rs
@@ -6,7 +6,10 @@ use horizon_client::{
     items::ItemStack,
     mobs::{
         Mob, Species, Who,
-        finalize::{SLOT_NAMES, set_drop_chance, set_item, stored_drop_chance},
+        finalize::{
+            SLOT_NAMES, set_drop_chance, set_item, set_slot_enchantments, slot_enchantments,
+            stored_drop_chance,
+        },
         piglin::{ADMIRE, ATE_RECENTLY},
     },
 };
@@ -88,7 +91,8 @@ impl Game<'_> {
     /// `Mob.equipItemIfPossible` for a piglin: put it in its slot when that
     /// slot takes it (an armour piece that cannot replace what is worn goes
     /// to an empty main hand), dropping what it replaces by drop chance.
-    fn piglin_equip(&mut self, index: usize, item: &str) -> bool {
+    fn piglin_equip(&mut self, index: usize, stack: &ItemStack) -> bool {
+        let item = &*stack.item;
         let mut slot = self.piglin_slot(item);
         let m = &self.mobs[index];
         let mut replace = self.piglin_can_replace(m, item, slot);
@@ -103,18 +107,18 @@ impl Game<'_> {
         let old = horizon_client::mobs::finalize::item(m, slot);
         let chance = stored_drop_chance(m, slot);
         let drop_old = old.is_some() && (m.random.next_float() - 0.1).max(0.0) < chance;
+        let old_enchantments = slot_enchantments(m, slot);
         set_item(m, slot, item);
+        // The piglin keeps what the stack carried (Protection IV stays on).
+        set_slot_enchantments(m, slot, stack.enchantments().to_vec());
         // setItemSlotAndDropWhenKilled, then persistenceRequired.
         set_drop_chance(m, slot, 2.0);
         m.persistent = true;
         let at = [m.position.x, m.position.y, m.position.z];
         if let (true, Some(old)) = (drop_old, old) {
-            self.spawn_item(
-                ItemStack::new(&old, 1),
-                at,
-                super::dispenser::new_item_motion(),
-                10,
-            );
+            let mut dropped = ItemStack::new(&old, 1);
+            dropped.set_crafting_enchantments(old_enchantments);
+            self.spawn_item(dropped, at, super::dispenser::new_item_motion(), 10);
         }
         true
     }
@@ -153,7 +157,9 @@ impl Game<'_> {
     /// `PiglinAi.stopHoldingOffHandItem` for something that is not
     /// bartering currency: wear it if it can, else keep it in the inventory.
     fn piglin_keep(&mut self, index: usize, stack: ItemStack) {
-        if !self.piglin_equip(index, &stack.item) {
+        // Nuggets keep their whole stack in the inventory (a hand slot here
+        // holds one item id only).
+        if &*stack.item == "minecraft:gold_nugget" || !self.piglin_equip(index, &stack) {
             self.piglin_stash(index, stack);
         }
     }
diff --git a/crates/horizon-client/src/mobs/finalize.rs b/crates/horizon-client/src/mobs/finalize.rs
index 4eeed885b..58aaa02bb 100644
--- a/crates/horizon-client/src/mobs/finalize.rs
+++ b/crates/horizon-client/src/mobs/finalize.rs
@@ -829,6 +829,14 @@ pub fn set_item(m: &mut Mob, slot: usize, id: &str) {
     }
     gear::set(m, gear_slot(slot), Vec::new());
 }
+/// The enchantments on what `m` has in `slot`.
+pub fn slot_enchantments(m: &Mob, slot: usize) -> gear::Levels {
+    gear::gear(m).map_or_else(Vec::new, |g| g.slots[gear_slot(slot)].clone())
+}
+/// Replace the enchantments of what `m` has in `slot` (after `set_item`).
+pub fn set_slot_enchantments(m: &mut Mob, slot: usize, levels: gear::Levels) {
+    gear::set(m, gear_slot(slot), levels);
+}
 /// `Mob.setDropChance`.
 pub fn set_drop_chance(m: &mut Mob, slot: usize, chance: f32) {
     let c = m

From e2b1dc66914a82108611316e978a8aa379463de1 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:49:12 +0100
Subject: [PATCH 185/475] Soul Speed: run its effects for each server-side
 player

---
 crates/horizon-client/src/game.rs             | 15 +++++++-
 .../src/game/enchant_effects.rs               | 34 +++++++++----------
 crates/horizon-client/src/game/lan_actions.rs |  8 +++++
 .../horizon-client/src/game/lan_particles.rs  | 29 ++++++++++++++++
 crates/horizon-client/src/motion.rs           |  9 ++++-
 5 files changed, 75 insertions(+), 20 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 515a69cc8..6f856d1cb 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4342,7 +4342,20 @@ impl Game<'_> {
         };
         self.eye += (camera_eye.unwrap_or(eye_height) - self.eye) * 0.5;
         let crouching = player.pose == horizon_client::pose::Pose::Crouching;
-        self.tick_soul_speed();
+        if let Some((at, velocity)) = self.tick_soul_speed() {
+            self.particles.send_particles(
+                &horizon_client::particles::ParticleOptions::simple(
+                    horizon_client::particles::ParticleType::Soul,
+                ),
+                at,
+                velocity,
+                1.0,
+                0,
+            );
+            if let Some(host) = self.lan.as_ref() {
+                lan_particles::send_soul_particle(host, at, velocity);
+            }
+        }
         self.tick_avatar(before, riding);
         self.end_spin_attack(spin_hit);
         self.record_combat(&events);
diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs
index 8ae54dba7..ad9894da8 100644
--- a/crates/horizon-client/src/game/enchant_effects.rs
+++ b/crates/horizon-client/src/game/enchant_effects.rs
@@ -9,7 +9,6 @@ use super::Game;
 use horizon_client::{
     enchant::{EffectContext, Enchantments, level_value},
     items::ItemStack,
-    particles::{ParticleOptions, ParticleType},
 };
 use horizon_core::{position::BlockPos, random::RandomSource};
 
@@ -474,15 +473,16 @@ impl Game<'_> {
     ///   (`enchantment_active_check`);
     /// - the boots lose 1 durability with a 4% chance when on such a block.
     ///
-    /// Every fifth tick the player walking on one also gets soul particles and
-    /// sometimes a sound. A remote server applies and syncs all of this itself.
-    pub(super) fn tick_soul_speed(&mut self) {
+    /// Every fifth tick the player walking on one also gets a soul particle
+    /// (returned as its position and velocity, for the caller to show or send
+    /// to the players around) and sometimes a sound. Runs for the window's own
+    /// player and for each guest on the server (`guest_server_tick`); a remote
+    /// client leaves it to its server.
+    pub(super) fn tick_soul_speed(&mut self) -> Option<([f64; 3], [f64; 3])> {
         const ID: &str = "minecraft:soul_speed";
-        let Some(player) = self.player.as_mut() else {
-            return;
-        };
+        let player = self.player.as_mut()?;
         if player.client_side {
-            return;
+            return None;
         }
         let level = self.armor[3]
             .as_ref()
@@ -533,22 +533,19 @@ impl Game<'_> {
             self.wear_boots(1);
         }
         if level == 0 {
-            return;
+            return None;
         }
         let r = &mut self.world.random;
-        if tick_effects {
-            // `spawn_particles`: in the bounding box, 0.1 above the feet, thrown
-            // back against the movement (-0.2) and up (0.1).
+        // `spawn_particles`: in the bounding box, 0.1 above the feet, thrown
+        // back against the movement (-0.2) and up (0.1).
+        let particle = tick_effects.then(|| {
             let x = position.x + (r.next_double() - 0.5) * f64::from(width);
             let z = position.z + (r.next_double() - 0.5) * f64::from(width);
-            self.particles.send_particles(
-                &ParticleOptions::simple(ParticleType::Soul),
+            (
                 [x, position.y + 0.1, z],
                 [moved.x * -0.2, 0.1, moved.z * -0.2],
-                1.0,
-                0,
-            );
-        }
+            )
+        });
         // `play_sound`: its `random_chance` (35%) comes first in its `all_of`,
         // so the level random is drawn every tick the boots are worn; volume
         // 0.6, pitch 0.6 to 1.0.
@@ -561,6 +558,7 @@ impl Game<'_> {
                 pitch,
             );
         }
+        particle
     }
     /// `ItemStack.hurtAndBreak` on the worn boots (`change_item_damage`):
     /// Unbreaking applies, and they break when worn out.
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index bbb0c37c0..78227b475 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -2115,6 +2115,7 @@ impl Game<'_> {
         let in_wall = !g.sleeping && self.in_wall(g.position, g.eye_height());
         let at = g.position;
         let sneaking = g.sneaking;
+        let mut soul = None;
         let events = self.as_guest(host, conn, |game| {
             let (rules, motion) = (game.world.health_rules, game.motion);
             let health = &motion.health;
@@ -2184,6 +2185,7 @@ impl Game<'_> {
             w.player.shift_key_down = sneaking;
             w.player.freeze_immune = freeze_immune;
             let _ = w.server_block_damage(start);
+            let _ = w.update_soul_speed_block();
             let _ = w.tick_environment_damage();
             let _ = w.apply_fire_contact();
             let _ = w.server_hazards_tick(in_wall);
@@ -2211,6 +2213,9 @@ impl Game<'_> {
             // LivingEntity.baseTick: outside the world border, then tickEffects.
             game.border_damage();
             game.tick_mob_effects();
+            // Soul Speed's effects (LivingEntity.baseTick's location_changed
+            // and tick effects); its particle goes to the players around.
+            soul = game.tick_soul_speed();
             let Some(player) = game.player.as_mut() else {
                 return (Vec::new(), None);
             };
@@ -2238,6 +2243,9 @@ impl Game<'_> {
         let Some((events, marked)) = events else {
             return;
         };
+        if let Some((at, velocity)) = soul {
+            super::lan_particles::send_soul_particle(host, at, velocity);
+        }
         self.as_guest(host, conn, |game| game.tick_player_sculk_events());
         for event in events {
             match event {
diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs
index 719fe79ab..a11547759 100644
--- a/crates/horizon-client/src/game/lan_particles.rs
+++ b/crates/horizon-client/src/game/lan_particles.rs
@@ -24,6 +24,35 @@ fn rgb(c: [f32; 4]) -> [f32; 3] {
     [c[0], c[1], c[2]]
 }
 
+/// `ServerLevel.sendParticles` of one soul particle moving by `velocity`
+/// (Soul Speed's `spawn_particles`): sent to the players within 32 blocks.
+pub(super) fn send_soul_particle(host: &super::lan::LanHost, at: [f64; 3], velocity: [f64; 3]) {
+    let Some(id) = host
+        .hub
+        .registry_id("minecraft:particle_type", "minecraft:soul")
+    else {
+        return;
+    };
+    let packet = C::LevelParticles(play::LevelParticles {
+        particle: Particle { id, data: None },
+        override_limiter: false,
+        always_show: false,
+        pos: at,
+        dist: velocity.map(|v| v as f32),
+        max_speed: [1.0; 3],
+        count: 0,
+        randomization: 0,
+    });
+    for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) {
+        let distance: f64 = (0..3)
+            .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2))
+            .sum();
+        if distance < 32.0 * 32.0 {
+            g.send(&packet);
+        }
+    }
+}
+
 impl Game<'_> {
     /// `SonicBoom.tick` uses `ServerLevel.sendParticles` for each ray point.
     /// Keep the local event's rendering; connected players receive one at rest.
diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index 156fc2549..084793049 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -1007,7 +1007,7 @@ impl MotionWorld<'_, '_, '_> {
             )
         });
         self.player.try_add_frost(on_air)?;
-        self.player.location_effects.on_soul_speed_block = self.on_soul_speed_block()?;
+        self.update_soul_speed_block()?;
         if self.player.health.tick_count % 40 == 0
             && self.player.is_fully_frozen()
             && self.player.can_freeze()
@@ -1020,6 +1020,13 @@ impl MotionWorld<'_, '_, '_> {
         }
         Ok(())
     }
+    /// Refresh whether the player stands on a soul speed block, for the
+    /// `location_changed` enchantment effects (a server's player too, whose
+    /// client does the walking).
+    pub fn update_soul_speed_block(&mut self) -> Result<()> {
+        self.player.location_effects.on_soul_speed_block = self.on_soul_speed_block()?;
+        Ok(())
+    }
     /// `MovementAffectedByPredicate` for `#minecraft:soul_speed_blocks`.
     fn on_soul_speed_block(&mut self) -> Result<bool> {
         let on = self.support(movement_support::MOVEMENT_SUPPORT_OFFSET)?;

From d7ec7b6077b73fa0159597d5f8ebdbf057701978 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 18:55:45 +0100
Subject: [PATCH 186/475] Shulker bullet split: record whether the shell was
 open at hit time

---
 crates/horizon-client/src/mobs/shulker.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/mobs/shulker.rs b/crates/horizon-client/src/mobs/shulker.rs
index 124d1b299..6f0edc2d7 100644
--- a/crates/horizon-client/src/mobs/shulker.rs
+++ b/crates/horizon-client/src/mobs/shulker.rs
@@ -166,9 +166,10 @@ pub fn after_hurt(m: &mut Mob) {
 }
 /// `Shulker.hurtServer` after a shulker bullet's damage: unless the
 /// low-health teleport was drawn instead (`else if`), `hitByShulkerBullet`
-/// runs on the next tick.
+/// runs on the next tick. Whether the shell is open is read here, at hurt
+/// time, so a goal opening it before that tick cannot change the outcome.
 pub fn hit_by_bullet(m: &mut Mob) {
-    if m.species() == Species::Shulker && !m.extra.flag {
+    if m.species() == Species::Shulker && !m.extra.flag && m.extra.counter != 0 {
         m.extra.flag2 = true;
     }
 }
@@ -188,9 +189,10 @@ pub fn ai_step(
         hit_by_shulker_bullet(m, w, level_random, events);
     }
 }
-/// `Shulker.hitByShulkerBullet`: an open shulker teleports, and leaves a
-/// new one of its colour behind unless shulkers crowd the place (one in
-/// five fewer chances for every other shulker within 8 blocks).
+/// `Shulker.hitByShulkerBullet` (only queued by an open shulker): it
+/// teleports, and leaves a new one of its colour behind unless shulkers
+/// crowd the place (one in five fewer chances for every other shulker
+/// within 8 blocks).
 fn hit_by_shulker_bullet(
     m: &mut Mob,
     w: &MobWorld,
@@ -199,7 +201,7 @@ fn hit_by_shulker_bullet(
 ) {
     let old_position = m.position;
     let old_box = m.bounds();
-    if m.extra.counter == 0 || !teleport(m, w, events) {
+    if !teleport(m, w, events) {
         return;
     }
     let area = old_box.inflate(Vec3::new(8.0, 8.0, 8.0));

From 2277c85fc3e486fa36ef6f4569a826a73db0cbd4 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:07:02 +0100
Subject: [PATCH 187/475] Run neighbour updates when a mob trampling farmland
 places dirt

---
 crates/horizon-client/src/game/creatures.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 2b65a3289..f08f41d01 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1037,9 +1037,9 @@ impl Game<'_> {
                     [0.0, 0.2, 0.0],
                     10,
                 ),
-                MobEvent::SetBlock { pos, state } => {
-                    self.world.set(pos[0], pos[1], pos[2], state)?
-                }
+                // `Level.setBlockAndUpdate`: neighbour and shape updates, so a crop
+                // above trampled farmland breaks and drops.
+                MobEvent::SetBlock { pos, state } => self.level_set(pos, state)?,
                 MobEvent::SetDoorOpen { pos, open } => {
                     let pos = BlockPos::new(pos[0], pos[1], pos[2]);
                     self.with_level(|b, level, ticks| b.set_door_open(level, ticks, pos, open));

From 7f5e3384b375c822d634f00a020f13f4992263f1 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:07:11 +0100
Subject: [PATCH 188/475] Play mining hit sounds once, from the server's
 destroy level events

The server now sends level events 2019 and 2020 every tick a player digs
(ServerPlayerGameMode.tick), and clients handle them like LevelEventHandler:
a crack on the face, plus the hit sound for 2020. A remote client plays only
the first hit itself and no longer adds its own sound every fourth tick, so
the hit was heard twice, out of phase, for every block.
---
 crates/horizon-client/src/game.rs             | 45 ++++++++++++-------
 crates/horizon-client/src/game/lan.rs         |  5 ++-
 .../src/game/level_particles.rs               | 24 ++++++++++
 crates/horizon-client/src/game/remote.rs      | 17 ++-----
 4 files changed, 60 insertions(+), 31 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 8448f0837..a0bc6c339 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2844,6 +2844,16 @@ impl Game<'_> {
                     data,
                 } => self.sculk_charge_event(pos, data),
                 LevelEvent::LevelEvent { id: 3007, pos, .. } => self.shriek_event(pos),
+                // LevelEventHandler 2019 and 2020: the crack on a face of the
+                // block being mined, with its hit sound for 2020.
+                LevelEvent::LevelEvent {
+                    id: id @ (2019 | 2020),
+                    pos,
+                    data,
+                } => {
+                    let face = horizon_core::geometry::Direction::ALL[data.clamp(0, 5) as usize];
+                    self.breaking_block_effects([pos.x, pos.y, pos.z], face.normal(), id == 2020);
+                }
                 LevelEvent::LevelEvent { id: 2004, pos, .. } => {
                     self.spawner_burst([pos.x, pos.y, pos.z])
                 }
@@ -4042,6 +4052,17 @@ impl Game<'_> {
             _ => {}
         }
     }
+    /// `ServerPlayerGameMode.tick` while a player digs: level event 2020 every
+    /// fourth tick since the START (the hit sound), else 2019 (the crack only),
+    /// for everyone around, the digger included (`levelEvent(null, ...)`).
+    fn destroy_progress_event(&mut self, pos: [i32; 3], face: [i32; 3], ticks: u32) {
+        let id = if ticks.is_multiple_of(4) { 2020 } else { 2019 };
+        let direction = horizon_core::geometry::Direction::ALL
+            .iter()
+            .position(|d| d.normal() == face)
+            .unwrap_or(1);
+        self.level_event_at(id, pos, direction as i32);
+    }
     fn tick_mining(&mut self) -> Result<()> {
         if self.destroy_delay > 0 {
             self.destroy_delay -= 1;
@@ -4085,6 +4106,11 @@ impl Game<'_> {
         let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]);
         let facts = self.res.facts().get(state);
         if facts.hardness < 0.0 {
+            // The server still counts its destroy ticks on an unbreakable block.
+            let m = self.mining.as_mut().ok_or("mining")?;
+            m.ticks += 1;
+            let (pos, ticks) = (m.pos, m.ticks);
+            self.destroy_progress_event(pos, hit.face, ticks);
             return Ok(());
         }
         // Player.getDestroySpeed / BlockBehaviour.getDestroyProgress.
@@ -4115,26 +4141,15 @@ impl Game<'_> {
         } else {
             speed / facts.hardness / if harvest { 30.0 } else { 100.0 }
         };
-        let hit_sound = facts.sounds.clone();
         self.swing_arm();
         let m = self.mining.as_mut().ok_or("mining")?;
         m.progress += progress;
         m.ticks += 1;
-        let crack = (m.pos, hit.face);
-        if m.ticks % 4 == 1 {
-            let c = [
-                f64::from(m.pos[0]) + 0.5,
-                f64::from(m.pos[1]) + 0.5,
-                f64::from(m.pos[2]) + 0.5,
-            ];
-            self.audio.play(
-                &hit_sound.hit,
-                Some(c),
-                (hit_sound.volume + 1.0) / 8.0,
-                hit_sound.pitch * 0.5,
-            );
+        // An instant break at START sends no destroy events.
+        if m.progress < 1.0 || m.ticks > 1 {
+            let (pos, ticks) = (m.pos, m.ticks);
+            self.destroy_progress_event(pos, hit.face, ticks);
         }
-        self.crack_particle(crack.0, crack.1, state);
         let m = self.mining.as_mut().ok_or("mining")?;
         // ServerPlayerGameMode breaks a player's block at once only when it is instant (START's
         // insta-mine); otherwise it waits for the client's STOP_DESTROY_BLOCK
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..3a172073d 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -1188,8 +1188,9 @@ impl Game<'_> {
                 horizon_world::level::LevelEvent::LevelEvent { id, pos, data } => {
                     // The acting guest does not predict the egg's teleport
                     // particles, bone meal's growth, or anvil result sounds
-                    // (these levelEvent calls name no excluded player).
-                    let except = if matches!(*id, 2015 | 1505 | 1029 | 1030) {
+                    // (these levelEvent calls name no excluded player), nor
+                    // the digger's own crack and hit sound (2019, 2020).
+                    let except = if matches!(*id, 2015 | 1505 | 1029 | 1030 | 2019 | 2020) {
                         None
                     } else {
                         self.lan_acting
diff --git a/crates/horizon-client/src/game/level_particles.rs b/crates/horizon-client/src/game/level_particles.rs
index f12aedc5b..69fbcfc2e 100644
--- a/crates/horizon-client/src/game/level_particles.rs
+++ b/crates/horizon-client/src/game/level_particles.rs
@@ -134,6 +134,30 @@ impl Game<'_> {
         // Each guest plays it from the global packet.
         self.audio.play_unshared(sound, at, volume, 1.0);
     }
+    /// `ClientLevel.addBreakingBlockEffects`: the block's hit sound (only for
+    /// `play_sound`) and one crumb on the face being mined; nothing for air.
+    pub(super) fn breaking_block_effects(
+        &mut self,
+        pos: [i32; 3],
+        face: [i32; 3],
+        play_sound: bool,
+    ) {
+        let state = self.world.block(pos[0], pos[1], pos[2]);
+        if self.res.facts().is_air(state) {
+            return;
+        }
+        if play_sound {
+            let sounds = self.res.facts().get(state).sounds.clone();
+            // Each guest plays it from the level event itself.
+            self.audio.play_unshared(
+                &sounds.hit,
+                Some(pos.map(|v| f64::from(v) + 0.5)),
+                (sounds.volume + 1.0) / 8.0,
+                sounds.pitch * 0.5,
+            );
+        }
+        self.crack_particle(pos, face, state);
+    }
     /// Queue and play level event `id` at `pos` (`Level.levelEvent`).
     pub(super) fn level_event_at(&mut self, id: i32, pos: [i32; 3], data: i32) {
         self.level_events.push(LevelEvent::LevelEvent {
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3cfbd15e3..1cc659cc0 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3866,6 +3866,9 @@ impl Game<'_> {
             if let Some(r) = self.remote.as_mut() {
                 r.destroying = Some((hit.pos, face, 0.0));
             }
+            // startDestroyBlock plays the first hit and crack itself; the
+            // server's level events 2019 and 2020 do the rest.
+            self.breaking_block_effects(hit.pos, hit.face, true);
             self.mining = Some(Mining {
                 pos: hit.pos,
                 progress: 0.0,
@@ -3878,20 +3881,6 @@ impl Game<'_> {
         };
         let done = done + progress;
         let ticks = self.mining.as_ref().map_or(0, |m| m.ticks) + 1;
-        if ticks % 4 == 1 {
-            let c = [
-                f64::from(pos[0]) + 0.5,
-                f64::from(pos[1]) + 0.5,
-                f64::from(pos[2]) + 0.5,
-            ];
-            self.audio.play(
-                &facts.sounds.hit,
-                Some(c),
-                (facts.sounds.volume + 1.0) / 8.0,
-                facts.sounds.pitch * 0.5,
-            );
-        }
-        self.crack_particle(pos, hit.face, state);
         if done >= 1.0 {
             let seq = self.next_sequence();
             self.predict_break(pos, state, seq);

From 91d6bdba85be4bc2f81b5f44ab896257799ecbf5 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:11:21 +0100
Subject: [PATCH 189/475] Fly firework rockets on by themselves between server
 updates

---
 crates/horizon-client/src/game/fireworks.rs   | 89 +++++++++++--------
 crates/horizon-client/src/game/remote.rs      |  9 ++
 .../src/game/remote_projectiles.rs            | 16 +++-
 3 files changed, 72 insertions(+), 42 deletions(-)

diff --git a/crates/horizon-client/src/game/fireworks.rs b/crates/horizon-client/src/game/fireworks.rs
index af226335e..716fa7d60 100644
--- a/crates/horizon-client/src/game/fireworks.rs
+++ b/crates/horizon-client/src/game/fireworks.rs
@@ -62,11 +62,56 @@ impl Rocket {
             item,
         }
     }
-    /// One tick of a server's client: the previous position, then `step`.
-    pub(super) fn remote_step(&mut self, step: impl FnOnce(Vec3) -> Vec3) {
+    /// One tick of a server's client: the rocket flies on by itself between
+    /// the server's updates (a rocket that follows an entity is placed by the
+    /// caller).
+    pub(super) fn remote_step(&mut self, scene: &mut SceneCollisions) {
         self.previous = self.position;
+        if self.attached_to.is_none() {
+            self.free_flight(scene);
+        }
         self.life += 1;
-        self.position = step(self.position);
+    }
+    /// `FireworkRocketEntity.tick` for a rocket attached to no entity: speed
+    /// up (an angled one keeps its motion) and rise, then move. True when a
+    /// block stopped it.
+    fn free_flight(&mut self, scene: &mut SceneCollisions) -> bool {
+        let h = 0.125;
+        let bounds = Aabb::new(
+            Vec3::new(self.position.x - h, self.position.y, self.position.z - h),
+            Vec3::new(
+                self.position.x + h,
+                self.position.y + 2.0 * h,
+                self.position.z + h,
+            ),
+        );
+        let wanted = if self.angled {
+            self.velocity
+        } else {
+            Vec3::new(
+                self.velocity.x * 1.15,
+                self.velocity.y + 0.04,
+                self.velocity.z * 1.15,
+            )
+        };
+        let Ok(moved) = scene.resolve(bounds, wanted, 0.0, false) else {
+            return false;
+        };
+        let blocked = (moved.x - wanted.x).abs() > 1e-7
+            || (moved.y - wanted.y).abs() > 1e-7
+            || (moved.z - wanted.z).abs() > 1e-7;
+        let horizontal = (moved.x - wanted.x).abs() > 1e-7 || (moved.z - wanted.z).abs() > 1e-7;
+        self.position = Vec3::new(
+            self.position.x + moved.x,
+            self.position.y + moved.y,
+            self.position.z + moved.z,
+        );
+        self.velocity = if horizontal {
+            Vec3::new(self.velocity.x, wanted.y, self.velocity.z)
+        } else {
+            wanted
+        };
+        blocked
     }
     /// Position and motion (the dispenser parity fixture).
     pub(super) fn motion(&self) -> (Vec3, Vec3) {
@@ -191,46 +236,14 @@ impl Game<'_> {
                     r.velocity = p.velocity;
                 }
             } else {
-                // Not shot at an angle: accelerate (unless blocked sideways) and rise.
                 let mut scene = SceneCollisions {
                     world: &self.world,
                     binding: self.collision,
                     subject: None,
                 };
-                let h = 0.125;
-                let bounds = Aabb::new(
-                    Vec3::new(r.position.x - h, r.position.y, r.position.z - h),
-                    Vec3::new(r.position.x + h, r.position.y + 2.0 * h, r.position.z + h),
-                );
-                let wanted = if r.angled {
-                    r.velocity
-                } else {
-                    Vec3::new(
-                        r.velocity.x * 1.15,
-                        r.velocity.y + 0.04,
-                        r.velocity.z * 1.15,
-                    )
-                };
-                if let Ok(moved) = scene.resolve(bounds, wanted, 0.0, false) {
-                    let blocked = (moved.x - wanted.x).abs() > 1e-7
-                        || (moved.y - wanted.y).abs() > 1e-7
-                        || (moved.z - wanted.z).abs() > 1e-7;
-                    if r.angled && blocked {
-                        // hitTargetOrDeflectSelf: explode on the block.
-                        r.life = r.lifetime;
-                    }
-                    let horizontal =
-                        (moved.x - wanted.x).abs() > 1e-7 || (moved.z - wanted.z).abs() > 1e-7;
-                    r.position = Vec3::new(
-                        r.position.x + moved.x,
-                        r.position.y + moved.y,
-                        r.position.z + moved.z,
-                    );
-                    r.velocity = if horizontal {
-                        Vec3::new(r.velocity.x, wanted.y, r.velocity.z)
-                    } else {
-                        wanted
-                    };
+                if r.free_flight(&mut scene) && r.angled {
+                    // hitTargetOrDeflectSelf: explode on the block.
+                    r.life = r.lifetime;
                 }
             }
             let at = [r.position.x, r.position.y, r.position.z];
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3cfbd15e3..1c86da46b 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -1406,6 +1406,13 @@ impl Game<'_> {
             {
                 return;
             }
+            // So does a firework rocket: its own tick flies it on.
+            if path.is_some()
+                && let Some(f) = self.rockets.iter_mut().find(|f| f.id == id as u32)
+            {
+                f.position = Vec3::new(position[0], position[1], position[2]);
+                return;
+            }
             // A dragon fireball keeps Entity's NO_OP InterpolationHandler too:
             // the server's position replaces its own at once.
             if let Some(b) = self.dragon_fireballs.iter_mut().find(|b| b.id == id as u32) {
@@ -3016,6 +3023,8 @@ impl Game<'_> {
             p.velocity = v;
         } else if let Some(b) = self.dragon_fireballs.iter_mut().find(|b| b.id == id as u32) {
             b.velocity = v;
+        } else if let Some(r) = self.rockets.iter_mut().find(|r| r.id == id as u32) {
+            r.velocity = v;
         } else if let Some(p) = self
             .remote
             .as_mut()
diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs
index b12cb4cd6..1dc9da095 100644
--- a/crates/horizon-client/src/game/remote_projectiles.rs
+++ b/crates/horizon-client/src/game/remote_projectiles.rs
@@ -3,8 +3,11 @@
 //! and `handleSetEntityData`): the server simulates them, the client draws
 //! them where it says and interpolates their moves.
 use super::{FallStep, FallingBlock, Game, fireworks::fireworks_of, view_vector};
-use horizon_client::particles::{ParticleOptions, ParticleType};
 use horizon_client::projectiles::{Hit, Projectile, ProjectileKind, ProjectileWorld};
+use horizon_client::{
+    collisions::SceneCollisions,
+    particles::{ParticleOptions, ParticleType},
+};
 use horizon_core::{geometry::Vec3, position::BlockPos, random::RandomSource};
 use horizon_protocol::entity_data::Value;
 use horizon_world::registry::BlockStateId;
@@ -361,9 +364,13 @@ impl Game<'_> {
             .remote
             .as_ref()
             .and_then(|r| u32::try_from(r.entity_id).ok());
-        for r in &mut self.rockets {
-            let id = r.id;
-            r.remote_step(|at| step(id, at));
+        let mut rockets = std::mem::take(&mut self.rockets);
+        for r in &mut rockets {
+            r.remote_step(&mut SceneCollisions {
+                world: &self.world,
+                binding: self.collision,
+                subject: None,
+            });
             if let Some(target) = r.attached_to {
                 if me == Some(target) {
                     if let Some(p) = self.player.as_mut() {
@@ -401,6 +408,7 @@ impl Game<'_> {
                 v,
             );
         }
+        self.rockets = rockets;
         for c in &mut self.crystals {
             c.time += 1;
             c.position = step(c.id, c.position);

From a45c73bb36609301725aafb7fa66ae7a57387d3c Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:12:49 +0100
Subject: [PATCH 190/475] Credit the player who kills the ender dragon

---
 crates/horizon-client/src/game/dragon.rs | 80 ++++++++++++++++++++++--
 1 file changed, 76 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index fff03ef1c..b2f04d77c 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -262,6 +262,9 @@ pub(super) struct Dragon {
     /// only damage above the last hit lands, and only the excess.
     invulnerable: i32,
     last_hurt: f32,
+    /// `lastHurtByPlayer` with its 100 tick memory: the player credited with
+    /// the kill, and the dragon tick of their last hit.
+    hurt_by_player: Option<(FightWho, i32)>,
     pub death_time: i32,
     pub flap: f32,
     pub old_flap: f32,
@@ -385,6 +388,7 @@ impl Dragon {
             hurt_time: 0,
             invulnerable: 0,
             last_hurt: 0.0,
+            hurt_by_player: None,
             death_time: 0,
             flap: 0.0,
             old_flap: 0.0,
@@ -426,6 +430,10 @@ impl Dragon {
     pub fn alive(&self) -> bool {
         self.health > 0.0
     }
+    /// `isDeadOrDying` for the killing blow: the dying flight, or no health.
+    fn down(&self) -> bool {
+        matches!(self.phase, Phase::Dying { .. }) || !self.alive()
+    }
     fn part_box(&self, i: usize) -> Aabb {
         let (w, h) = PART_SIZES[i];
         let p = self.parts[i].0;
@@ -903,7 +911,7 @@ impl Game<'_> {
         if let Some(d) = self.dragon.as_mut() {
             if d.nearest_crystal == Some(index) {
                 d.nearest_crystal = None;
-                self.hurt_dragon(0, 10.0, true, false);
+                self.hurt_dragon(0, 10.0, true, by, false);
             } else if let Some(n) = d.nearest_crystal.as_mut()
                 && *n > index
             {
@@ -975,17 +983,40 @@ impl Game<'_> {
             self.destroy_crystal(index, by, CrystalDamage::Direct);
             Hurt::Landed { full: true }
         } else if id >= SPECIAL {
-            self.hurt_dragon((id - SPECIAL) as usize, amount, by_player, arrow)
+            let by = by_player.then(|| self.acting_player());
+            self.hurt_dragon((id - SPECIAL) as usize, amount, by_player, by, arrow)
         } else {
             Hurt::Refused
         }
     }
     /// `EnderDragon.hurt(part, source, damage)` on the dragon in the level.
-    fn hurt_dragon(&mut self, part: usize, damage: f32, counts: bool, arrow: bool) -> Hurt {
+    /// `by` is the player behind the hit, remembered for the kill credit.
+    fn hurt_dragon(
+        &mut self,
+        part: usize,
+        damage: f32,
+        counts: bool,
+        by: Option<FightWho>,
+        arrow: bool,
+    ) -> Hurt {
         let Some(d) = self.dragon.as_mut() else {
             return Hurt::Refused;
         };
+        let was_down = d.down();
         let hurt = d.hurt(part, damage, counts, arrow);
+        // LivingEntity.hurtServer: a player's hit sets lastHurtByPlayer (100 ticks).
+        if counts
+            && matches!(hurt, Hurt::Landed { .. })
+            && let Some(who) = by
+        {
+            d.hurt_by_player = Some((who, d.ticks));
+        }
+        if !was_down && d.down() {
+            self.credit_dragon_kill();
+        }
+        let Some(d) = self.dragon.as_ref() else {
+            return hurt;
+        };
         if hurt == (Hurt::Landed { full: true }) {
             let at = [d.position.x, d.position.y, d.position.z];
             let pitch = 0.8 + self.world.random.next_float() * 0.3;
@@ -994,6 +1025,47 @@ impl Game<'_> {
         }
         hurt
     }
+    /// `LivingEntity.die`: `getKillCredit().awardKillScore`, for the player
+    /// who hurt the dragon within the last 100 ticks. A guest's kill is
+    /// theirs: their statistics, scores and advancements.
+    fn credit_dragon_kill(&mut self) {
+        let Some(d) = self.dragon.as_ref() else {
+            return;
+        };
+        let Some((who, _)) = d.hurt_by_player.filter(|(_, hit)| d.ticks - hit <= 100) else {
+            return;
+        };
+        let view = horizon_client::advancements::EntityView {
+            kind: "minecraft:ender_dragon".to_owned(),
+            position: [d.position.x, d.position.y, d.position.z],
+            ..Default::default()
+        };
+        let id = d.id;
+        let guest = match who {
+            FightWho::Guest(conn) if self.lan_acting.is_none() => Some(conn),
+            _ => None,
+        };
+        let credited = guest.is_some_and(|conn| {
+            let Some(mut host) = self.lan.take() else {
+                return false;
+            };
+            let done = self
+                .as_guest(&mut host, conn, |g| g.award_dragon_kill(id, &view))
+                .is_some();
+            self.lan = Some(host);
+            done
+        });
+        if !credited {
+            self.award_dragon_kill(id, &view);
+        }
+    }
+    /// `ServerPlayer.awardKillScore` for the dragon, on the killer's state.
+    fn award_dragon_kill(&mut self, id: u32, view: &horizon_client::advancements::EntityView) {
+        self.stats.add("killed", "minecraft:ender_dragon", 1);
+        self.stats.custom("mob_kills", 1);
+        self.score_player_killed(super::commands::Target::Mob(id));
+        self.trigger_entity("minecraft:player_killed_entity", "entity", view);
+    }
     /// Player melee on the dragon's parts or a crystal under the crosshair.
     /// The dragon part under the crosshair within reach: its id and distance.
     pub(super) fn dragon_hit(&self) -> Option<(u32, f64)> {
@@ -2716,7 +2788,7 @@ impl Game<'_> {
             self.seen_percent(center, [lo.x, lo.y, lo.z], [hi.x, hi.y, hi.z])
         });
         for (part, amount) in hits {
-            self.hurt_dragon(part, amount, true, false);
+            self.hurt_dragon(part, amount, true, None, false);
         }
     }
 }

From e6587dce6a005413b2617d281826dde4ca6663f0 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:17:05 +0100
Subject: [PATCH 191/475] Respawn at once without a death screen when
 immediate_respawn is on

---
 crates/horizon-client/src/game.rs         | 11 ++-
 crates/horizon-client/src/game/lan.rs     |  2 +
 crates/horizon-client/src/game/remote.rs  | 29 ++++++--
 crates/horizon-client/src/game/screens.rs | 86 ++++++++++++-----------
 crates/horizon-client/src/lan/hub.rs      | 17 ++++-
 5 files changed, 95 insertions(+), 50 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 8448f0837..2d0efc34d 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4614,9 +4614,14 @@ impl Game<'_> {
             if let Some(host) = &self.lan {
                 host.hub.entity_event(host.host_entity, 3, feet);
             }
-            self.screen = Screen::Dead;
-            self.capture(false);
-            self.ui.death_time = 0;
+            if self.ui.rules.bool("immediate_respawn") {
+                // Gui.setScreen: without the death screen the player respawns at once.
+                self.respawn_player()?;
+            } else {
+                self.screen = Screen::Dead;
+                self.capture(false);
+                self.ui.death_time = 0;
+            }
         } else if dead {
             // LivingEntity.tickDeath: 20 ticks after dying the player is
             // removed, and Player.remove's inventoryMenu.removed drops what
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..9b52cc46e 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -974,6 +974,8 @@ impl Game<'_> {
                     self.ui.rules.bool("player_movement_check"),
                     self.ui.rules.bool("elytra_movement_check"),
                 );
+                host.hub
+                    .set_immediate_respawn(self.ui.rules.bool("immediate_respawn"));
                 // A server with several levels runs a pass for each
                 // (`tick_server`): the network is read once, before the first.
                 let pass = self.level_pass;
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3cfbd15e3..1a684cb75 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -192,6 +192,8 @@ pub(super) struct Remote {
     stop_mining: bool,
     placing: Option<([i32; 3], u64)>,
     death_message: Option<String>,
+    /// `LocalPlayer.showDeathScreen`: off with `immediate_respawn`.
+    show_death_screen: bool,
     player_type: Option<Arc<MobType>>,
     /// Inventory as last synchronised, for creative-mode slot updates.
     synced: Vec<Option<ItemStack>>,
@@ -476,6 +478,7 @@ impl Game<'_> {
             stop_mining: false,
             placing: None,
             death_message: None,
+            show_death_screen: true,
             player_type,
             synced: vec![None; 36],
             decode_errors: 0,
@@ -1623,6 +1626,7 @@ impl Game<'_> {
                     r.online_mode = p.online_mode;
                     r.entity_id = p.player_id;
                     r.view_distance = p.chunk_radius;
+                    r.show_death_screen = p.show_death_screen;
                 }
                 self.streaming.radius =
                     self.settings.render_distance.min(p.chunk_radius + 1).max(2);
@@ -2182,7 +2186,11 @@ impl Game<'_> {
                     pl.health.flash_health_change(p.health);
                 }
                 self.apply_remote_health();
-                if p.health <= 0.0 && self.screen != Screen::Dead && self.player.is_some() {
+                // The death screen opens (or the respawn is asked for) with the
+                // death packet when the rule hides it.
+                let shown = self.remote.as_ref().is_none_or(|r| r.show_death_screen);
+                if p.health <= 0.0 && shown && self.screen != Screen::Dead && self.player.is_some()
+                {
                     self.screen = Screen::Dead;
                     self.ui.death_time = 0;
                     self.capture(false);
@@ -2198,11 +2206,16 @@ impl Game<'_> {
                     r.death_message = Some(message);
                 }
                 // ClientPacketListener.handlePlayerCombatKill: the death
-                // screen, whatever health was last sent.
+                // screen, whatever health was last sent, or `respawn()` at
+                // once when it is hidden.
                 if me && self.screen != Screen::Dead && self.player.is_some() {
-                    self.screen = Screen::Dead;
-                    self.ui.death_time = 0;
-                    self.capture(false);
+                    if self.remote.as_ref().is_none_or(|r| r.show_death_screen) {
+                        self.screen = Screen::Dead;
+                        self.ui.death_time = 0;
+                        self.capture(false);
+                    } else {
+                        self.respawn_player()?;
+                    }
                 }
             }
             C::TrackedWaypoint(p) => self.handle_waypoint(&p),
@@ -2278,6 +2291,12 @@ impl Game<'_> {
                         r.game_mode = mode;
                     }
                 }
+                // IMMEDIATE_RESPAWN: LocalPlayer.setShowDeathScreen.
+                11 => {
+                    if let Some(r) = self.remote.as_mut() {
+                        r.show_death_screen = p.param == 0.0;
+                    }
+                }
                 7 => {
                     self.world.weather.rain_level = (p.param, p.param);
                     self.world.weather.raining = p.param > 0.0;
diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs
index f8885f83a..3a2c3deda 100644
--- a/crates/horizon-client/src/game/screens.rs
+++ b/crates/horizon-client/src/game/screens.rs
@@ -286,6 +286,50 @@ impl Game<'_> {
             );
         }
     }
+    /// LocalPlayer.respawn: the player comes back (the death screen's
+    /// button, or at once with `immediate_respawn`).
+    pub(super) fn respawn_player(&mut self) -> Result<()> {
+        if self.remote.is_none() {
+            let keep = self.ui.rules.bool("keep_inventory") || self.spectator();
+            self.experience.respawn(keep);
+            // The guests are sent the respawned host as a new entity, not the dead body.
+            if let Some(host) = self.lan.as_mut() {
+                let id = host.host_entity;
+                host.hub.respawned(id);
+            }
+            // Autosaves keep a login position; death must resolve the respawn point instead.
+            self.level.position = None;
+        }
+        if self.remote.is_some() {
+            self.ui.death_text = None;
+            self.toggles.respawn();
+            self.remote_respawn();
+        } else if self.respawn_config.is_some() {
+            // LocalPlayer.respawn: KeyMapping.resetToggleKeys.
+            self.toggles.respawn();
+            // PlayerList.respawn at the respawn anchor, once it is loaded.
+            self.begin_anchor_respawn()?;
+            self.screen = Screen::Playing;
+            self.ui.death_text = None;
+            self.spawn_player()?;
+            self.capture(true);
+        } else {
+            // LocalPlayer.respawn: KeyMapping.resetToggleKeys.
+            self.toggles.respawn();
+            self.respawn_out_of_end()?;
+            self.player = None;
+            self.screen = Screen::Playing;
+            self.ui.death_text = None;
+            self.spawn_player()?;
+            self.capture(true);
+        }
+        // ServerGamePacketListenerImpl.handleClientCommand: a hardcore world's
+        // respawned player only watches.
+        if self.remote.is_none() && self.level.hardcore {
+            self.set_mode(GameMode::Spectator);
+        }
+        Ok(())
+    }
     pub(super) fn death_click(&mut self) -> Result<()> {
         if self
             .ui
@@ -303,51 +347,11 @@ impl Game<'_> {
             .into_iter()
             .find(|d| ui::hovered(self.cursor, d.0, d.1, 200.0, 20.0))
             .map(|d| d.3);
-        if hit == Some(0) && self.remote.is_none() {
-            let keep = self.ui.rules.bool("keep_inventory") || self.spectator();
-            self.experience.respawn(keep);
-            // The guests are sent the respawned host as a new entity, not the dead body.
-            if let Some(host) = self.lan.as_mut() {
-                let id = host.host_entity;
-                host.hub.respawned(id);
-            }
-            // Autosaves keep a login position; death must resolve the respawn point instead.
-            self.level.position = None;
-        }
         match hit {
-            Some(0) if self.remote.is_some() => {
-                self.ui.death_text = None;
-                self.toggles.respawn();
-                self.remote_respawn();
-            }
-            Some(0) if self.respawn_config.is_some() => {
-                // LocalPlayer.respawn: KeyMapping.resetToggleKeys.
-                self.toggles.respawn();
-                // PlayerList.respawn at the respawn anchor, once it is loaded.
-                self.begin_anchor_respawn()?;
-                self.screen = Screen::Playing;
-                self.ui.death_text = None;
-                self.spawn_player()?;
-                self.capture(true);
-            }
-            Some(0) => {
-                // LocalPlayer.respawn: KeyMapping.resetToggleKeys.
-                self.toggles.respawn();
-                self.respawn_out_of_end()?;
-                self.player = None;
-                self.screen = Screen::Playing;
-                self.ui.death_text = None;
-                self.spawn_player()?;
-                self.capture(true);
-            }
+            Some(0) => self.respawn_player()?,
             Some(1) => self.close_world()?,
             _ => {}
         }
-        // ServerGamePacketListenerImpl.handleClientCommand: a hardcore world's
-        // respawned player only watches.
-        if hit == Some(0) && self.remote.is_none() && self.level.hardcore {
-            self.set_mode(GameMode::Spectator);
-        }
         if hit.is_some() {
             self.audio.play_button_click();
         }
diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs
index b1a8cbc62..8c60dc75f 100644
--- a/crates/horizon-client/src/lan/hub.rs
+++ b/crates/horizon-client/src/lan/hub.rs
@@ -43,6 +43,7 @@ pub mod game_event {
     pub const RAIN_LEVEL: u8 = 7;
     pub const THUNDER_LEVEL: u8 = 8;
     pub const GUARDIAN_ELDER_EFFECT: u8 = 10;
+    pub const IMMEDIATE_RESPAWN: u8 = 11;
     pub const LEVEL_CHUNKS_LOAD_START: u8 = 13;
 }
 
@@ -149,6 +150,8 @@ pub struct Hub {
     /// The `player_movement_check` and `elytra_movement_check` game rules,
     /// set by the game before each tick.
     pub movement_checks: (bool, bool),
+    /// The `immediate_respawn` game rule, as the players were last told.
+    immediate_respawn: bool,
     /// An integrated server's owner (`MinecraftServer.isSingleplayerOwner`),
     /// whose moves are never checked.
     pub singleplayer_owner: Option<u128>,
@@ -324,6 +327,7 @@ impl Hub {
             guests: Vec::new(),
             sync,
             ticks: 0,
+            immediate_respawn: false,
             movement_checks: (true, true),
             singleplayer_owner: None,
             riding: Default::default(),
@@ -399,6 +403,17 @@ impl Hub {
             g.sender.send(body.clone());
         }
     }
+    /// MinecraftServer.onGameRuleChanged: every player is told when
+    /// `immediate_respawn` changes; a joining player's Login carries it.
+    pub fn set_immediate_respawn(&mut self, on: bool) {
+        if self.immediate_respawn != on {
+            self.immediate_respawn = on;
+            self.broadcast(&C::GameEvent(play::GameEvent {
+                event: game_event::IMMEDIATE_RESPAWN,
+                param: if on { 1.0 } else { 0.0 },
+            }));
+        }
+    }
     /// PlayerList.setViewDistance: every player is told the new radius,
     /// and each one's chunks follow it, up to what they asked for
     /// (ChunkMap.getPlayerViewDistance).
@@ -633,7 +648,7 @@ impl Hub {
             chunk_radius: self.config.view_distance,
             simulation_distance: self.config.simulation_distance,
             reduced_debug_info: false,
-            show_death_screen: true,
+            show_death_screen: !self.immediate_respawn,
             limited_crafting: false,
             spawn: self.spawn_info(mode),
             // MinecraftServer.usesAuthentication, enforceSecureProfile.

From 5d7097877bccd89bd0e448b875706ec8006ecdbf Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 19:19:30 +0100
Subject: [PATCH 192/475] game: station tabs on the recipe pages

A row of tabs above the recipe pages shows `set-recipes`' stations (their
item in a slot, a white frame on the selected one). A click sends `tab(i)`
to the mod, R/U over a tab works like over any slot, and horizon-ctl lists
them as "<name> tab". Changing tab resets the page.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/mod_browser.rs |  12 +-
 .../src/game/mod_browser_recipes.rs           | 116 ++++++++++++++++--
 2 files changed, 115 insertions(+), 13 deletions(-)

diff --git a/crates/horizon-client/src/game/mod_browser.rs b/crates/horizon-client/src/game/mod_browser.rs
index 3121eb05b..645415ccb 100644
--- a/crates/horizon-client/src/game/mod_browser.rs
+++ b/crates/horizon-client/src/game/mod_browser.rs
@@ -127,10 +127,11 @@ impl Game<'_> {
             self.mods.browser.stacks = stacks;
             // The same title again (the mod updating its buttons) keeps the page.
             let old = self.mods.browser.recipes.take();
-            self.mods.browser.recipes =
-                self.mods.mods.browser_recipes(owner).map(|(title, list)| {
-                    super::mod_browser_recipes::Pages::new(items, title, list, old)
-                });
+            self.mods.browser.recipes = self
+                .mods
+                .mods
+                .browser_recipes(owner)
+                .map(|shown| super::mod_browser_recipes::Pages::new(items, shown, old));
             self.mods.browser.of = Some((owner, version));
         }
         Some(owner)
@@ -171,6 +172,9 @@ impl Game<'_> {
     /// as the mod sent it and as a stack.
     fn browser_pointed_stack(&self, layout: &Layout) -> Option<(BrowserStack, ItemStack)> {
         if self.mods.browser.recipes.is_some() {
+            if let Some((_, sent, stack)) = self.recipe_tab_hovered(layout) {
+                return Some((sent, stack));
+            }
             let (_, _, sent, stack) = self.recipe_slot_hovered(layout)?;
             return Some((sent, stack));
         }
diff --git a/crates/horizon-client/src/game/mod_browser_recipes.rs b/crates/horizon-client/src/game/mod_browser_recipes.rs
index 14848de90..13b3b78e1 100644
--- a/crates/horizon-client/src/game/mod_browser_recipes.rs
+++ b/crates/horizon-client/src/game/mod_browser_recipes.rs
@@ -11,12 +11,14 @@ use horizon_client::{
     hud::{HudBatch, rgba},
     items::ItemStack,
 };
-use horizon_mods::{BrowserEvent, BrowserLayout, BrowserRecipe, BrowserSlotClick, BrowserStack};
+use horizon_mods::{BrowserEvent, BrowserLayout, BrowserSlotClick, BrowserStack, RecipePage};
 use std::time::Instant;
 
 const SLOT: f32 = 18.0;
 /// The title row's height, and the gap under each recipe.
 const TITLE: f32 = 18.0;
+/// A tab's step: an 18 px slot and a gap.
+const TAB: f32 = 20.0;
 const GAP: f32 = 6.0;
 
 /// One recipe as the game draws it.
@@ -34,6 +36,9 @@ pub(super) struct Shown {
 /// The recipes a panel shows, and its page.
 pub(super) struct Pages {
     title: String,
+    /// The tabs' icons and the selected one.
+    tabs: Vec<(BrowserStack, Option<ItemStack>)>,
+    tab: usize,
     recipes: Vec<Shown>,
     page: usize,
     since: Instant,
@@ -42,11 +47,11 @@ pub(super) struct Pages {
 impl Pages {
     pub(super) fn new(
         items: &horizon_client::items::Items,
-        title: &str,
-        list: &[BrowserRecipe],
+        shown: &RecipePage,
         old: Option<Pages>,
     ) -> Self {
-        let kept = old.filter(|o| o.title == title);
+        let (title, list, tab) = (&shown.title, &shown.recipes, shown.tab as usize);
+        let kept = old.filter(|o| o.title == *title && o.tab == tab);
         let cycle = |stacks: &[BrowserStack]| -> Vec<(BrowserStack, ItemStack)> {
             stacks
                 .iter()
@@ -69,7 +74,13 @@ impl Pages {
             })
             .collect();
         Self {
-            title: title.to_owned(),
+            title: title.clone(),
+            tabs: shown
+                .tabs
+                .iter()
+                .map(|t| (t.clone(), browser_stack(items, t)))
+                .collect(),
+            tab,
             recipes,
             page: kept.as_ref().map_or(0, |o| o.page),
             since: kept.map_or_else(Instant::now, |o| o.since),
@@ -131,11 +142,30 @@ impl Shown {
     }
 }
 
+/// The tabs' places, in rows under the title row.
+fn tab_places(pages: &Pages, layout: &Layout) -> Vec<(f32, f32)> {
+    let per_row = ((layout.width() / TAB).floor() as usize).max(1);
+    (0..pages.tabs.len())
+        .map(|i| {
+            (
+                layout.grid.0 + (i % per_row) as f32 * TAB,
+                layout.grid.1 + TITLE + 3.0 + (i / per_row) as f32 * TAB,
+            )
+        })
+        .collect()
+}
+/// Where the recipes start: under the title row and the tabs.
+fn recipes_top(pages: &Pages, layout: &Layout) -> f32 {
+    let tabs = tab_places(pages, layout);
+    tabs.last()
+        .map_or(layout.grid.1 + TITLE, |&(_, y)| y + TAB + 3.0)
+}
+
 impl Game<'_> {
-    /// The first recipe of each page, filling the panel from the title row
-    /// to the search box.
+    /// The first recipe of each page, filling the panel from the tabs to
+    /// the search box.
     fn recipe_pages(pages: &Pages, layout: &Layout) -> Vec<usize> {
-        let room = layout.search[1] - 4.0 - (layout.grid.1 + TITLE);
+        let room = layout.search[1] - 4.0 - recipes_top(pages, layout);
         let mut starts = vec![0];
         let mut used = 0.0;
         for (i, r) in pages.recipes.iter().enumerate() {
@@ -156,7 +186,7 @@ impl Game<'_> {
         let starts = Self::recipe_pages(pages, layout);
         let page = pages.page.min(starts.len() - 1);
         let end = starts.get(page + 1).copied().unwrap_or(pages.recipes.len());
-        let mut y = layout.grid.1 + TITLE;
+        let mut y = recipes_top(pages, layout);
         (starts[page]..end)
             .map(|i| {
                 let at = (layout.grid.0, y);
@@ -177,6 +207,21 @@ impl Game<'_> {
         let n = pages.since.elapsed().as_secs() as usize;
         stacks.get(n % stacks.len().max(1))
     }
+    /// The tab under the pointer: its index and icon.
+    pub(super) fn recipe_tab_hovered(
+        &self,
+        layout: &Layout,
+    ) -> Option<(usize, BrowserStack, ItemStack)> {
+        let pages = self.mods.browser.recipes.as_ref()?;
+        let places = tab_places(pages, layout);
+        places.iter().enumerate().find_map(|(i, &(x, y))| {
+            if !inside(self.cursor, [x, y, SLOT, SLOT]) {
+                return None;
+            }
+            let (sent, stack) = pages.tabs.get(i)?;
+            Some((i, sent.clone(), stack.clone()?))
+        })
+    }
     /// The recipe slot under the pointer: recipe, slot, and its stack now.
     pub(super) fn recipe_slot_hovered(
         &self,
@@ -237,6 +282,7 @@ impl Game<'_> {
             u32::MAX,
             true,
         );
+        self.draw_recipe_tabs(batch, layout);
         if pages_n > 1 {
             let labels = [
                 self.translate("gui.recipebook.previous_page", "Previous Page"),
@@ -351,6 +397,50 @@ impl Game<'_> {
         }
     }
 
+    /// The tabs, on slots; the selected one framed.
+    fn draw_recipe_tabs(&mut self, batch: &mut HudBatch, layout: &Layout) {
+        let Some(pages) = &self.mods.browser.recipes else {
+            return;
+        };
+        let places = tab_places(pages, layout);
+        let tabs: Vec<Option<ItemStack>> = pages.tabs.iter().map(|t| t.1.clone()).collect();
+        let selected = pages.tab;
+        for (i, (&(x, y), stack)) in places.iter().zip(tabs).enumerate() {
+            let atlas = &self.gui.atlas;
+            batch.sprite(atlas, "gui/sprites/container/slot", x, y);
+            let Some(stack) = stack else {
+                continue;
+            };
+            self.draw_item(batch, &stack, x + 1.0, y + 1.0);
+            // The selected tab: a white frame around its slot.
+            if i == selected {
+                let white = rgba(255, 255, 255, 255);
+                let atlas = &self.gui.atlas;
+                batch.fill(atlas, x - 1.0, y - 1.0, SLOT + 2.0, 1.0, white);
+                batch.fill(atlas, x - 1.0, y + SLOT, SLOT + 2.0, 1.0, white);
+                batch.fill(atlas, x - 1.0, y, 1.0, SLOT, white);
+                batch.fill(atlas, x + SLOT, y, 1.0, SLOT, white);
+            }
+            if inside(self.cursor, [x, y, SLOT, SLOT]) {
+                batch.fill(
+                    &self.gui.atlas,
+                    x + 1.0,
+                    y + 1.0,
+                    16.0,
+                    16.0,
+                    rgba(255, 255, 255, 128),
+                );
+            }
+            let name = self.pack.names.display_item(&stack.item);
+            horizon_client::widgets::record_as(
+                &format!("{name} tab"),
+                [x + 1.0, y + 1.0, 16.0, 16.0],
+                true,
+                horizon_client::widgets::Kind::Tab(i == selected),
+            );
+        }
+    }
+
     /// A press on the recipes: true when it hit one of their parts.
     pub(super) fn browser_recipes_press(
         &mut self,
@@ -383,6 +473,14 @@ impl Game<'_> {
                 .browser_event(owner, BrowserEvent::Page(starts[to] as u32));
             return true;
         }
+        if let Some((tab, _, _)) = self.recipe_tab_hovered(layout) {
+            self.audio
+                .play("minecraft:ui.button.click", None, 0.25, 1.0);
+            self.mods
+                .mods
+                .browser_event(owner, BrowserEvent::Tab(tab as u32));
+            return true;
+        }
         if inside(cursor, self.back_button(layout).0) {
             self.audio
                 .play("minecraft:ui.button.click", None, 0.25, 1.0);

From 0c127ec1d9285a225d0cee0f29755b8f8fcaff8b Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:23:34 +0100
Subject: [PATCH 193/475] Stub breaking_block_effects in the remote mining test
 fixture

---
 tests/test_remote_mining.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/test_remote_mining.py b/tests/test_remote_mining.py
index 9feb255fa..4c77f989d 100644
--- a/tests/test_remote_mining.py
+++ b/tests/test_remote_mining.py
@@ -90,6 +90,7 @@ impl Game {
     fn predict_break(&mut self, pos: [i32; 3], _: u32, _: i32) { self.world.broken.push(pos); }
     fn send(&mut self, S::PlayerAction(packet): S) { self.packets.push(packet); }
     fn crack_particle(&mut self, _: [i32; 3], _: u8, _: u32) {}
+    fn breaking_block_effects(&mut self, _: [i32; 3], _: u8, _: bool) {}
 METHOD
 }
 fn main() {

From 484cc945aa0b4c9cf558da2262169e8ae09642fb Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:23:52 +0100
Subject: [PATCH 194/475] Add the rockets list to the remote motion test
 fixture

---
 tests/test_remote_motion.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/test_remote_motion.py b/tests/test_remote_motion.py
index b00e5f0a9..59526b476 100644
--- a/tests/test_remote_motion.py
+++ b/tests/test_remote_motion.py
@@ -35,7 +35,8 @@ impl End { fn remote_eye_motion(&mut self, _id: u32, _v: [f64; 3]) {} }
 #[derive(Default)]
 struct Game {
     mobs: Vec<Entity>, dropped: Vec<Entity>, falling: Vec<Entity>, tnts: Vec<Entity>,
-    creatures: Creatures, dragon_fireballs: Vec<Entity>, remote: Option<Remote>,
+    creatures: Creatures, dragon_fireballs: Vec<Entity>, rockets: Vec<Entity>,
+    remote: Option<Remote>,
     potions: Potions, end: End,
 }
 impl Game {

From 705e3d10cf00e1fd4e504c6a974432531f5f983a Mon Sep 17 00:00:00 2001
From: FusselTV <github@fussel.tv>
Date: Mon, 26 Oct 2026 14:11:07 +0100
Subject: [PATCH 195/475] Force-loaded chunks decorate in vanilla's order

Chunks no player ticket reached were decorated nearest the centre first.
Vanilla's ForceLoadCommand adds a FORCED ticket per chunk, x-outer and
z-inner, and the FULL tasks run in that order, so a chunk decorates
before its neighbour at higher x or z. Both orders agree only in the +x,
+z quarter of the map. Elsewhere features crossing chunk borders
overwrote each other the other way round: a geode next door ate a trial
chamber's dispensers, sculk or a clay pool closed a dungeon so it was
never placed, and ore, stone and tree blobs swapped.

The forceload command now ranks the chunks it adds in vanilla's order
(decoration_order::forced_order, which shares its scheduler with
vanilla_order); chunks without a rank still go last, nearest first.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/game/commands/pregen.rs               |  6 +-
 .../src/game/commands/terrain_cmds.rs         |  3 +
 crates/horizon-client/src/game/levels.rs      |  3 +-
 crates/horizon-client/src/streaming.rs        |  8 +++
 .../src/worldgen/decoration_order.rs          | 67 +++++++++++++++----
 5 files changed, 71 insertions(+), 16 deletions(-)

diff --git a/crates/horizon-client/src/game/commands/pregen.rs b/crates/horizon-client/src/game/commands/pregen.rs
index d497e2734..eb3c37688 100644
--- a/crates/horizon-client/src/game/commands/pregen.rs
+++ b/crates/horizon-client/src/game/commands/pregen.rs
@@ -244,7 +244,11 @@ impl Game<'_> {
     /// hand them the next jobs as soon as each one is done, rather than once
     /// a tick.
     pub(in crate::game) fn pump_pregen(&mut self, until: Instant) {
-        while self.pregen_runs_here() {
+        // Force-loaded chunks too: decorating in vanilla's order, a chunk
+        // waits for its neighbours far more often than once a tick allows.
+        while self.pregen_runs_here()
+            || (!self.streaming.forced.is_empty() && self.streaming.busy())
+        {
             let now = Instant::now();
             if now >= until {
                 break;
diff --git a/crates/horizon-client/src/game/commands/terrain_cmds.rs b/crates/horizon-client/src/game/commands/terrain_cmds.rs
index d4b1c125c..824ca4d60 100644
--- a/crates/horizon-client/src/game/commands/terrain_cmds.rs
+++ b/crates/horizon-client/src/game/commands/terrain_cmds.rs
@@ -120,6 +120,9 @@ impl Game<'_> {
                         tracker.track(&holder(chunk_text(x, z)), i32::from(changed));
                     }
                 }
+                if add {
+                    self.streaming.rank_forced(cx0, cz0, cx1, cz1);
+                }
                 let (lo, hi) = (chunk_text(cx0, cz0), chunk_text(cx1, cz1));
                 let verb = if add { "added" } else { "removed" };
                 let (message, total) = tracker.message(
diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs
index 8d2e0a4a2..8ba18ac22 100644
--- a/crates/horizon-client/src/game/levels.rs
+++ b/crates/horizon-client/src/game/levels.rs
@@ -383,7 +383,8 @@ impl Game<'_> {
         }
         *next += self.clock.tick_duration();
         if *next > now {
-            // A `/pregen` task keeps the workers fed until the next tick.
+            // A `/pregen` task or force-loaded chunks keep the workers fed
+            // until the next tick.
             self.pump_pregen(*next);
             let now = Instant::now();
             if *next > now {
diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs
index 643a604bc..bc43d1c94 100644
--- a/crates/horizon-client/src/streaming.rs
+++ b/crates/horizon-client/src/streaming.rs
@@ -1381,6 +1381,14 @@ impl Streaming {
     pub fn band(&self) -> Option<Band> {
         self.band
     }
+    /// Rank the chunks `/forceload add` over chunks `(x0, z0)..=(x1, z1)`
+    /// decorates in vanilla's order (`forced_order`), after every chunk
+    /// ranked before.
+    pub fn rank_forced(&mut self, x0: i32, z0: i32, x1: i32, z1: i32) {
+        for (x, z) in horizon_world::worldgen::decoration_order::forced_order(x0, z0, x1, z1) {
+            self.decoration_order.rank_or_append(x, z);
+        }
+    }
     /// Generate, light and keep the chunks of `band` (none: stop), and let
     /// go of what earlier bands held as it falls out of range. The chunks a
     /// band reaches are ranked for decoration row by row, as they first come
diff --git a/crates/horizon-world/src/worldgen/decoration_order.rs b/crates/horizon-world/src/worldgen/decoration_order.rs
index 6b0fb2252..0e53e7d09 100644
--- a/crates/horizon-world/src/worldgen/decoration_order.rs
+++ b/crates/horizon-world/src/worldgen/decoration_order.rs
@@ -29,7 +29,7 @@
 //! overlap), so a chunk may be decorated as soon as no lower-ranked chunk
 //! within two of it is still waiting: [`DecorationOrder::blocked`]. Chunks
 //! further apart still decorate in parallel.
-use std::collections::HashMap;
+use std::collections::{HashMap, VecDeque};
 
 #[derive(Default)]
 pub struct DecorationOrder {
@@ -121,7 +121,6 @@ fn ticket_hash(x: i32, z: i32) -> u64 {
 /// The chunks decorated around a player at `center`, in vanilla's order.
 pub fn vanilla_order(center: (i32, i32), radius: i32) -> Vec<(i32, i32)> {
     use std::cmp::Reverse;
-    use std::collections::{BinaryHeap, VecDeque};
     let mut tickets: Vec<(i32, i32)> = (-radius..=radius)
         .flat_map(|dx| (-radius..=radius).map(move |dz| (center.0 + dx, center.1 + dz)))
         .collect();
@@ -132,16 +131,31 @@ pub fn vanilla_order(center: (i32, i32), radius: i32) -> Vec<(i32, i32)> {
             Reverse(ticket_hash(x, z) & (TICKET_SET_CAPACITY - 1)),
         )
     });
-    let mut tickets: VecDeque<_> = tickets.into();
     // Every chunk this touches lies within `half` of the centre: tickets
     // reach `LIGHT_LEVEL - TICKET_LEVEL` further, and FULL tasks decorate
-    // one more ring. Dense grids over that square replace hash maps.
+    // one more ring.
+    let half = radius.max(0) + LIGHT_LEVEL - TICKET_LEVEL + 1;
+    ticket_order(
+        tickets.into(),
+        TICKETS_IN_FLIGHT,
+        (center.0 - half, center.1 - half),
+        (2 * half + 1) as usize,
+    )
+}
+
+/// The decoration order of `tickets` (level 31) added in turn, at most
+/// `in_flight` at a time. Dense grids of `side` chunks from `origin` hold
+/// every chunk this touches, in place of hash maps.
+fn ticket_order(
+    mut tickets: VecDeque<(i32, i32)>,
+    in_flight: usize,
+    origin: (i32, i32),
+    side: usize,
+) -> Vec<(i32, i32)> {
+    use std::cmp::Reverse;
+    use std::collections::BinaryHeap;
     let reach = LIGHT_LEVEL - TICKET_LEVEL;
-    let half = radius.max(0) + reach + 1;
-    let side = (2 * half + 1) as usize;
-    let cell = |(x, z): (i32, i32)| {
-        ((x - center.0 + half) as usize) * side + (z - center.1 + half) as usize
-    };
+    let cell = |(x, z): (i32, i32)| ((x - origin.0) as usize) * side + (z - origin.1) as usize;
     let mut active: Vec<(i32, i32)> = Vec::new();
     // Queued task per chunk (level, sequence), `NONE` when there is none;
     // stale heap entries are skipped.
@@ -177,10 +191,9 @@ pub fn vanilla_order(center: (i32, i32), radius: i32) -> Vec<(i32, i32)> {
             }
         }
     };
-    for _ in 0..TICKETS_IN_FLIGHT {
-        if let Some(t) = tickets.pop_front() {
-            add(t, &mut active, &mut queued, &mut heap, &full);
-        }
+    while active.len() < in_flight {
+        let Some(t) = tickets.pop_front() else { break };
+        add(t, &mut active, &mut queued, &mut heap, &full);
     }
     while let Some(Reverse((l, s, chunk))) = heap.pop() {
         let i = cell(chunk);
@@ -202,7 +215,7 @@ pub fn vanilla_order(center: (i32, i32), radius: i32) -> Vec<(i32, i32)> {
             full[i] = true;
         }
         active.retain(|t| !(-2..=2).all(|dx| (-2..=2).all(|dz| full[cell((t.0 + dx, t.1 + dz))])));
-        while active.len() < TICKETS_IN_FLIGHT {
+        while active.len() < in_flight {
             let Some(t) = tickets.pop_front() else { break };
             add(t, &mut active, &mut queued, &mut heap, &full);
         }
@@ -210,10 +223,36 @@ pub fn vanilla_order(center: (i32, i32), radius: i32) -> Vec<(i32, i32)> {
     order
 }
 
+/// The chunks `/forceload add` over chunks `(x0, z0)..=(x1, z1)` decorates,
+/// in vanilla's order: ForceLoadCommand adds a FORCED ticket (level 31) per
+/// chunk, x-outer, z-inner, all at once.
+pub fn forced_order(x0: i32, z0: i32, x1: i32, z1: i32) -> Vec<(i32, i32)> {
+    let tickets = (x0..=x1)
+        .flat_map(|x| (z0..=z1).map(move |z| (x, z)))
+        .collect();
+    let pad = LIGHT_LEVEL - TICKET_LEVEL + 1;
+    let side = ((x1 - x0).max(z1 - z0) + 2 * pad + 1) as usize;
+    ticket_order(tickets, usize::MAX, (x0 - pad, z0 - pad), side)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    /// Seed 8675309's geodes in chunks (-26, -1) and (14, -20) run into the
+    /// trial chambers of (-26, 0) and (14, -19); vanilla decorates the lower
+    /// z first, wherever the batch lies, so the chambers are drawn over them.
+    #[test]
+    fn forced_chunks_decorate_x_outer_z_inner() {
+        let rank = |order: &[(i32, i32)], c| order.iter().position(|&o| o == c).unwrap();
+        let west = forced_order(-32, -16, -17, -1);
+        assert!(rank(&west, (-26, -1)) < rank(&west, (-26, 0)));
+        let east = forced_order(0, -32, 15, -17);
+        assert!(rank(&east, (14, -20)) < rank(&east, (14, -19)));
+        assert_eq!(west[0], (-33, -17));
+        assert_eq!(west.len(), 22 * 22);
+    }
+
     /// The hash map version this module had before its dense grids.
     fn hashed_order(center: (i32, i32), radius: i32) -> Vec<(i32, i32)> {
         use std::cmp::Reverse;

From 8c2ef15171d2bdfd31a07c83f5ea80df315068e1 Mon Sep 17 00:00:00 2001
From: FusselTV <github@fussel.tv>
Date: Mon, 26 Oct 2026 13:58:26 +0100
Subject: [PATCH 196/475] Falling suspicious sand and gravel break where they
 land

BrushableBlock.tick makes the falling block entity with disableDrop, so
vanilla breaks it on landing (onBrokenAfterFall: level event 2001 and
the block_destroy game event) and
places nothing. Horizon landed it as a plain block without its
archaeology block entity. Seen in pre-generated worlds: suspicious gravel
of cold ocean ruins that sits over water fell during the first ticks and
landed one block lower without its block entity, so with no loot.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/falling_block.rs    | 20 +++++++++++++++++++
 crates/horizon-client/src/game.rs             |  8 +++-----
 .../horizon-client/src/game/falling_damage.rs | 19 ++++++++++++++++++
 3 files changed, 42 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/falling_block.rs b/crates/horizon-client/src/falling_block.rs
index 79ca28f7a..4faf105b9 100644
--- a/crates/horizon-client/src/falling_block.rs
+++ b/crates/horizon-client/src/falling_block.rs
@@ -35,6 +35,18 @@ impl Damage {
             ..Self::default()
         }
     }
+    /// A block that starts to fall: anvils hurt, and a brushable block
+    /// breaks where it lands (BrushableBlock.tick: disableDrop).
+    pub fn falling(block: &str) -> Self {
+        if block.ends_with("anvil") {
+            Self::anvil()
+        } else {
+            Self {
+                cancel_drop: block.starts_with("minecraft:suspicious_"),
+                ..Self::default()
+            }
+        }
+    }
     pub fn from_nbt(tag: &Tag, anvil: bool) -> Self {
         Self {
             hurt_entities: number(tag.get("HurtEntities")).map_or(anvil, |v| v != 0),
@@ -181,6 +193,14 @@ pub fn hurt_mobs(mobs: &mut [Mob], position: Vec3, amount: f32) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    #[test]
+    fn only_brushable_blocks_break_where_they_land() {
+        assert!(Damage::falling("minecraft:suspicious_gravel").cancel_drop);
+        assert!(Damage::falling("minecraft:suspicious_sand").cancel_drop);
+        assert!(!Damage::falling("minecraft:gravel").cancel_drop);
+        assert!(Damage::falling("minecraft:chipped_anvil").hurt_entities);
+    }
+
     #[test]
     fn impact_uses_ceil_distance_capped_damage_and_positive_damage_wear() {
         let damage = Damage::anvil();
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 58b89a140..b961b6d16 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2971,11 +2971,9 @@ impl Game<'_> {
                         drop_item: true,
                         fall_distance: 0.0,
                         stuck: Vec3::ZERO,
-                        damage: if self.res.facts().get(state).name.ends_with("anvil") {
-                            horizon_client::falling_block::Damage::anvil()
-                        } else {
-                            Default::default()
-                        },
+                        damage: horizon_client::falling_block::Damage::falling(
+                            &self.res.facts().get(state).name,
+                        ),
                         saved: None,
                     });
                 }
diff --git a/crates/horizon-client/src/game/falling_damage.rs b/crates/horizon-client/src/game/falling_damage.rs
index 8eec28d1d..08d96d7d1 100644
--- a/crates/horizon-client/src/game/falling_damage.rs
+++ b/crates/horizon-client/src/game/falling_damage.rs
@@ -64,6 +64,25 @@ impl Game<'_> {
                     pos: BlockPos::new(pos[0], pos[1], pos[2]),
                     data: 0,
                 });
+            } else if self
+                .res
+                .facts()
+                .get(block.state)
+                .name
+                .starts_with("minecraft:suspicious_")
+            {
+                // BrushableBlock.onBrokenAfterFall.
+                let at = BlockPos::new(pos[0], pos[1], pos[2]);
+                self.level_events.push(LevelEvent::LevelEvent {
+                    id: 2001,
+                    pos: at,
+                    data: block.state.0 as i32,
+                });
+                self.level_events.push(LevelEvent::GameEvent {
+                    pos: at,
+                    event: "minecraft:block_destroy",
+                    state: None,
+                });
             }
             return;
         }

From 55a066e88a7b0739903a6ef6f46d33ed4f19b7c3 Mon Sep 17 00:00:00 2001
From: FusselTV <github@fussel.tv>
Date: Mon, 26 Oct 2026 16:20:45 +0100
Subject: [PATCH 197/475] End: spike crystals are saved with the chunk that
 generates them

SpikeFeature.placeSpike adds each crystal to the WorldGenRegion, so a
pre-generated End holds its ten crystals before anyone ticks it.
Horizon's decoration dropped spawn_end_crystal and the game placed the
crystals later, once the arena was loaded and ticking. An End generated
with ticks frozen, as a seed generator does, had none. The decoration
region now writes the crystal like any placed entity; the game's own
placement still skips a spike that has its crystal.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/worldgen/generator_decoration.rs      | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/crates/horizon-world/src/worldgen/generator_decoration.rs b/crates/horizon-world/src/worldgen/generator_decoration.rs
index fc1cd8bcf..426cd98a4 100644
--- a/crates/horizon-world/src/worldgen/generator_decoration.rs
+++ b/crates/horizon-world/src/worldgen/generator_decoration.rs
@@ -851,6 +851,33 @@ impl PlacementContext for World<'_> {
         self.entities.push(nbt);
         Ok(())
     }
+    /// SpikeFeature.placeSpike: the crystal is a fresh entity of the region,
+    /// saved with the chunk.
+    fn spawn_end_crystal(
+        &mut self,
+        position: [f64; 3],
+        yaw: f32,
+        beam_target: Option<[i32; 3]>,
+        invulnerable: bool,
+    ) -> Result<(), PlacementQueryError> {
+        use crate::nbt::Tag;
+        let mut nbt = crate::nbt::Compound::new();
+        nbt.insert("id".into(), Tag::String("minecraft:end_crystal".into()));
+        nbt.insert(
+            "Pos".into(),
+            Tag::List(position.iter().map(|v| Tag::Double(v.to_bits())).collect()),
+        );
+        nbt.insert(
+            "Rotation".into(),
+            Tag::List(vec![Tag::Float(yaw.to_bits()), Tag::Float(0)]),
+        );
+        nbt.insert("Invulnerable".into(), Tag::Byte(i8::from(invulnerable)));
+        nbt.insert("ShowBottom".into(), Tag::Byte(1));
+        if let Some(b) = beam_target {
+            nbt.insert("beam_target".into(), Tag::IntArray(b.to_vec()));
+        }
+        self.add_entity(nbt)
+    }
     fn set_block_entity(
         &mut self,
         position: [i32; 3],

From 1eb7a04a4e17cfd56cf2b6f530c123c1c8ec83cb Mon Sep 17 00:00:00 2001
From: FusselTV <github@fussel.tv>
Date: Mon, 26 Oct 2026 13:41:57 +0100
Subject: [PATCH 198/475] End: no exit portal while nobody is in the fight

With force-loaded levels ticking without players (#1525), Horizon placed
the exit portal as soon as the End's main island was loaded. Vanilla
only places it from scanState and the dragon's death, both with players
in the fight, so a pre-generated End has no portal until someone
arrives.

test_forced_end_parity force-loads the End's arena on vanilla's and
Horizon's dedicated servers with nobody online and compares what is
around 0, 0.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/dragon.rs |  4 +-
 docs/architecture.md                     |  2 +-
 tools/test_forced_end_parity.py          | 91 ++++++++++++++++++++++++
 3 files changed, 95 insertions(+), 2 deletions(-)
 create mode 100755 tools/test_forced_end_parity.py

diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index fff03ef1c..a2602fb96 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -2598,7 +2598,9 @@ impl Game<'_> {
     }
     pub(super) fn fight_ready(&mut self) -> bool {
         self.load_fight();
-        self.fight.loaded
+        // spawnExitPortal runs from scanState and the dragon's death, both
+        // only with players in the fight.
+        self.fight.loaded && self.fight.players
     }
     pub(super) fn exit_portal(&self) -> Option<[i32; 3]> {
         self.fight.exit_portal
diff --git a/docs/architecture.md b/docs/architecture.md
index 0350bd1ea..8e19046f8 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -46,7 +46,7 @@ file selects ~103.
 | 29 | Title, worlds, startup (49) | `L/title.rs` + `L/title/`, `G/startup_menu.rs`, `L/title_edition.rs` | world_options; `cargo test -p horizon-client --lib title` |
 | 30 | Dedicated server, horizon-server (48) | `G/dedicated.rs`, `G/dedicated/status.rs`, `crates/horizon-server/`, `crates/horizon-server-files/` | dedicated_server, server_files, user_cache, online_mode, server_ops_feedback |
 | 31 | Particles and client effects (46) | `L/particles.rs`, `G/render_tick.rs`, `G/level_particles.rs`, `L/animate_tick.rs` | particle_providers, block_particles, entity_particles, emitter_particles, marker_particles |
-| 32 | Bosses and the End (45) | `G/dragon.rs`, `G/wither.rs`, `G/end.rs` | server_dragon, end_podium, end_gateway |
+| 32 | Bosses and the End (45) | `G/dragon.rs`, `G/wither.rs`, `G/end.rs` | server_dragon, forced_end, end_podium, end_gateway |
 | 33 | Protocol and packets (44) | `crates/horizon-protocol/src/` (`packets/play.rs`, `entity_data.rs`, `connection.rs`) | dedicated_server, online_mode, secure_chat; `cargo test -p horizon-protocol` |
 | 34 | Multiplayer and LAN screens, friends (44) | `L/multiplayer.rs`, `G/lan_screen.rs`, `G/friends.rs`, `L/friends_screen.rs`, `crates/horizon-friends/`, `crates/horizon-relay/` | lan, world_options; `python3 tools/test_friends.py` |
 | 35 | Dispensers (43) | `G/dispenser.rs`, `G/dispense_fixture.rs` (the harness side) | dispenser |
diff --git a/tools/test_forced_end_parity.py b/tools/test_forced_end_parity.py
new file mode 100755
index 000000000..81a92e4ed
--- /dev/null
+++ b/tools/test_forced_end_parity.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""The End of a dedicated server nobody has entered, force-loaded from the console, against vanilla's.
+
+A vanilla dedicated server and Horizon's each open a copy of one world vanilla generated (its End not made yet).
+With no player online, the console force-loads the End's main island and its arena. A FORCED ticket keeps its level active
+(`ServerChunkCache.hasActiveTickets`, `TicketType.FORCED`), so the chunks are generated, loaded and ticked
+without a player in the dimension. With nobody in the fight, `EnderDragonFight.tick` neither scans the state nor
+places the exit portal: no bedrock and no torches around 0, 0. Both servers must answer the same.
+"""
+import os
+import re
+import subprocess
+import sys
+import time
+
+try:
+    from . import lab, test_rust_parity as base
+    from .test_dedicated_server_parity import Server, wait_ticks
+    from .test_locator_bar_parity import generate_world, server_dir
+except ImportError:
+    import lab
+    import test_rust_parity as base
+    from test_dedicated_server_parity import Server, wait_ticks
+    from test_locator_bar_parity import generate_world, server_dir
+
+NAME = 'forced-end-parity'
+END = 'execute in minecraft:the_end'
+QUERIES = [
+    f'{END} run fill -3 0 -3 3 255 3 minecraft:air replace minecraft:bedrock',
+    f'{END} run fill -3 0 -3 3 255 3 minecraft:air replace minecraft:wall_torch',
+]
+
+
+def answer(server, command, n):
+    start = len(server.lines)
+    server.console(command)
+    server.console(f'say done {n}')
+    server.wait_for(rf'\[Server\] done {n}$', timeout=120)
+    replies = [l.split(']: ', 1)[-1] for l in server.lines[start:] if 'done ' not in l]
+    return ' / '.join(r for r in replies if r) or '(no reply)'
+
+
+def run_side(label, command, build, world):
+    directory = build / label
+    server_dir(directory, world)
+    server = Server(command, directory, label)
+    try:
+        server.wait_for(r'Done \(')
+        # The main island's arena (EnderDragonFight.isArenaLoaded: chunks -8..8), in pieces of at most 256 chunks.
+        for area in ('-128 -128 143 -1', '-128 0 143 143'):
+            server.console(f'{END} run forceload add {area}')
+        deadline = time.time() + 600
+        for poll in range(1_000_000):
+            reply = answer(server, f'{END} if loaded 0 0 0', f'loaded {poll}')
+            if 'passed' in reply:
+                break
+            if time.time() > deadline:
+                raise AssertionError(f'{label}: the End centre never loaded')
+            time.sleep(2)
+        wait_ticks(server, 200)
+        return {q: answer(server, q, i) for i, q in enumerate(QUERIES)}
+    finally:
+        server.stop()
+
+
+def main():
+    _, jars, libraries = base.verify_artifacts()
+    build = lab.LOCAL / NAME
+    build.mkdir(parents=True, exist_ok=True)
+    dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
+    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+                   check=True, capture_output=True)
+    binary = lab.cargo_target() / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
+    horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
+    world = generate_world(vanilla_server, build)
+    vanilla = run_side('vanilla', vanilla_server, build, world)
+    horizon = run_side('horizon', horizon_server, build, world)
+    normal = lambda s: re.sub(r'\s+', ' ', s).strip()
+    problems = [f'{q}\n  vanilla: {vanilla[q]}\n  horizon: {horizon[q]}'
+                for q in QUERIES if normal(vanilla[q]) != normal(horizon[q])]
+    if problems:
+        raise AssertionError('the forced End differs:\n' + '\n'.join(problems))
+    print(f'forced End: loaded and ticked with nobody in it, no exit portal, as vanilla ({vanilla[QUERIES[0]]})')
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except AssertionError as error:
+        sys.exit(f'{NAME}: {error}')

From ec81bea5bfc0270e4b597eff4d0dc2f320258874 Mon Sep 17 00:00:00 2001
From: FusselTV <github@fussel.tv>
Date: Mon, 26 Oct 2026 16:32:02 +0100
Subject: [PATCH 199/475] Worldgen: blocks with a block entity get vanilla's
 default one

WorldGenRegion.setBlock gives every block that has a block entity a new
one, so vanilla saves the sculk sensors, catalysts and shriekers of the
deep dark and potent sulfur with their block entities. Horizon only
saved block entities that a structure or feature placed data for, and
these kinds have none, so a Horizon-made world had none of them (3,035
sculk sensors, 753 catalysts, 329 shriekers and 21 potent sulfur over
three 1,024-block seeds). A finished column now adds vanilla's defaults
(block_entity_nbt::canonical) for every such block: as the modelled
block entity where Horizon has one (sculk), as raw NBT otherwise.
Potent sulfur gets its block entity type.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/lan/chunks.rs |  1 +
 crates/horizon-client/src/vanillagen.rs | 85 ++++++++++++++++++++++++-
 2 files changed, 85 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/lan/chunks.rs b/crates/horizon-client/src/lan/chunks.rs
index 122d37bcd..9ca20b894 100644
--- a/crates/horizon-client/src/lan/chunks.rs
+++ b/crates/horizon-client/src/lan/chunks.rs
@@ -66,6 +66,7 @@ pub fn block_entity_type(name: &str) -> Option<&'static str> {
         "sculk_catalyst" => "minecraft:sculk_catalyst",
         "sculk_shrieker" => "minecraft:sculk_shrieker",
         "crafter" => "minecraft:crafter",
+        "potent_sulfur" => "minecraft:potent_sulfur",
         "chiseled_bookshelf" => "minecraft:chiseled_bookshelf",
         "trial_spawner" => "minecraft:trial_spawner",
         "vault" => "minecraft:vault",
diff --git a/crates/horizon-client/src/vanillagen.rs b/crates/horizon-client/src/vanillagen.rs
index 923818a08..a634d5e28 100644
--- a/crates/horizon-client/src/vanillagen.rs
+++ b/crates/horizon-client/src/vanillagen.rs
@@ -39,6 +39,8 @@ pub struct VanillaTerrain {
     tick_blocks: Vec<u32>,
     /// Block index -> default state id: `tick_blocks` the other way.
     tick_states: Vec<u32>,
+    /// Block state id -> the block entity type of its block, if it has one.
+    block_entity_types: Vec<Option<&'static str>>,
     seed: i64,
     dimension: String,
     /// When the last proto chunk was generated, in milliseconds since
@@ -51,6 +53,51 @@ enum VanillaProto {
     Ready(Box<ProtoChunk>),
     Failed(i32, i32),
 }
+/// WorldGenRegion.setBlock gives every block with a block entity a new
+/// one: the blocks nothing placed data for (a sculk patch's sensors) get
+/// vanilla's defaults.
+fn add_default_block_entities(kinds: &[Option<&str>], out: &mut Chunk, raw: &mut Vec<Tag>) {
+    let kind = |v: u32| kinds.get(v as usize).copied().flatten();
+    let mut states = [0u32; 4096];
+    for (si, section) in out.sections.iter().enumerate() {
+        if !section.blocks.maybe_has(|v| kind(v).is_some()) {
+            continue;
+        }
+        section.unpack(&mut states);
+        for (i, &v) in states.iter().enumerate() {
+            let Some(id) = kind(v) else {
+                continue;
+            };
+            let i = i as i32;
+            let pos = [
+                out.x * 16 + (i & 15),
+                MIN_Y + si as i32 * 16 + (i >> 8),
+                out.z * 16 + ((i >> 4) & 15),
+            ];
+            let at = |t: &Tag| {
+                ["x", "y", "z"]
+                    .iter()
+                    .zip(pos)
+                    .all(|(k, p)| t.get(k) == Some(&Tag::Int(p)))
+            };
+            if raw.iter().any(at) || out.block_entities.iter().any(|(p, _)| *p == pos.into()) {
+                continue;
+            }
+            let tag = Tag::compound([
+                ("id", Tag::String(id.into())),
+                ("x", Tag::Int(pos[0])),
+                ("y", Tag::Int(pos[1])),
+                ("z", Tag::Int(pos[2])),
+            ]);
+            let tag = crate::block_entity_nbt::canonical(&tag).unwrap_or(tag);
+            match crate::save::decode_block_entity(&tag) {
+                Some(modelled) => out.block_entities.push(modelled),
+                None => raw.push(tag),
+            }
+        }
+    }
+}
+
 impl VanillaTerrain {
     fn client_surface(&self, surface: SurfaceSample) -> crate::lod::Surface {
         crate::lod::Surface {
@@ -119,6 +166,7 @@ impl VanillaTerrain {
         }
         let mut tick_blocks = Vec::with_capacity(registry.len());
         let mut tick_states = Vec::new();
+        let mut block_entity_types = Vec::with_capacity(registry.len());
         let mut last: Option<&str> = None;
         let mut index = 0u32;
         for id in 0..registry.len() {
@@ -133,6 +181,7 @@ impl VanillaTerrain {
             }
             last = Some(name);
             tick_blocks.push(index);
+            block_entity_types.push(crate::lan::chunks::block_entity_type(name));
         }
         Ok(Self {
             generator,
@@ -141,6 +190,7 @@ impl VanillaTerrain {
             query: std::sync::Mutex::new(None),
             tick_blocks,
             tick_states,
+            block_entity_types,
             seed,
             dimension: dimension.to_owned(),
             last_proto: std::sync::atomic::AtomicU64::new(0),
@@ -553,7 +603,7 @@ impl ChunkGenerator for VanillaTerrain {
         // The block entities Horizon does not model (decorated pots with their
         // sherds and loot table, brushable blocks) stay as placed, like a
         // loaded chunk's.
-        let unmodelled: Vec<Tag> = chunk
+        let mut unmodelled: Vec<Tag> = chunk
             .block_entities
             .iter()
             .filter(|(pos, _)| {
@@ -573,6 +623,7 @@ impl ChunkGenerator for VanillaTerrain {
                 Some(Tag::Compound(nbt))
             })
             .collect();
+        add_default_block_entities(&self.block_entity_types, &mut out, &mut unmodelled);
         if !unmodelled.is_empty() || !rolled_loot.is_empty() {
             let mut extras = out
                 .saved
@@ -596,3 +647,35 @@ impl ChunkGenerator for VanillaTerrain {
         out
     }
 }
+
+#[cfg(test)]
+mod default_block_entity_tests {
+    use super::*;
+
+    #[test]
+    fn generated_blocks_get_their_block_entities() {
+        let mut out = Chunk::empty(-2, 3);
+        out.set(4, -40, 9, 7);
+        out.set(5, -40, 9, 6);
+        let mut kinds = vec![None; 8];
+        kinds[6] = Some("minecraft:potent_sulfur");
+        kinds[7] = Some("minecraft:sculk_sensor");
+        let mut raw = vec![];
+        add_default_block_entities(&kinds, &mut out, &mut raw);
+        assert!(matches!(
+            out.block_entities[..],
+            [((-28, -40, 57), crate::containers::BlockEntity::Sculk(_))]
+        ));
+        assert_eq!(raw.len(), 1);
+        assert_eq!(
+            raw[0].get("id"),
+            Some(&Tag::String("minecraft:potent_sulfur".into()))
+        );
+        add_default_block_entities(&kinds, &mut out, &mut raw);
+        assert_eq!(
+            (out.block_entities.len(), raw.len()),
+            (1, 1),
+            "a placed block entity is kept, not doubled"
+        );
+    }
+}

From 97f8bca9daf9eb3f18b4bab27c3bd36cc8ca56e2 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:32:41 +0100
Subject: [PATCH 200/475] Raiders skip ominous banners they cannot reach

A captainless raider walked towards the nearest fallen ominous banner
even when no path led to it. Check that a path reaches the banner before
going for it, and skip a banner without one for 600 ticks, like vanilla.
---
 crates/horizon-client/src/game/raids.rs  | 17 +++++++----
 crates/horizon-client/src/mobs/raider.rs | 37 ++++++++++++++++++------
 2 files changed, 39 insertions(+), 15 deletions(-)

diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs
index bedca5708..e34d9feed 100644
--- a/crates/horizon-client/src/game/raids.rs
+++ b/crates/horizon-client/src/game/raids.rs
@@ -762,7 +762,7 @@ impl Game<'_> {
             }
             positions.push((m.id, m.position, s.active_raid));
         }
-        let banners: Vec<(usize, Vec3)> = self
+        let banners: Vec<(usize, u32, Vec3)> = self
             .dropped
             .iter()
             .enumerate()
@@ -771,7 +771,7 @@ impl Game<'_> {
                     && e.stack.data().is_some_and(|d| d.ominous_banner)
                     && e.pickup_delay == 0
             })
-            .map(|(i, e)| (i, e.position))
+            .map(|(i, e)| (i, e.id, e.position))
             .collect();
         let mut taken: Vec<usize> = Vec::new();
         let mut collectors: Vec<(usize, u32)> = Vec::new();
@@ -858,18 +858,23 @@ impl Game<'_> {
             {
                 let near = banners
                     .iter()
-                    .filter(|(i, p)| {
+                    .filter(|(i, item, p)| {
                         !taken.contains(i)
+                            && !s
+                                .unreachable_banners
+                                .iter()
+                                .any(|&(b, until)| b == *item && now < until)
                             && (p.x - position.x).abs() <= range
                             && (p.z - position.z).abs() <= range
                             && (p.y - position.y).abs() <= 8.0
                     })
                     .min_by(|a, b| {
-                        a.1.distance_squared(position)
-                            .total_cmp(&b.1.distance_squared(position))
+                        a.2.distance_squared(position)
+                            .total_cmp(&b.2.distance_squared(position))
                     });
-                if let Some((i, p)) = near {
+                if let Some((i, item, p)) = near {
                     s.banner_at = Some([p.x, p.y, p.z]);
+                    s.banner_item = *item;
                     if p.distance_squared(position) < 1.414 * 1.414 {
                         // pickUpItem: the banner becomes the wave's leader.
                         taken.push(*i);
diff --git a/crates/horizon-client/src/mobs/raider.rs b/crates/horizon-client/src/mobs/raider.rs
index 6c3ab9b64..a2c3ffe33 100644
--- a/crates/horizon-client/src/mobs/raider.rs
+++ b/crates/horizon-client/src/mobs/raider.rs
@@ -38,6 +38,11 @@ pub struct State {
     pub in_village: bool,
     /// A dropped ominous banner this raider may fetch.
     pub banner_at: Option<[f64; 3]>,
+    /// The item entity of `banner_at`.
+    pub banner_item: u32,
+    /// Banners with no path to them, and until when (game time):
+    /// `unreachableBannerCache`.
+    pub unreachable_banners: Vec<(u32, i64)>,
     /// Beds around the raid's centre.
     pub homes: Option<std::sync::Arc<Vec<[i32; 3]>>>,
     /// A ravager carrying a raider, set every tick from `Extra::rider`.
@@ -113,7 +118,7 @@ pub fn register(m: &mut Mob) {
     }
     m.extra.raider = Some(Box::default());
     m.ai.goals.add(4, LongDistancePatrol::new(0.7, 0.595));
-    m.ai.goals.add(1, ObtainBanner);
+    m.ai.goals.add(1, ObtainBanner::default());
     m.ai.goals.add(3, PathfindToRaid);
     m.ai.goals.add(4, MoveThroughVillage::new(1.05, 1.0));
     m.ai.goals.add(5, Celebration);
@@ -336,23 +341,37 @@ fn close_to_center(p: [i32; 3], at: Vec3, distance: f64) -> bool {
 
 /// `Raider.ObtainRaidLeaderBannerGoal`: walk to a fallen ominous banner when
 /// the wave has no living leader (the game finds the banner and picks it up).
-#[derive(Clone, Debug)]
-pub struct ObtainBanner;
+#[derive(Clone, Debug, Default)]
+pub struct ObtainBanner {
+    path_to_banner: Option<super::path::Path>,
+}
 impl Goal for ObtainBanner {
     goal_clone!();
     fn flags(&self) -> u8 {
         MOVE
     }
-    fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool {
-        state(m).is_some_and(|s| s.banner_at.is_some())
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        let Some((at, item)) = state(m).and_then(|s| s.banner_at.map(|at| (at, s.banner_item)))
+        else {
+            return false;
+        };
+        // A banner with no path to it is skipped for 600 ticks.
+        let path = m.create_path_to_entity(cx.w, at, 1);
+        if path.as_ref().is_some_and(|p| p.reached) {
+            self.path_to_banner = path;
+            return true;
+        }
+        let now = cx.w.game_time;
+        let s = state_mut(m);
+        s.unreachable_banners.retain(|&(_, until)| now < until);
+        s.unreachable_banners.push((item, now + 600));
+        false
     }
     fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool {
         !m.ai.nav.is_done() && state(m).is_some_and(|s| s.banner_at.is_some())
     }
-    fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
-        if let Some(at) = state(m).and_then(|s| s.banner_at) {
-            m.nav_move_to(cx.w, at, 1.15);
-        }
+    fn start(&mut self, m: &mut Mob, _cx: &mut Cx) {
+        m.nav_move_to_path(self.path_to_banner.take(), 1.15);
     }
 }
 

From 61df807b33290aa01e0bebb928ea7449252213df Mon Sep 17 00:00:00 2001
From: FusselTV <github@fussel.tv>
Date: Mon, 26 Oct 2026 13:41:57 +0100
Subject: [PATCH 201/475] Structures: a chunk saves its starts also when no
 piece reaches it

A chunk's STRUCTURE_STARTS are the starts made in it
(StructureManager.getAllStarts), whether or not one of their pieces
reaches it. own_starts filtered the chunk's references, which only hold
starts with a piece in the chunk, so a start whose pieces all lie next
door (seed 8675309's giant ruined portal in chunk -26, 23) was not saved.
The proto chunk now keeps the starts made at its position.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../horizon-world/src/worldgen/generator.rs   | 49 ++++++++++++++-----
 1 file changed, 36 insertions(+), 13 deletions(-)

diff --git a/crates/horizon-world/src/worldgen/generator.rs b/crates/horizon-world/src/worldgen/generator.rs
index 7a38608be..8630a4ef8 100644
--- a/crates/horizon-world/src/worldgen/generator.rs
+++ b/crates/horizon-world/src/worldgen/generator.rs
@@ -23,6 +23,7 @@ use super::{
     climate::{ClimateSampler, decode_parameter, quantize},
     decode_noise,
     density::DensityRegistry,
+    generator_structures::Starts,
     material_condition::{
         MaterialConditionRegistry, MaterialConditions, MaterialDensitySources, MaterialRule,
         MaterialRuleError, MaterialRuleLibrary, MaterialSurfaceQueries,
@@ -567,6 +568,9 @@ pub struct ProtoChunk {
     pub block_entities: Vec<([i32; 3], crate::nbt::Compound)>,
     /// Structure starts referencing this chunk (STRUCTURE_REFERENCES).
     pub(super) structure_starts: Vec<Arc<super::structure::start::StructureStart>>,
+    /// The starts made in this chunk (STRUCTURE_STARTS), also those none of
+    /// whose pieces reach it (a giant ruined portal next door).
+    own_starts: Starts,
     /// Entities placed by structures (`ProtoChunk.addEntity`), as NBT with
     /// absolute `Pos`.
     pub entities: Vec<crate::nbt::Compound>,
@@ -620,12 +624,7 @@ impl ProtoChunk {
     }
     /// The structure starts this chunk holds itself (`structures.starts`).
     pub fn own_starts(&self) -> Vec<Arc<super::structure::start::StructureStart>> {
-        let pos = self.position();
-        self.structure_starts
-            .iter()
-            .filter(|s| s.chunk == pos)
-            .cloned()
-            .collect()
+        self.own_starts.to_vec()
     }
     /// Also restores a saved proto chunk that was decorated before it was saved.
     pub fn set_decorated(&mut self) {
@@ -1114,16 +1113,19 @@ where
         )
         .map_err(stage("noise"))?;
         chunk.set_generation_stage(PreLightChunkStage::Biomes);
-        let references = match &self.structures {
-            Some(structures) => structures.references(
-                &mut StructureQueries {
+        let (references, own_starts) = match &self.structures {
+            Some(structures) => {
+                let mut queries = StructureQueries {
                     pipeline: self,
                     worker,
                     valid: BTreeSet::new(),
-                },
-                pos,
-            ),
-            None => Vec::new(),
+                };
+                (
+                    structures.references(&mut queries, pos),
+                    structures.starts_at(&mut queries, pos),
+                )
+            }
+            None => (Vec::new(), Starts::default()),
         };
         if let Some(beard) = self
             .structures
@@ -1259,6 +1261,7 @@ where
             decorated: false,
             block_entities: Vec::new(),
             structure_starts: references,
+            own_starts,
             entities: Vec::new(),
         })
     }
@@ -2975,6 +2978,26 @@ mod tests {
         }
     }
 
+    /// Seed 8675309's giant ruined portal starts in chunk (-26, 23) and lies
+    /// wholly in (-26, 24): its own chunk still holds the start, as vanilla's
+    /// getAllStarts does, though no piece reaches it.
+    #[test]
+    fn a_chunk_holds_its_starts_whose_pieces_lie_elsewhere() {
+        let Some(data) = prepared_data() else {
+            return;
+        };
+        let generator = OverworldGenerator::new(data, 8675309).expect("generator");
+        let mut worker = generator.worker();
+        let proto = worker
+            .generate_proto(ChunkPos::new(-26, 23))
+            .expect("proto");
+        let own: Vec<_> = proto.own_starts().iter().map(|s| s.name.clone()).collect();
+        assert!(
+            own.iter().any(|n| n == "minecraft:ruined_portal_mountain"),
+            "{own:?}"
+        );
+    }
+
     /// Chunks no ring search can end near are decided without the rings,
     /// which stay unsearched, and get the starts they get with them.
     #[test]

From c74626448c544dae0101e005eafa4c23fab19981 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:40:06 +0100
Subject: [PATCH 202/475] Show the crosshair to spectators over containers,
 stations and portals

---
 crates/horizon-client/src/game.rs      |  6 ++-
 crates/horizon-client/src/game/hand.rs | 56 +++++++++++++++++++++++++-
 2 files changed, 60 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 58b89a140..91d953722 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -5141,7 +5141,11 @@ impl Game<'_> {
             let delay = horizon_client::attack_strength::delay(self.main_hand_attack_speed());
             let strength = self.hand_strength.scale(0.0, self.main_hand_attack_speed());
             // The 3D crosshair (F3) takes the 2D one's place.
-            if self.camera_type.first_person() && !spectator && !self.debug_crosshair() {
+            // Hud.extractCrosshair: a spectator only sees it over something to open.
+            if self.camera_type.first_person()
+                && (!spectator || self.spectator_crosshair())
+                && !self.debug_crosshair()
+            {
                 let attack = (indicator == 1).then_some(strength);
                 let full = attack.is_some_and(|a| {
                     hud_layout::full_attack_indicator(a, delay, self.crosshair_living())
diff --git a/crates/horizon-client/src/game/hand.rs b/crates/horizon-client/src/game/hand.rs
index d91d3b979..c3fd78310 100644
--- a/crates/horizon-client/src/game/hand.rs
+++ b/crates/horizon-client/src/game/hand.rs
@@ -3,7 +3,7 @@
 //! `continueAttack`, `MultiPlayerGameMode` block breaking), the arm swing
 //! (`LivingEntity.SwingState`) and the first-person equip heights
 //! (`FirstPersonHandsAndItems`) with the item swap ticker they read.
-use super::{Game, Mining, Screen};
+use super::{Game, Mining, Screen, minecarts::CartKind};
 use horizon_client::{
     Result,
     attack_strength::HeldStack,
@@ -289,6 +289,60 @@ impl Game<'_> {
         // Only alive mobs are hit, so a picked living entity is alive.
         Some(true)
     }
+    /// `Hud.canRenderCrosshairForSpectator` for the nearest hit in reach: an
+    /// entity that is a `MenuProvider` (a chest or hopper minecart, a chest
+    /// boat), or a block whose `showAsInteractableInSpectatorMode` holds.
+    pub(super) fn spectator_crosshair(&self) -> bool {
+        let cart = self.cart_hit().map(|(i, d)| {
+            let kind = &self.carts[i].kind;
+            (d, matches!(kind, CartKind::Chest | CartKind::Hopper))
+        });
+        let boat = self.boat_hit().map(|(i, d)| (d, self.boats[i].chest));
+        let others = [
+            self.mob_hit().map(|h| h.1),
+            self.armor_stand_hit().map(|h| h.1),
+            self.cushion_hit().map(|h| h.1),
+            self.painting_hit().map(|h| h.1),
+            self.frame_hit().map(|h| h.1),
+            self.dragon_hit().map(|h| h.1),
+        ];
+        let nearest = cart
+            .into_iter()
+            .chain(boat)
+            .chain(others.into_iter().flatten().map(|d| (d, false)))
+            .min_by(|a, b| a.0.total_cmp(&b.0));
+        if let Some((distance, menu)) = nearest
+            && self.before_block(distance)
+        {
+            return menu;
+        }
+        let Some(hit) = self.pick() else {
+            return false;
+        };
+        let name = &*self
+            .res
+            .facts()
+            .get(self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]))
+            .name;
+        let name = name.trim_start_matches("minecraft:");
+        match name {
+            // BlockBehaviour.getMenuProvider and `instanceof Portal`.
+            "crafting_table" | "enchanting_table" | "anvil" | "chipped_anvil" | "damaged_anvil"
+            | "stonecutter" | "loom" | "cartography_table" | "grindstone" | "smithing_table"
+            | "barrel" | "furnace" | "blast_furnace" | "smoker" | "brewing_stand" | "hopper"
+            | "dispenser" | "dropper" | "crafter" | "lectern" | "beacon" | "nether_portal"
+            | "end_portal" | "end_gateway" => true,
+            // ChestBlock.getMenuProvider: none while a redstone conductor
+            // sits on top (a sitting cat aside).
+            "chest" | "trapped_chest" => {
+                let above = self.world.block(hit.pos[0], hit.pos[1] + 1, hit.pos[2]);
+                self.res.behaviours().facts(above).flags
+                    & horizon_world::level::data::state_flags::CONDUCTOR
+                    == 0
+            }
+            _ => name.ends_with("shulker_box"),
+        }
+    }
     /// `Attributes.ATTACK_SPEED` with the main-hand item's modifier.
     pub(super) fn main_hand_attack_speed(&self) -> f64 {
         horizon_client::attack_strength::BASE_ATTACK_SPEED

From b28b4991359b3111ac2249d0c3b9b6276684cc66 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 19:41:35 +0100
Subject: [PATCH 203/475] mods: recipes.give hands out one stack at most

As the creative inventory does: a count over the item's stack size (64, 16
or 1) is cut to it, so a mod can ask for a full stack without knowing it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/mod_recipes.rs | 8 ++++++--
 crates/horizon-mod-sdk/wit/horizon.wit        | 3 ++-
 docs/api/mods-reference.md                    | 2 +-
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/game/mod_recipes.rs b/crates/horizon-client/src/game/mod_recipes.rs
index 0f65b0b42..b97944e39 100644
--- a/crates/horizon-client/src/game/mod_recipes.rs
+++ b/crates/horizon-client/src/game/mod_recipes.rs
@@ -74,7 +74,10 @@ impl Game<'_> {
     /// creative inventory; a server hears it as `SetCreativeModeSlot`
     /// through the inventory's sync, and refuses it unless creative.
     pub(super) fn mod_give(&mut self, item: &str, count: u32, components: &str) {
-        if !self.creative || self.res.items().get(item).is_none() {
+        let Some(max) = self.res.items().get(item).map(|i| i.max_stack) else {
+            return;
+        };
+        if !self.creative {
             return;
         }
         let (damage, extra) = horizon_client::item_data::command_components(components)
@@ -83,7 +86,8 @@ impl Game<'_> {
             });
         let _ = self.give(ItemStack {
             item: item.into(),
-            count,
+            // One stack at most, as the creative inventory hands out.
+            count: count.min(max),
             damage,
             extra,
         });
diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit
index 3edc44872..1c1431273 100644
--- a/crates/horizon-mod-sdk/wit/horizon.wit
+++ b/crates/horizon-mod-sdk/wit/horizon.wit
@@ -516,7 +516,8 @@ interface recipes {
     place: func(book-id: s32, all: bool) -> result<_, string>;
     /// Creative mode only: gives the player the stack, as taking it from
     /// the creative inventory does (`ServerboundSetCreativeModeSlot`): the
-    /// selected slot first, then the hotbar, then the inventory.
+    /// selected slot first, then the hotbar, then the inventory. The count
+    /// is cut to one stack of the item (64, 16 or 1).
     give: func(stack: stack) -> result<_, string>;
 }
 
diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md
index ed8d8d4ad..6416245ad 100644
--- a/docs/api/mods-reference.md
+++ b/docs/api/mods-reference.md
@@ -531,7 +531,7 @@ The station a recipe is made at.
 | `all` | `func() -> list<recipe>` | Every recipe: the book's in its order, then campfire, stonecutting, smithing and brewing. They don't change while a world is open. |
 | `known` | `func() -> list<s32>` | The `book-id`s of the recipes the player's recipe book holds now. |
 | `place` | `func(book-id: s32, all: bool) -> result<_, string>` | Places a recipe in the open screen's grid as a click in the recipe book does (`ServerboundPlaceRecipePacket`): the inventory's grid or a crafting table. `all` places as many as the items allow, as with Shift. Refused while no such screen is open, for a recipe the player's book doesn't hold and for one that can't be placed; one missing items shows as a ghost in the grid, as in the book. |
-| `give` | `func(stack: stack) -> result<_, string>` | Creative mode only: gives the player the stack, as taking it from the creative inventory does (`ServerboundSetCreativeModeSlot`): the selected slot first, then the hotbar, then the inventory. |
+| `give` | `func(stack: stack) -> result<_, string>` | Creative mode only: gives the player the stack, as taking it from the creative inventory does (`ServerboundSetCreativeModeSlot`): the selected slot first, then the hotbar, then the inventory. The count is cut to one stack of the item (64, 16 or 1). |
 
 ## `browser`
 

From 752138e866916b5f116b7fbb933f07bee2138144 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:43:27 +0100
Subject: [PATCH 204/475] Cats sit on a chest only while nobody has it open,
 and on a bed's foot only

---
 crates/horizon-client/examples/probe/mob_ai_probe.rs | 3 +++
 crates/horizon-client/src/game/creatures.rs          | 1 +
 crates/horizon-client/src/mobs.rs                    | 2 ++
 crates/horizon-client/src/mobs/tame.rs               | 7 +++++--
 4 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs
index ecdf02901..2fdb12ce9 100644
--- a/crates/horizon-client/examples/probe/mob_ai_probe.rs
+++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs
@@ -1069,6 +1069,8 @@ pub fn main() -> horizon_client::Result<()> {
         for (i, m) in mobs.iter().enumerate() {
             print(&mut out, 0, i, m, s.creative, world.game_time);
         }
+        // No player has a chest open in the scenarios.
+        let lid_openers = std::collections::HashMap::new();
         // The MobWorld every step sees, over a snapshot of the mobs.
         macro_rules! mob_world {
             ($snapshot:expr) => {
@@ -1103,6 +1105,7 @@ pub fn main() -> horizon_client::Result<()> {
                     // FlatLevelSource.getSeaLevel.
                     sea_level: -63,
                     items: Some(&items),
+                    lid_openers: &lid_openers,
                 }
             };
         }
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 845d2aee6..88f3fd669 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -422,6 +422,7 @@ impl Game<'_> {
             sea_level: if self.dim == Dim::Nether { 32 } else { 63 },
             teams: std::sync::Arc::new(self.mob_teams()),
             items: Some(self.res.items()),
+            lid_openers: &self.lid_openers,
             difficulty: self.local_difficulty(
                 self.player
                     .as_ref()
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 6b1e16f5c..06930be93 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1529,6 +1529,8 @@ pub struct MobWorld<'a> {
     pub teams: std::sync::Arc<Teams<'a>>,
     /// Item data (max stack sizes), when the host has it.
     pub items: Option<&'a crate::items::Items>,
+    /// `ChestBlockEntity.getOpenCount`: the players with each chest open.
+    pub lid_openers: &'a HashMap<(i32, i32, i32), i32>,
 }
 /// `Entity.getTeam` of the player and of the mobs on a team.
 #[derive(Clone, Debug, Default)]
diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs
index 1e725df80..30ac762b9 100644
--- a/crates/horizon-client/src/mobs/tame.rs
+++ b/crates/horizon-client/src/mobs/tame.rs
@@ -835,7 +835,7 @@ impl Goal for CatLieOnBlock {
         m.extra.flag = self.0.reached;
     }
 }
-/// `CatSitOnBlockGoal`: chests, lit furnaces and beds.
+/// `CatSitOnBlockGoal`: unopened chests, lit furnaces and the foot of beds.
 #[derive(Clone, Debug)]
 struct CatSitOnBlock(super::goals::MoveToBlock);
 fn can_sit_on(w: &MobWorld, p: [i32; 3]) -> bool {
@@ -846,7 +846,10 @@ fn can_sit_on(w: &MobWorld, p: [i32; 3]) -> bool {
     match f.name.as_ref() {
         // The lit state is the only light source a furnace has.
         "minecraft:furnace" => f.emission > 0,
-        _ => true,
+        // `ChestBlockEntity.getOpenCount(level, pos) < 1`.
+        "minecraft:chest" => !w.lid_openers.contains_key(&(p[0], p[1], p[2])),
+        // A bed's foot only (`BedBlock.PART != HEAD`).
+        _ => w.prop(p[0], p[1], p[2], "part") != Some("head"),
     }
 }
 impl Goal for CatSitOnBlock {

From 8aad511579676fa39072a685482a9ed3b9a1bacc Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:46:01 +0100
Subject: [PATCH 205/475] Drop the cursor stack when the dead player respawns

---
 crates/horizon-client/src/game/screens.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs
index 3a2c3deda..69ae69633 100644
--- a/crates/horizon-client/src/game/screens.rs
+++ b/crates/horizon-client/src/game/screens.rs
@@ -290,6 +290,14 @@ impl Game<'_> {
     /// button, or at once with `immediate_respawn`).
     pub(super) fn respawn_player(&mut self) -> Result<()> {
         if self.remote.is_none() {
+            // PlayerList.respawn removes the dead player, and Player.remove's
+            // inventoryMenu.removed drops what the cursor held, whatever
+            // keep_inventory says (the 20-tick branch handles a later respawn).
+            if let Some(stack) = self.carried.take()
+                && let Some(eye) = self.eye_position()
+            {
+                self.throw_from_eyes(stack, eye);
+            }
             let keep = self.ui.rules.bool("keep_inventory") || self.spectator();
             self.experience.respawn(keep);
             // The guests are sent the respawned host as a new entity, not the dead body.

From 766bfbcdfa6d602518e0fe70657092c54f63b692 Mon Sep 17 00:00:00 2001
From: mahirsn <mahirsuna72@gmail.com>
Date: Mon, 26 Oct 2026 21:13:00 +0300
Subject: [PATCH 206/475] fix(client): answer the server's held slot like
 vanilla

ClientboundSetHeldSlotPacket only changes the selected hotbar slot (and ignores slots outside the hotbar), so the next tick sends ServerboundSetCarriedItemPacket as vanilla does. Each login starts again from slot 0, as handleLogin's new MultiPlayerGameMode and LocalPlayer do.
---
 crates/horizon-client/src/game/remote.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3cfbd15e3..d53420db9 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -1619,7 +1619,11 @@ impl Game<'_> {
             }
             C::Login(p) => {
                 self.level.hardcore = p.hardcore;
+                // handleLogin makes a new MultiPlayerGameMode (carried index 0) and a
+                // new LocalPlayer (slot 0).
+                self.selected = 0;
                 if let Some(r) = self.remote.as_mut() {
+                    r.carried = Some(0);
                     r.online_mode = p.online_mode;
                     r.entity_id = p.player_id;
                     r.view_distance = p.chunk_radius;
@@ -2295,10 +2299,11 @@ impl Game<'_> {
                 }
                 self.apply_remote_abilities();
             }
+            // ClientPacketListener.handleSetHeldSlot: a hotbar slot only, and the
+            // carried index stays, so the next tick answers with SetCarriedItem.
             C::SetHeldSlot(p) => {
-                self.selected = p.slot.clamp(0, 8) as usize;
-                if let Some(r) = self.remote.as_mut() {
-                    r.carried = Some(self.selected);
+                if (0..9).contains(&p.slot) {
+                    self.selected = p.slot as usize;
                 }
             }
             C::ContainerSetContent(p) => {

From 2b2aecd9757305af6e124daeaf55b5327440c02e Mon Sep 17 00:00:00 2001
From: mahirsn <mahirsuna72@gmail.com>
Date: Mon, 26 Oct 2026 21:40:03 +0300
Subject: [PATCH 207/475] fix(client): send sign editor text like vanilla

A new editor or a removed sign closes the open editor (Minecraft.setScreen, AbstractSignEditScreen.tick), and closing sends ServerboundSignUpdatePacket with the lines it opened with when the sign is gone. Sign lines resolve key binds and translations (Component.getString) instead of keeping only plain text.
---
 crates/horizon-client/src/game/remote.rs    |  9 +++++++
 crates/horizon-client/src/game/sign_edit.rs | 29 +++++++++++++++------
 crates/horizon-client/src/signs.rs          |  8 +++---
 3 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3cfbd15e3..4e279de6c 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3129,6 +3129,15 @@ impl Game<'_> {
 
     fn tick_remote_level(&mut self) -> Result<()> {
         self.ticks += 1;
+        // AbstractSignEditScreen.tick: the editor closes once its sign is removed.
+        if let Some(edit) = &self.sign_edit
+            && !matches!(
+                self.world.block_entities.get(&edit.pos),
+                Some(BlockEntity::Sign(_))
+            )
+        {
+            self.close_sign_editor();
+        }
         self.track_experience_display();
         // Player.tick's ItemCooldowns.tick: this path replaces `tick_world`'s
         // for a server's client (multiplayer and the default single player),
diff --git a/crates/horizon-client/src/game/sign_edit.rs b/crates/horizon-client/src/game/sign_edit.rs
index 2d010f1f5..529e511f2 100644
--- a/crates/horizon-client/src/game/sign_edit.rs
+++ b/crates/horizon-client/src/game/sign_edit.rs
@@ -20,6 +20,9 @@ pub(super) struct SignEditor {
     pub line: usize,
     /// The line being edited (`AbstractSignEditScreen`'s text field).
     edit: EditBox,
+    /// `AbstractSignEditScreen.messages`: the lines when it opened, sent if
+    /// the sign is gone by the time the editor closes.
+    lines: [String; 4],
 }
 
 fn sign_box() -> EditBox {
@@ -33,11 +36,19 @@ fn sign_box() -> EditBox {
 impl Game<'_> {
     /// `SignBlock.openTextEdit` for the front side after placement.
     pub(super) fn open_sign_editor(&mut self, pos: (i32, i32, i32), front: bool) {
+        // Minecraft.setScreen: the editor already open is removed first.
+        self.close_sign_editor();
+        let lines = match self.world.block_entities.get(&pos) {
+            Some(BlockEntity::Sign(sign)) if front => sign.front.lines.clone(),
+            Some(BlockEntity::Sign(sign)) => sign.back.lines.clone(),
+            _ => Default::default(),
+        };
         self.sign_edit = Some(SignEditor {
             pos,
             front,
             line: 0,
             edit: sign_box(),
+            lines,
         });
         self.sign_load();
         self.keys.clear();
@@ -50,14 +61,16 @@ impl Game<'_> {
     pub(super) fn close_sign_editor(&mut self) {
         if let Some(edit) = self.sign_edit.take() {
             if self.remote.is_some() {
-                if let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get(&edit.pos) {
-                    let side = if edit.front { &sign.front } else { &sign.back };
-                    self.send(S::SignUpdate(play::SignUpdate {
-                        pos: [edit.pos.0, edit.pos.1, edit.pos.2],
-                        lines: side.lines.clone(),
-                        front: edit.front,
-                    }));
-                }
+                let lines = match self.world.block_entities.get(&edit.pos) {
+                    Some(BlockEntity::Sign(sign)) if edit.front => sign.front.lines.clone(),
+                    Some(BlockEntity::Sign(sign)) => sign.back.lines.clone(),
+                    _ => edit.lines,
+                };
+                self.send(S::SignUpdate(play::SignUpdate {
+                    pos: [edit.pos.0, edit.pos.1, edit.pos.2],
+                    lines,
+                    front: edit.front,
+                }));
             } else {
                 self.mark_block_entity_updated(edit.pos);
             }
diff --git a/crates/horizon-client/src/signs.rs b/crates/horizon-client/src/signs.rs
index 07217ed79..799210797 100644
--- a/crates/horizon-client/src/signs.rs
+++ b/crates/horizon-client/src/signs.rs
@@ -147,10 +147,10 @@ fn component_text(tag: &Tag) -> String {
                 _ => s,
             }
         }
-        Tag::Compound(_) => match tag.get("text") {
-            Some(Tag::String(t)) => t.to_string_lossy(),
-            _ => String::new(),
-        },
+        // Component.getString: translations and key binds resolved.
+        Tag::Compound(_) => {
+            crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(tag)).plain()
+        }
         _ => String::new(),
     }
 }

From 818b377c02105e8662225a8ec7072867834ed9ef Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:54:32 +0100
Subject: [PATCH 208/475] Add honey drips, poplar and azalea leaves, falling
 dust and campfire food smoke

---
 crates/horizon-client/src/animate_tick.rs     | 148 ++++++++++++++++--
 crates/horizon-client/src/game/render_tick.rs |   5 +
 2 files changed, 142 insertions(+), 11 deletions(-)

diff --git a/crates/horizon-client/src/animate_tick.rs b/crates/horizon-client/src/animate_tick.rs
index 28b28544b..0e0a3319b 100644
--- a/crates/horizon-client/src/animate_tick.rs
+++ b/crates/horizon-client/src/animate_tick.rs
@@ -35,8 +35,9 @@ enum Animate {
     Campfire {
         spawn_particles: bool,
     },
-    /// Leaves: optional falling-leaf particle and chance, tinted by foliage.
-    Leaves(Option<(T, f32)>),
+    /// Leaves: optional falling-leaf particle and chance; a tinted leaf takes
+    /// the biome foliage colour unless a fixed colour is given (azalea).
+    Leaves(Option<(T, f32)>, Option<u32>),
     NetherPortal,
     EnchantingTable,
     EndRod([i32; 3]),
@@ -49,6 +50,8 @@ enum Animate {
     EnderChest,
     /// FallingBlock with its dust colour.
     Falling(u32),
+    /// A beehive or bee nest full of honey (`BeehiveBlock.animateTick`).
+    Beehive,
     RedstoneOre,
     RedstoneWire {
         power: u8,
@@ -104,10 +107,17 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
             spawn_particles: false,
         },
         "oak_leaves" | "birch_leaves" | "jungle_leaves" | "acacia_leaves" | "dark_oak_leaves"
-        | "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01))),
-        "cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1))),
-        "pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02))),
-        "spruce_leaves" | "azalea_leaves" | "flowering_azalea_leaves" => Animate::Leaves(None),
+        | "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01)), None),
+        "cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1)), None),
+        "pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02)), None),
+        "red_poplar_leaves" => Animate::Leaves(Some((T::RedPoplarLeaves, 0.01)), None),
+        "orange_poplar_leaves" => Animate::Leaves(Some((T::OrangePoplarLeaves, 0.01)), None),
+        "yellow_poplar_leaves" => Animate::Leaves(Some((T::YellowPoplarLeaves, 0.01)), None),
+        // The azalea blocks drop tinted leaves of the fixed colour -9399763.
+        "azalea_leaves" | "flowering_azalea_leaves" => {
+            Animate::Leaves(Some((T::TintedLeaves, 0.01)), Some(0x0070_922D))
+        }
+        "spruce_leaves" => Animate::Leaves(None, None),
         "nether_portal" => Animate::NetherPortal,
         "enchanting_table" => Animate::EnchantingTable,
         "end_rod" => Animate::EndRod(facing()),
@@ -119,6 +129,14 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
         "sand" => Animate::Falling(0xDBD3A0),
         "red_sand" => Animate::Falling(0xA95821),
         "gravel" => Animate::Falling(0x807C7B),
+        // AnvilBlock/ConcretePowderBlock.getDustColor is the map colour;
+        // DragonEggBlock's is black.
+        "anvil" | "chipped_anvil" | "damaged_anvil" => Animate::Falling(0xA7A7A7),
+        "dragon_egg" => Animate::Falling(0x000000),
+        _ if name.ends_with("_concrete_powder") => Animate::Falling(concrete_powder_color(
+            name.trim_end_matches("_concrete_powder"),
+        )),
+        "beehive" | "bee_nest" if prop("honey_level").as_deref() == Some("5") => Animate::Beehive,
         "redstone_ore" | "deepslate_redstone_ore" if lit => Animate::RedstoneOre,
         "redstone_wire" => {
             let power = prop("power").and_then(|p| p.parse().ok()).unwrap_or(0);
@@ -161,6 +179,27 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
         _ => Animate::None,
     }
 }
+/// `DyeColor.getMapColor` of a concrete powder colour.
+fn concrete_powder_color(dye: &str) -> u32 {
+    match dye {
+        "white" => 0xFFFFFF,
+        "orange" => 0xD87F33,
+        "magenta" => 0xB24CD8,
+        "light_blue" => 0x6699D8,
+        "yellow" => 0xE5E533,
+        "lime" => 0x7FCC19,
+        "pink" => 0xF27FA5,
+        "gray" => 0x4C4C4C,
+        "light_gray" => 0x999999,
+        "cyan" => 0x4C7F99,
+        "purple" => 0x7F3FB2,
+        "blue" => 0x334CB2,
+        "brown" => 0x664C33,
+        "green" => 0x667F33,
+        "red" => 0x993333,
+        _ => 0x191919,
+    }
+}
 /// `RedstoneWireBlock.COLORS`.
 fn redstone_color(power: u8) -> [f32; 3] {
     let f = f32::from(power) / 15.0;
@@ -504,6 +543,53 @@ fn try_spawn_drip(
         }
     }
 }
+/// `BeehiveBlock.trySpawnDripParticles`.
+fn beehive_drip(
+    tables: &AnimateTables,
+    engine: &mut ParticleEngine,
+    ctx: &AnimateContext,
+    state: BlockStateId,
+    pos: [i32; 3],
+) {
+    if ctx.facts.get(state).fluid != Fluid::None || engine.random().next_float() < 0.3 {
+        return;
+    }
+    let Some((bottom, top, bounds)) = ctx.shape_y(pos) else {
+        return;
+    };
+    if top < 1.0
+        || tables
+            .impermeable
+            .get(state.0 as usize)
+            .copied()
+            .unwrap_or(false)
+    {
+        return;
+    }
+    let y = if bottom > 0.0 {
+        f64::from(pos[1]) + bottom - 0.05
+    } else {
+        let below = [pos[0], pos[1] - 1, pos[2]];
+        let below_top = ctx.shape_y(below).map_or(1.0, |s| s.1);
+        // `belowTop < 1 || !isCollisionShapeFullBlock` and no fluid below.
+        if (below_top < 1.0 || !ctx.sturdy(below))
+            && ctx.facts.get(ctx.state(below)).fluid == Fluid::None
+        {
+            f64::from(pos[1]) - 0.05
+        } else {
+            return;
+        }
+    };
+    let r = engine.random();
+    let (a, b) = (r.next_double(), r.next_double());
+    let (fx, fz) = (f64::from(pos[0]), f64::from(pos[2]));
+    let p = [
+        fx + bounds[0] + (bounds[1] - bounds[0]) * a,
+        y,
+        fz + bounds[2] + (bounds[3] - bounds[2]) * b,
+    ];
+    add(engine, T::DrippingHoney, p, [0.0; 3]);
+}
 /// `WaterFluid.animateTick` / `LavaFluid.animateTick`.
 fn fluid_animate_tick(
     engine: &mut ParticleEngine,
@@ -685,7 +771,7 @@ fn block_animate_tick(
                 }
             }
         }
-        Animate::Leaves(falling) => {
+        Animate::Leaves(falling, fixed_tint) => {
             let below = [pos[0], pos[1] - 1, pos[2]];
             // LeavesBlock.makeDrippingWaterParticles.
             if (ctx.raining_at)([pos[0], pos[1] + 1, pos[2]]) && next_int(engine.random(), 15) == 1
@@ -705,7 +791,7 @@ fn block_animate_tick(
                 let r = engine.random();
                 let p = [fx + r.next_double(), fy - 0.05, fz + r.next_double()];
                 let options = if ty == T::TintedLeaves {
-                    let c = ctx.foliage(pos);
+                    let c = fixed_tint.unwrap_or_else(|| ctx.foliage(pos));
                     let f = |s: u32| ((c >> s) & 255) as f32 / 255.0;
                     ParticleOptions::colored(ty, [f(16), f(8), f(0), 1.0])
                 } else {
@@ -977,6 +1063,13 @@ fn block_animate_tick(
                 }
             }
         }
+        Animate::Beehive => {
+            // BeehiveBlock.animateTick: nextInt(1) + 1 attempts.
+            let attempts = next_int(engine.random(), 1) + 1;
+            for _ in 0..attempts {
+                beehive_drip(tables, engine, ctx, state, pos);
+            }
+        }
         Animate::RedstoneOre => {
             for d in [
                 [0, -1, 0],
@@ -1209,21 +1302,32 @@ fn candle(engine: &mut ParticleEngine, p: [f64; 3]) {
     }
     add(engine, T::SmallFlame, p, [0.0; 3]);
 }
-/// `CampfireBlockEntity.particleTick` for every lit campfire (no cooking items).
+/// `CampfireBlockEntity.particleTick` for every lit campfire; `cooking` says
+/// which of a campfire's four slots hold an item.
 pub fn campfire_particles<'a>(
     tables: &AnimateTables,
     engine: &mut ParticleEngine,
     ctx: &AnimateContext,
     blocks: impl Iterator<Item = &'a ([i32; 3], u32)>,
+    cooking: &dyn Fn([i32; 3]) -> [bool; 4],
 ) {
     for &(pos, state) in blocks {
         if !tables.is_lit_campfire(state) {
             continue;
         }
-        let signal = ctx
+        let properties = ctx
             .registry
             .state(BlockStateId(state))
-            .is_some_and(|s| s.properties.get("signal_fire").map(String::as_str) == Some("true"));
+            .map(|s| &s.properties);
+        let prop = |k: &str| properties.and_then(|p| p.get(k)).map(String::as_str);
+        let signal = prop("signal_fire") == Some("true");
+        // Direction.get2DDataValue: south, west, north, east.
+        let rotation = match prop("facing") {
+            Some("west") => 1,
+            Some("north") => 2,
+            Some("east") => 3,
+            _ => 0,
+        };
         let r = engine.random();
         if r.next_float() < 0.11 {
             let count = next_int(r, 2) + 2;
@@ -1231,6 +1335,28 @@ pub fn campfire_particles<'a>(
                 make_campfire_smoke(engine, pos, signal, false);
             }
         }
+        // The smoke over each cooking item, at the slot's corner of the fire.
+        let occupied = cooking(pos);
+        for (slot, _) in occupied.iter().enumerate().filter(|(_, held)| **held) {
+            if engine.random().next_float() >= 0.2 {
+                continue;
+            }
+            // Direction.from2DDataValue((slot + rotation) % 4) and its clockwise side.
+            let (step, clockwise) = match (slot + rotation) % 4 {
+                0 => ([0.0, 1.0], [-1.0, 0.0]),
+                1 => ([-1.0, 0.0], [0.0, -1.0]),
+                2 => ([0.0, -1.0], [1.0, 0.0]),
+                _ => ([1.0, 0.0], [0.0, 1.0]),
+            };
+            let at = [
+                f64::from(pos[0]) + 0.5 - step[0] * 0.3125 + clockwise[0] * 0.3125,
+                f64::from(pos[1]) + 0.5,
+                f64::from(pos[2]) + 0.5 - step[1] * 0.3125 + clockwise[1] * 0.3125,
+            ];
+            for _ in 0..4 {
+                add(engine, T::Smoke, at, [0.0, 5.0e-4, 0.0]);
+            }
+        }
     }
 }
 /// `CampfireBlock.makeParticles` (always visible, overriding the limiter);
diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs
index e013c8d29..3f5862f49 100644
--- a/crates/horizon-client/src/game/render_tick.rs
+++ b/crates/horizon-client/src/game/render_tick.rs
@@ -7,6 +7,7 @@ use horizon_client::{
     biome::Biomes,
     blocks::{BlockFacts, Fluid},
     chunk::{HEIGHT, MIN_Y},
+    containers::BlockEntity,
     particles::{ParticleLevel, ParticleOptions, ParticleType},
     world::World,
 };
@@ -344,6 +345,10 @@ impl Game<'_> {
                 &mut self.particles,
                 &ctx,
                 r.block_entities(),
+                &|pos| match self.world.block_entities.get(&(pos[0], pos[1], pos[2])) {
+                    Some(BlockEntity::Campfire(c)) => c.items.each_ref().map(Option::is_some),
+                    _ => [false; 4],
+                },
             );
         }
         let level = ParticleLevel {

From 7112d0cd6498c6e16020230a2868e8f0d0ba4e3f Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:55:27 +0100
Subject: [PATCH 209/475] Mobs standing in a wither rose get wither, bees in an
 open eyeblossom get poison

---
 crates/horizon-client/src/mobs/ai.rs | 51 ++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 2676c3a37..189625541 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -413,6 +413,7 @@ pub fn tick(
     super::axolotl::tick_animation(m);
     m.anim.end_tick(m.ai.swinging);
     tick_swing(m);
+    flower_contact_effects(m, w);
     if m.species() == Species::CopperGolem {
         // CopperGolem.tick: updateWeathering after the living tick.
         super::copper_golem::update_weathering(m, w, level_random, events);
@@ -1464,6 +1465,56 @@ pub fn custom_travel(m: &mut Mob, w: &MobWorld, input: Vec3, events: &mut Vec<Mo
     }
 }
 
+/// `Entity.applyEffectsFromBlocks` for the flowers that give an effect:
+/// `WitherRoseBlock.entityInside` (wither for 40 ticks on a living mob that
+/// can take it, not in peaceful) and `EyeblossomBlock.entityInside` (poison
+/// for 25 ticks on a bee, when the open flower attracts bees). The blocks
+/// are those the mob's box touches where it started the tick and where it
+/// ended.
+fn flower_contact_effects(m: &mut Mob, w: &MobWorld) {
+    if !m.alive() || w.difficulty.effective == 0.0 {
+        return;
+    }
+    let half = f64::from(m.width()) / 2.0 - 1.0e-5;
+    let height = f64::from(m.height()) - 1.0e-5;
+    let mut visited: Vec<[i32; 3]> = Vec::new();
+    for at in [m.previous, m.position] {
+        let cells = |lo: f64, hi: f64| lo.floor() as i32..=hi.floor() as i32;
+        for x in cells(at.x - half, at.x + half) {
+            for y in cells(at.y + 1.0e-5, at.y + height) {
+                for z in cells(at.z - half, at.z + half) {
+                    let p = [x, y, z];
+                    if visited.contains(&p) {
+                        continue;
+                    }
+                    match w.block_name(x, y, z) {
+                        "minecraft:wither_rose" => {
+                            // isInvulnerableTo(wither): the invulnerable time
+                            // after a hit; WitherBoss and WitherSkeleton
+                            // refuse the effect (`canBeAffected`).
+                            if m.invulnerable <= 0
+                                && !m.invulnerable_flag
+                                && !matches!(m.species(), Species::Wither | Species::WitherSkeleton)
+                            {
+                                m.add_effect("minecraft:wither", 40, 0);
+                            }
+                        }
+                        "minecraft:open_eyeblossom"
+                            if m.species() == Species::Bee
+                                && super::bee::attracts_bees(w, p)
+                                && !m.has_effect("minecraft:poison") =>
+                        {
+                            m.add_effect("minecraft:poison", 25, 0);
+                        }
+                        _ => continue,
+                    }
+                    visited.push(p);
+                }
+            }
+        }
+    }
+}
+
 /// MobEffect ticking for the effects mobs receive (poison, wither, regeneration).
 fn tick_effects(m: &mut Mob) {
     let mut effects = std::mem::take(&mut m.extra.effects);

From 4ebfaef0d3976c2e003acddeded25c891028d1d4 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:56:07 +0100
Subject: [PATCH 210/475] Slide slowly down the sides of honey blocks

---
 crates/horizon-client/src/game.rs   | 26 +++++++++++++++
 crates/horizon-client/src/motion.rs | 51 +++++++++++++++++++++++++++++
 2 files changed, 77 insertions(+)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index de7eb448b..ab63124d6 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4544,6 +4544,32 @@ impl Game<'_> {
                 MotionEvent::Fall(event) => self.landing_block_updates(&event),
                 MotionEvent::Snowflake { position, velocity } => self.snowflake(position, velocity),
                 MotionEvent::EnterBlock { state } => self.trigger_enter_block(state),
+                MotionEvent::HoneySlide {
+                    pos,
+                    sound,
+                    particles,
+                } => {
+                    if sound {
+                        self.audio
+                            .play("minecraft:block.honey_block.slide", Some(feet), 1.0, 1.0);
+                    }
+                    // HoneyBlock.showSlideParticles: five block particles.
+                    if particles
+                        && let Some((sprite, tint)) = self.particle_sprite(
+                            self.world.block(pos.x, pos.y, pos.z),
+                            [pos.x, pos.y, pos.z],
+                        )
+                    {
+                        use horizon_client::particles::{ParticleOptions, ParticleType};
+                        for _ in 0..5 {
+                            self.particles.add(
+                                &ParticleOptions::block(ParticleType::Block, sprite.clone(), tint),
+                                feet,
+                                [0.0; 3],
+                            );
+                        }
+                    }
+                }
                 MotionEvent::InsidePortal { pos } => self.player_inside_nether_portal(pos),
                 MotionEvent::CauldronExtinguish { pos } => self.cauldron_extinguish(pos),
                 MotionEvent::InsideWitherRose => self.wither_rose_contact(),
diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index fcdd32cbd..04341b66f 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -203,6 +203,14 @@ pub enum MotionEvent {
         bubble: bool,
         position: Vec3,
     },
+    /// `HoneyBlock.maybeDoSlideEffects` for a player sliding down the side of
+    /// the honey block at `pos`: its slide sound, and the client's five
+    /// block particles (entity event 53) at the player.
+    HoneySlide {
+        pos: BlockPos,
+        sound: bool,
+        particles: bool,
+    },
     /// Entity event 67 (`LivingEntity.makeDrownParticles`): eight bubbles
     /// around a drowning player.
     Drown,
@@ -1386,6 +1394,7 @@ impl MotionWorld<'_, '_, '_> {
                         entered.push((step, p));
                     }
                     "minecraft:cobweb" => self.web_inside(),
+                    "minecraft:honey_block" => self.honey_block_inside(p)?,
                     "minecraft:sweet_berry_bush" => self.sweet_berry_bush_inside(state)?,
                     "minecraft:bubble_column" => {
                         let precise = moved_far || deflated.intersects(Aabb::block(p));
@@ -1403,6 +1412,48 @@ impl MotionWorld<'_, '_, '_> {
         }
         Ok(iterations + 1)
     }
+    /// `HoneyBlock.entityInside`: a falling player touching a side of the block
+    /// slides down it (`isSlidingDown`, `doSlideMovement`, `maybeDoSlideEffects`).
+    fn honey_block_inside(&mut self, pos: BlockPos) -> Result<()> {
+        let old_delta_y = |dy: f64| dy / f64::from(0.98_f32) + 0.08;
+        let new_delta_y = |dy: f64| (dy - 0.08) * f64::from(0.98_f32);
+        let position = self.player.position;
+        let velocity = self.player.velocity;
+        if self.player.ground.on_ground
+            || position.y > f64::from(pos.y) + 0.9375 - 1.0e-7
+            || old_delta_y(velocity.y) >= -0.08
+        {
+            return Ok(());
+        }
+        let dx = (f64::from(pos.x) + 0.5 - position.x).abs();
+        let dz = (f64::from(pos.z) + 0.5 - position.z).abs();
+        let overlap = 0.4375 + f64::from(self.player.dimensions.width / 2.0);
+        if !(dx + 1.0e-7 > overlap || dz + 1.0e-7 > overlap) {
+            return Ok(());
+        }
+        // doSlideMovement
+        let old = old_delta_y(velocity.y);
+        if old < -0.13 {
+            let factor = -0.05 / old;
+            self.player.velocity =
+                Vec3::new(velocity.x * factor, new_delta_y(-0.05), velocity.z * factor);
+        } else {
+            self.player.velocity = Vec3::new(velocity.x, new_delta_y(-0.05), velocity.z);
+        }
+        self.player.fall_distance = 0.0;
+        // maybeDoSlideEffects: the sound, then the server's event 53.
+        let random = &mut self.scene.random;
+        let sound = random.next_int_bound(5).map_err(|e| format!("{e:?}"))? == 0;
+        let particles = random.next_int_bound(5).map_err(|e| format!("{e:?}"))? == 0;
+        if sound || particles {
+            self.player.events.push(MotionEvent::HoneySlide {
+                pos,
+                sound,
+                particles,
+            });
+        }
+        Ok(())
+    }
     /// `Player.makeStuckInBlock`: the next move is scaled by `multiplier`
     /// (and the fall forgotten) unless flying; the impulse context resets
     /// either way.

From e7e6e5bc07556c8c4e15fcda5768517007001e59 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:56:22 +0100
Subject: [PATCH 211/475] Scale entity tracking range by
 entity-broadcast-range-percentage

The property was parsed and ignored. The tracking range of each entity type is now scaled by it on a dedicated server, like DedicatedServer.getScaledTrackingDistance.
---
 crates/horizon-client/src/game/dedicated.rs |  3 +++
 crates/horizon-client/src/lan/entity.rs     | 14 ++++++++++----
 crates/horizon-client/src/lan/hub.rs        |  4 ++++
 3 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/game/dedicated.rs b/crates/horizon-client/src/game/dedicated.rs
index fa5365195..49b653ae1 100644
--- a/crates/horizon-client/src/game/dedicated.rs
+++ b/crates/horizon-client/src/game/dedicated.rs
@@ -654,6 +654,9 @@ impl Game<'_> {
         // DedicatedServer.initServer ends with saveEverything(false, true, true).
         self.save_game()?;
         self.log_saved_levels();
+        if let Some(host) = self.lan.as_mut() {
+            host.hub.entity_range_percent = props.entity_broadcast_range_percentage;
+        }
         let mut state = ServerState {
             lists,
             console,
diff --git a/crates/horizon-client/src/lan/entity.rs b/crates/horizon-client/src/lan/entity.rs
index ae3089006..920052b5a 100644
--- a/crates/horizon-client/src/lan/entity.rs
+++ b/crates/horizon-client/src/lan/entity.rs
@@ -611,8 +611,9 @@ pub struct Viewer<'a> {
 }
 
 /// One entity as this tick's range checks read it: where it is
-/// horizontally, its id, its type's tracking range in chunks and the chunk
-/// it is in (an index into the tick's chunks).
+/// horizontally, its id, its tracking range in blocks (scaled by
+/// `entity-broadcast-range-percentage`) and the chunk it is in (an index
+/// into the tick's chunks).
 #[derive(Clone, Copy)]
 struct Probe {
     x: f64,
@@ -627,7 +628,7 @@ struct Probe {
 /// each of the tick's chunks whether the client has it (0: not looked up
 /// yet, 1: no, 2: yes), so each chunk is looked up once per client.
 fn sees(v: &Viewer, p: &Probe, chunks: &[(i32, i32)], held: &mut [u8]) -> bool {
-    let range = f64::from(p.range.min(v.view_distance) * 16);
+    let range = f64::from(p.range.min(v.view_distance * 16));
     let (dx, dz) = (v.position[0] - p.x, v.position[2] - p.z);
     dx * dx + dz * dz <= range * range && {
         let held = &mut held[p.chunk as usize];
@@ -641,6 +642,9 @@ fn sees(v: &Viewer, p: &Probe, chunks: &[(i32, i32)], held: &mut [u8]) -> bool {
 /// One level's tracked entities (ChunkMap.entityMap).
 #[derive(Default)]
 pub struct Entities {
+    /// `entity-broadcast-range-percentage` (None: 100), which scales every
+    /// type's tracking range (MinecraftServer.getScaledTrackingDistance).
+    pub range_percent: Option<i32>,
     states: crate::fast_hash::FxHashMap<i32, ServerEntity>,
     /// The level tick, stamped on every entity still in the level.
     tick: u32,
@@ -732,7 +736,9 @@ impl Entities {
                 x: e.position[0],
                 z: e.position[2],
                 id: e.id,
-                range: s.range,
+                range: self
+                    .range_percent
+                    .map_or(s.range * 16, |p| p * (s.range * 16) / 100),
                 chunk,
             });
         }
diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs
index b1a8cbc62..ac0530d86 100644
--- a/crates/horizon-client/src/lan/hub.rs
+++ b/crates/horizon-client/src/lan/hub.rs
@@ -168,6 +168,8 @@ pub struct Hub {
     level_sync: std::collections::HashMap<String, LevelSync>,
     /// Operators and their permission levels (dedicated servers).
     pub ops: std::collections::HashMap<u128, u8>,
+    /// `entity-broadcast-range-percentage` (dedicated servers).
+    pub entity_range_percent: i32,
     chat_type: i32,
     dimension_type: i32,
     clock_ids: Vec<i32>,
@@ -332,6 +334,7 @@ impl Hub {
             ticking: (20.0, false),
             stepping: 0,
             ops: Default::default(),
+            entity_range_percent: 100,
             weather: (false, 0.0, 0.0),
             level_sync: Default::default(),
             chat_type,
@@ -1678,6 +1681,7 @@ impl Hub {
                 out,
             })
             .collect();
+        level.range_percent = Some(self.entity_range_percent);
         let (types, sync) = (&mut self.entity_types, &self.sync);
         level.tick(&entities, &self.riding, &mut viewers, |kind| {
             entity_type(types, sync, kind)

From 5a70691d63980600cd6de1fc03b6ad0c03c02e60 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:56:39 +0100
Subject: [PATCH 212/475] Show the note particle above a note block when it
 plays

---
 crates/horizon-client/src/game.rs          | 25 ++++++++++++++++++++++
 crates/horizon-world/src/level/redstone.rs |  9 +++++++-
 2 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index de7eb448b..118256915 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -3085,6 +3085,31 @@ impl Game<'_> {
                 LevelEvent::BlockEntityEvent { pos, a, b, .. } => {
                     self.block_entity_event([pos.x, pos.y, pos.z], a, b)
                 }
+                // NoteBlock.triggerEvent: a NOTE particle above, coloured by
+                // the note (`note / 24.0` in the x speed).
+                LevelEvent::BlockEvent {
+                    pos,
+                    state,
+                    kind: "note_particle",
+                } => {
+                    use horizon_client::particles::{ParticleOptions, ParticleType};
+                    let note = self
+                        .pack
+                        .assets
+                        .registry
+                        .state(state)
+                        .and_then(|s| s.properties.get("note")?.parse::<f64>().ok())
+                        .unwrap_or(0.0);
+                    self.particles.add(
+                        &ParticleOptions::simple(ParticleType::Note),
+                        [
+                            f64::from(pos.x) + 0.5,
+                            f64::from(pos.y) + 1.2,
+                            f64::from(pos.z) + 0.5,
+                        ],
+                        [note / 24.0, 0.0, 0.0],
+                    );
+                }
                 LevelEvent::GrowTree { .. }
                 | LevelEvent::PlaceFeature { .. }
                 | LevelEvent::BlockEvent { .. } => {}
diff --git a/crates/horizon-world/src/level/redstone.rs b/crates/horizon-world/src/level/redstone.rs
index a2a02081f..3965a57a2 100644
--- a/crates/horizon-world/src/level/redstone.rs
+++ b/crates/horizon-world/src/level/redstone.rs
@@ -1108,7 +1108,8 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
             self.game_event(pos, "minecraft:note_block_play");
         }
     }
-    /// `NoteBlock.triggerEvent`: the note's sound.
+    /// `NoteBlock.triggerEvent`: the note's particle (tunable instruments)
+    /// and sound.
     pub(crate) fn note_trigger_event(&mut self, pos: BlockPos, state: BlockStateId) {
         let b = self.b;
         let instrument = b.table.text(state, b.props.instrument).to_owned();
@@ -1120,6 +1121,12 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
         let pitch = if mob_head {
             1.0
         } else {
+            // `isTunable`: the client adds the NOTE particle above the block.
+            self.emit(LevelEvent::BlockEvent {
+                pos,
+                state,
+                kind: "note_particle",
+            });
             horizon_core::jmath::pow(2.0, f64::from(note - 12) / 12.0) as f32
         };
         let sound = match instrument.as_str() {

From dbd24e2e16534cbdadb9cd56118d987d25b0ec07 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:57:02 +0100
Subject: [PATCH 213/475] A creaking heart blown up by an explosion makes its
 creaking die

---
 crates/horizon-client/src/game.rs           | 2 +-
 crates/horizon-client/src/game/creaking.rs  | 7 ++++---
 crates/horizon-client/src/game/explosion.rs | 5 +++++
 3 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index a51bdcbcb..0ebf5bfaf 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -3493,7 +3493,7 @@ impl Game<'_> {
         } else if let Some(tag) = spill::saved_entity(&self.world, pos) {
             self.pending.record_saved(pos, &tag);
         }
-        self.creaking_heart_broken(pos);
+        self.creaking_heart_broken(pos, true);
         let hive = match self.world.block_entities.get(&key) {
             Some(BlockEntity::Beehive(h)) => self.hive_state(pos).map(|s| ((**h).clone(), s)),
             _ => None,
diff --git a/crates/horizon-client/src/game/creaking.rs b/crates/horizon-client/src/game/creaking.rs
index c75325c2f..19b3442c2 100644
--- a/crates/horizon-client/src/game/creaking.rs
+++ b/crates/horizon-client/src/game/creaking.rs
@@ -218,8 +218,9 @@ impl Game<'_> {
         );
     }
     /// `CreakingHeartBlock.playerWillDestroy`: the heart's creaking twitches to
-    /// death and a natural heart drops experience.
-    pub(super) fn creaking_heart_broken(&mut self, pos: [i32; 3]) {
+    /// death and a natural heart drops experience. `onExplosionHit` does the
+    /// same for the creaking (`by_player` false), without the experience.
+    pub(super) fn creaking_heart_broken(&mut self, pos: [i32; 3], by_player: bool) {
         let key = (pos[0], pos[1], pos[2]);
         if !matches!(
             self.world.block_entities.get(&key),
@@ -242,7 +243,7 @@ impl Game<'_> {
             .state(state)
             .and_then(|s| s.properties.get("natural").cloned())
             .is_some_and(|v| v == "true");
-        if natural && !self.creative && !self.spectator() {
+        if by_player && natural && !self.creative && !self.spectator() {
             let xp = 20 + self.world.random.next_int_bound(5).unwrap_or(0) as u32;
             self.spawn_orbs(
                 [
diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs
index 8800e29d8..886310d91 100644
--- a/crates/horizon-client/src/game/explosion.rs
+++ b/crates/horizon-client/src/game/explosion.rs
@@ -599,6 +599,11 @@ impl Game<'_> {
         }
         let name = self.res.facts().get(state).name.clone();
         let is_tnt = &*name == "minecraft:tnt";
+        // CreakingHeartBlock.onExplosionHit: its creaking dies (no
+        // experience, as Horizon does not track a TNT's owner).
+        if &*name == "minecraft:creaking_heart" {
+            self.creaking_heart_broken(pos, false);
+        }
         // Block.onExplosionHit: the drops copy from the block entity, which
         // then spills its contents as the block turns to air.
         let key = (pos[0], pos[1], pos[2]);

From 9e848670dbb543e2e0338b0290804390fd6cd577 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:57:11 +0100
Subject: [PATCH 214/475] Send swimming, gliding, fire, invisible and glowing
 for LAN players

---
 crates/horizon-client/src/game/lan.rs  | 11 +++-
 crates/horizon-client/src/lan/hub.rs   | 77 ++++++++++++++++++++++----
 crates/horizon-client/tests/lan_bot.rs |  1 +
 3 files changed, 78 insertions(+), 11 deletions(-)

diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..4ccbb0ec8 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -11,7 +11,7 @@ use horizon_client::{
         chunks::ChunkEncoder,
         data::SyncData,
         entity::{EntityState, States},
-        hub::{HostEvent, HostState, Hub, HubConfig, TickCtx},
+        hub::{BodyFlags, HostEvent, HostState, Hub, HubConfig, TickCtx},
         playerdata,
     },
     mobs::{Mob, Who, leash::Holder},
@@ -835,6 +835,15 @@ impl Game<'_> {
             living_flags: living_flags(self.using)
                 | if p.auto_spin_attack_ticks > 0 { 4 } else { 0 },
             bed: self.sleeping,
+            body: BodyFlags {
+                gliding: p.fall_flying,
+                swimming: p.swimming,
+                crawling: p.pose == horizon_client::pose::Pose::Swimming && !p.swimming,
+                spin_attack: p.auto_spin_attack_ticks > 0,
+                on_fire: p.fire_ticks > 0,
+                invisible: self.potions.effects.get("invisibility").is_some(),
+                glowing: self.potions.effects.get("glowing").is_some(),
+            },
         })
     }
 
diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs
index b1a8cbc62..c3a18ee86 100644
--- a/crates/horizon-client/src/lan/hub.rs
+++ b/crates/horizon-client/src/lan/hub.rs
@@ -87,6 +87,27 @@ pub struct HostState {
     pub living_flags: i8,
     /// The bed the host sleeps in (`LivingEntity.SLEEPING_POS`).
     pub bed: Option<[i32; 3]>,
+    pub body: BodyFlags,
+}
+
+/// What the other players see of a player's body besides sneaking and
+/// sprinting: the pose and the rest of `Entity.DATA_SHARED_FLAGS_ID`.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct BodyFlags {
+    /// `Entity.isFallFlying`: gliding with elytra.
+    pub gliding: bool,
+    /// `Entity.isSwimming` (the swimming flag).
+    pub swimming: bool,
+    /// The swimming pose of a player crawling under a block.
+    pub crawling: bool,
+    /// `LivingEntity.isAutoSpinAttack`: Riptide's spin.
+    pub spin_attack: bool,
+    /// `Entity.isOnFire`.
+    pub on_fire: bool,
+    /// `Entity.isInvisible`: the invisibility effect.
+    pub invisible: bool,
+    /// The glowing effect.
+    pub glowing: bool,
 }
 
 /// Everything the hub needs from the game for one tick.
@@ -1507,7 +1528,8 @@ impl Hub {
         position: [f64; 3],
         rot: (f32, f32, f32),
         on_ground: bool,
-        flags: (bool, bool, bool, bool),
+        flags: (bool, bool, bool),
+        body: BodyFlags,
         living_flags: i8,
         bed: Option<[i32; 3]>,
         skin: u8,
@@ -1515,12 +1537,18 @@ impl Hub {
         equipment: Vec<(u8, Option<horizon_protocol::item::Stack>)>,
         attributes: Vec<play::AttributeSnapshot>,
     ) -> EntityState {
-        let (sneaking, sprinting, gliding, sleeping) = flags;
-        let shared = shared_flags(sneaking, sprinting, gliding);
+        let (sneaking, sprinting, sleeping) = flags;
+        let shared = shared_flags(sneaking, sprinting, &body);
+        // Player.getDesiredPose (and updatePlayerPose's crawl): sleeping,
+        // swimming, gliding, Riptide's spin, crouching.
         let pose = if sleeping {
             2
-        } else if gliding {
+        } else if body.swimming || body.crawling {
+            3
+        } else if body.gliding {
             1
+        } else if body.spin_attack {
+            4
         } else if sneaking {
             5
         } else {
@@ -1607,7 +1635,8 @@ impl Hub {
                 h.position,
                 (h.yaw, h.pitch, h.head_yaw),
                 h.on_ground,
-                (h.sneaking, h.sprinting, false, h.bed.is_some()),
+                (h.sneaking, h.sprinting, h.bed.is_some()),
+                h.body,
                 h.living_flags,
                 h.bed,
                 0x7F,
@@ -1639,7 +1668,8 @@ impl Hub {
                     g.position,
                     (g.yaw, g.pitch, g.head_yaw),
                     g.on_ground,
-                    (g.sneaking, g.sprinting, g.fall_flying, g.sleeping),
+                    (g.sneaking, g.sprinting, g.sleeping),
+                    guest_body(g),
                     g.living_flags,
                     g.bed,
                     g.info.model_customisation,
@@ -1798,7 +1828,7 @@ impl Hub {
         // too, so the sprint a hit stops (Player.causeExtraKnockback) stops
         // on its client.
         let g = &mut self.guests[i];
-        let shared = shared_flags(g.sneaking, g.sprinting, g.fall_flying);
+        let shared = shared_flags(g.sneaking, g.sprinting, &guest_body(g));
         if shared != g.sent_shared {
             g.sent_shared = shared;
             g.send(&C::SetEntityData(play::SetEntityData {
@@ -2578,16 +2608,43 @@ fn ticking_state(rate: f32, frozen: bool) -> C {
     raw(ids::TICKING_STATE, w.data)
 }
 
-/// Entity.DATA_SHARED_FLAGS_ID of a player: crouching, sprinting, gliding.
-fn shared_flags(sneaking: bool, sprinting: bool, gliding: bool) -> i8 {
+/// What the others see of a guest's body, from its server-side state.
+fn guest_body(g: &Guest) -> BodyFlags {
+    let m = g.motion.as_deref();
+    BodyFlags {
+        gliding: g.fall_flying,
+        swimming: m.is_some_and(|m| m.swimming),
+        crawling: m.is_some_and(|m| m.pose == crate::pose::Pose::Swimming && !m.swimming),
+        spin_attack: m.is_some_and(|m| m.auto_spin_attack_ticks > 0),
+        on_fire: m.is_some_and(|m| m.fire_ticks > 0),
+        invisible: g.effects.get("invisibility").is_some(),
+        glowing: g.effects.get("glowing").is_some(),
+    }
+}
+
+/// Entity.DATA_SHARED_FLAGS_ID of a player: on fire 0x01, crouching 0x02,
+/// sprinting 0x08, swimming 0x10, invisible 0x20, glowing 0x40, gliding 0x80.
+fn shared_flags(sneaking: bool, sprinting: bool, body: &BodyFlags) -> i8 {
     let mut shared = 0i8;
+    if body.on_fire {
+        shared |= 0x01;
+    }
     if sneaking {
         shared |= 0x02;
     }
     if sprinting {
         shared |= 0x08;
     }
-    if gliding {
+    if body.swimming {
+        shared |= 0x10;
+    }
+    if body.invisible {
+        shared |= 0x20;
+    }
+    if body.glowing {
+        shared |= 0x40;
+    }
+    if body.gliding {
         shared |= -128;
     }
     shared
diff --git a/crates/horizon-client/tests/lan_bot.rs b/crates/horizon-client/tests/lan_bot.rs
index 34e8265a1..c4ed2884b 100644
--- a/crates/horizon-client/tests/lan_bot.rs
+++ b/crates/horizon-client/tests/lan_bot.rs
@@ -186,6 +186,7 @@ impl Server {
             attributes: Vec::new(),
             bed: None,
             living_flags: 0,
+            body: Default::default(),
         };
         let mut ctx = TickCtx {
             world: &mut self.world,

From 00cb813dc88ff067912e574ae02c7fcbc6cd10b3 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:57:18 +0100
Subject: [PATCH 215/475] Show the missing item tooltip lines in vanilla order

Custom names are italic. Unbreakable, dyed, written book author and
generation, music disc songs, goat horn instruments, loaded crossbow
projectiles, hive bees and honey, the potion "When Applied" block and
enchantment attribute modifiers (Efficiency V gives +26 Mining Efficiency)
now appear, and advanced tooltips (F3+H) end with the item id and the
component count. Attribute lines use the attribute's sentiment colour.
---
 crates/horizon-client/src/enchant.rs       |  26 ++
 crates/horizon-client/src/game/stations.rs | 253 +++++++++++++----
 crates/horizon-client/src/item_tooltip.rs  | 311 ++++++++++++++++++---
 crates/horizon-client/src/items.rs         |   6 +
 4 files changed, 498 insertions(+), 98 deletions(-)

diff --git a/crates/horizon-client/src/enchant.rs b/crates/horizon-client/src/enchant.rs
index 2f418ae82..73b9bf090 100644
--- a/crates/horizon-client/src/enchant.rs
+++ b/crates/horizon-client/src/enchant.rs
@@ -545,6 +545,32 @@ impl Enchantments {
         }
         out
     }
+    /// `EnchantmentHelper.forEachModifier` as an item's tooltip lists them: the
+    /// `minecraft:attributes` effects of `stack`'s enchantments as rows of
+    /// (attribute, id, amount, operation, slot group), one per slot group the
+    /// enchantment lists.
+    pub fn modifier_rows(&self, stack: &ItemStack) -> Vec<(String, String, f64, String, String)> {
+        let mut rows = Vec::new();
+        for (id, level) in stack.enchantments() {
+            let Some(e) = self.get(id) else { continue };
+            for a in e.effects["minecraft:attributes"]
+                .as_array()
+                .into_iter()
+                .flatten()
+            {
+                for slot in &e.slots {
+                    rows.push((
+                        a["attribute"].as_str().unwrap_or("").to_owned(),
+                        a["id"].as_str().unwrap_or("").to_owned(),
+                        f64::from(level_value(&a["amount"], *level)),
+                        a["operation"].as_str().unwrap_or("add_value").to_owned(),
+                        slot.clone(),
+                    ));
+                }
+            }
+        }
+        rows
+    }
     /// Sum of `add_value` amounts of one attribute from enchantments on `stack`.
     pub fn attribute_add(&self, stack: Option<&ItemStack>, attribute: &str) -> f64 {
         stack.map_or(0.0, |s| {
diff --git a/crates/horizon-client/src/game/stations.rs b/crates/horizon-client/src/game/stations.rs
index 56b19e393..686ad0c02 100644
--- a/crates/horizon-client/src/game/stations.rs
+++ b/crates/horizon-client/src/game/stations.rs
@@ -277,6 +277,10 @@ fn argb(c: i32) -> u32 {
     )
 }
 
+/// A text style's `0xRRGGBB` colour from a HUD colour (`rgba`).
+fn rgb_of(rgba: u32) -> u32 {
+    (rgba & 0xFF) << 16 | (rgba >> 8 & 0xFF) << 8 | (rgba >> 16 & 0xFF)
+}
 impl Game<'_> {
     /// `Component.translatable`: the selected language (which `lang` layers
     /// over `en_us`), the caller's English text last.
@@ -1689,20 +1693,34 @@ impl Game<'_> {
         &self,
         stack: &ItemStack,
     ) -> Vec<(horizon_client::text::Text, u32)> {
-        let e: &Enchantments = &self.res.stations().enchantments;
-        let props = e.props(&stack.item);
+        self.stack_tooltip_lines(stack, false)
+    }
+    /// `ItemStack.getRarity`'s colour for the name line and a `[name]` link.
+    fn rarity_color(&self, stack: &ItemStack) -> u32 {
+        let props = self.res.stations().enchantments.props(&stack.item);
         let rarity = horizon_client::item_tooltip::rarity(
             stack,
             props.map_or("common", |p| p.rarity.as_str()),
         );
-        let color = match rarity {
+        match rarity {
             "uncommon" => rgba(255, 255, 85, 255),
             "rare" => rgba(85, 255, 255, 255),
             "epic" => rgba(255, 85, 255, 255),
             _ => u32::MAX,
-        };
-        let name = if let Some(n) = stack.custom_name() {
+        }
+    }
+    /// `ItemStack.getHoverName`: the custom name, a written book's title, the
+    /// item name component, else the item's or potion's name.
+    fn stack_hover_name(&self, stack: &ItemStack) -> String {
+        if let Some(n) = stack.custom_name() {
             n.to_owned()
+        } else if let Some(title) = stack
+            .data()
+            .and_then(|d| d.written.as_ref())
+            .map(|w| w.title.as_str())
+            .filter(|t| !t.trim().is_empty())
+        {
+            title.to_owned()
         } else if let Some(n) = stack.item_name() {
             n
         } else if stack.data().is_some_and(|d| d.ominous_banner) {
@@ -1718,16 +1736,47 @@ impl Game<'_> {
                 .unwrap_or_else(|| self.pack.names.display_item(&stack.item))
         } else {
             self.pack.names.display_item(&stack.item)
-        };
+        }
+    }
+    /// `ItemStack.getTooltipLines`. A `nested` stack is a crossbow's
+    /// projectile: `ChargedProjectiles.addProjectileTooltip` takes its details
+    /// without the name, the player and the advanced flag.
+    fn stack_tooltip_lines(
+        &self,
+        stack: &ItemStack,
+        nested: bool,
+    ) -> Vec<(horizon_client::text::Text, u32)> {
+        let e: &Enchantments = &self.res.stations().enchantments;
+        let color = self.rarity_color(stack);
+        let advanced = !nested && self.options_advanced_tooltips();
         let display = horizon_client::item_tooltip::TooltipDisplay::for_stack(stack);
         let mut lines = Vec::new();
-        if display.name_visible(self.screen == Screen::Creative) {
-            lines.push((horizon_client::text::Text::legacy(&name), color));
+        if !nested && display.name_visible(self.screen == Screen::Creative) {
+            // `getStyledHoverName`: a custom name is italic.
+            let name = self.stack_hover_name(stack);
+            let name = if stack.custom_name().is_some() {
+                horizon_client::text::Text::literal(name).italic()
+            } else {
+                horizon_client::text::Text::legacy(&name)
+            };
+            lines.push((name, color));
         }
         let translate = |k: &str| self.pack.names.display_get(k);
         let push = |lines: &mut Vec<(horizon_client::text::Text, u32)>, s: String, c: u32| {
             lines.push((horizon_client::text::Text::legacy(&s), c));
         };
+        let gray = rgba(170, 170, 170, 255);
+        let item_info = self.res.items().get(&stack.item);
+        // InstrumentComponent.addToTooltip.
+        if let Some(text) =
+            horizon_client::item_tooltip::instrument_line(stack, &display, &translate)
+        {
+            push(&mut lines, text, gray);
+        }
+        // Bees.addToTooltip.
+        if let Some(text) = horizon_client::item_tooltip::bees_line(stack, &display, &translate) {
+            push(&mut lines, text, gray);
+        }
         // ItemContainerContents.addToTooltip.
         let hover_name = |s: &ItemStack| {
             s.custom_name()
@@ -1742,6 +1791,70 @@ impl Game<'_> {
                 push(&mut lines, text, u32::MAX);
             }
         }
+        // BannerPatternLayers.addToTooltip: up to six layer names.
+        if display.shows("minecraft:banner_patterns") {
+            for layer in horizon_client::banner::tooltip_layers(stack).iter().take(6) {
+                let key = self.res.stations().banners.layer_key(layer);
+                push(
+                    &mut lines,
+                    self.translate(&key, &key),
+                    rgba(170, 170, 170, 255),
+                );
+            }
+        }
+        // WrittenBookContent.addToTooltip.
+        for text in horizon_client::item_tooltip::written_book_lines(stack, &display, &translate) {
+            push(&mut lines, text, gray);
+        }
+        // ChargedProjectiles.addToTooltip: each run of equal projectiles, then
+        // the projectile's own details indented under it.
+        if display.shows("minecraft:charged_projectiles") {
+            let charged = stack.data().map_or(&[][..], |d| &d.charged[..]);
+            for run in charged.chunk_by(|a, b| a.same_item_same_components(b)) {
+                let projectile = &run[0];
+                let name = self.stack_hover_name(projectile);
+                let line = if run.len() == 1 {
+                    // `getDisplayName`: `[name]` in the rarity colour.
+                    let mut shown = horizon_client::text::Text::literal(format!("[{name}]"))
+                        .with_color(rgb_of(self.rarity_color(projectile)));
+                    if projectile.custom_name().is_some() {
+                        shown = shown.italic();
+                    }
+                    horizon_client::text::format_translation(
+                        &self.translate(
+                            "item.minecraft.crossbow.projectile.single",
+                            "Projectile: %s",
+                        ),
+                        &[shown],
+                    )
+                } else {
+                    horizon_client::text::format_translation(
+                        &self.translate(
+                            "item.minecraft.crossbow.projectile.multiple",
+                            "Projectile: %s x %s",
+                        ),
+                        &[
+                            horizon_client::text::Text::literal(run.len().to_string()),
+                            horizon_client::text::Text::literal(name),
+                        ],
+                    )
+                };
+                lines.push((line, u32::MAX));
+                for (text, c) in self.stack_tooltip_lines(projectile, true) {
+                    // `literal("  ").append(line).withStyle(GRAY)`: the line's
+                    // own colours win over the gray.
+                    let rgb = if c == u32::MAX {
+                        horizon_client::text::GRAY
+                    } else {
+                        rgb_of(c)
+                    };
+                    let indented = horizon_client::text::Text::literal("  ")
+                        .append(text)
+                        .with_color(rgb);
+                    lines.push((indented, u32::MAX));
+                }
+            }
+        }
         // Fireworks / FireworkExplosion.addToTooltip.
         for text in horizon_client::item_tooltip::firework_lines(stack, &translate) {
             push(&mut lines, text, rgba(170, 170, 170, 255));
@@ -1764,6 +1877,17 @@ impl Game<'_> {
                 };
                 push(&mut lines, text, c);
             }
+            // The attribute modifiers of the effects (`When Applied:`).
+            for (text, c) in horizon_client::item_tooltip::potion_modifier_lines(stack, &translate)
+            {
+                push(&mut lines, text, c);
+            }
+        }
+        // JukeboxPlayable.addToTooltip.
+        if let Some(text) =
+            horizon_client::item_tooltip::jukebox_line(stack, item_info, &display, &translate)
+        {
+            push(&mut lines, text, gray);
         }
         if display.shows("minecraft:trim")
             && let Some((material, pattern)) = stack.data().and_then(|d| d.trim.clone())
@@ -1811,16 +1935,12 @@ impl Game<'_> {
                 );
             }
         }
-        // BannerPatternLayers.addToTooltip: up to six layer names.
-        if display.shows("minecraft:banner_patterns") {
-            for layer in horizon_client::banner::tooltip_layers(stack).iter().take(6) {
-                let key = self.res.stations().banners.layer_key(layer);
-                push(
-                    &mut lines,
-                    self.translate(&key, &key),
-                    rgba(170, 170, 170, 255),
-                );
-            }
+        // DyedItemColor.addToTooltip.
+        if let Some((text, italic)) =
+            horizon_client::item_tooltip::dyed_line(stack, &display, advanced, &translate)
+        {
+            let text = horizon_client::text::Text::legacy(&text);
+            lines.push((if italic { text.italic() } else { text }, gray));
         }
         // ItemLore.addToTooltip: after the enchantments, before the attributes
         // (ItemStack.addDetailsToTooltip).
@@ -1829,6 +1949,50 @@ impl Game<'_> {
                 lines.push((text, u32::MAX));
             }
         }
+        if display.shows("minecraft:attribute_modifiers") {
+            // The item's own modifiers, then its enchantments' for each slot
+            // group (`ItemStack.forEachModifier`).
+            let mut modifiers = item_info.map(|i| i.modifiers.clone()).unwrap_or_default();
+            modifiers.extend(e.modifier_rows(stack));
+            let base = |name: &str, default| {
+                self.player
+                    .as_ref()
+                    .and_then(|player| {
+                        let key = player.attributes.key(name)?;
+                        let handle = player.attributes.lookup(Some(&key))?;
+                        player
+                            .attributes
+                            .instance(&handle)
+                            .ok()
+                            .map(|value| value.base_value())
+                    })
+                    .unwrap_or(default)
+            };
+            let player_base = (!nested).then(|| {
+                [
+                    base("minecraft:attack_damage", 1.0),
+                    base(
+                        "minecraft:attack_speed",
+                        horizon_client::attack_strength::BASE_ATTACK_SPEED,
+                    ),
+                ]
+            });
+            for (text, c) in
+                horizon_client::item_tooltip::attribute_lines(&modifiers, player_base, &translate)
+            {
+                push(&mut lines, text, c);
+            }
+        }
+        // ItemStack.UNBREAKABLE_TOOLTIP.
+        if let Some(text) =
+            horizon_client::item_tooltip::unbreakable_line(stack, &display, &translate)
+        {
+            push(&mut lines, text, rgba(85, 85, 255, 255));
+        }
+        // BlockItemStateProperties.addToTooltip.
+        if let Some(text) = horizon_client::item_tooltip::honey_line(stack, &display, &translate) {
+            push(&mut lines, text, gray);
+        }
         // Spawner.appendHoverText: what a spawner or trial spawner item spawns.
         if display.shows("minecraft:block_entity_data")
             && matches!(
@@ -1852,43 +2016,11 @@ impl Game<'_> {
                 }
             }
         }
-        if display.shows("minecraft:attribute_modifiers")
-            && let Some(info) = self.res.items().get(&stack.item)
-        {
-            let base = |name: &str, default| {
-                self.player
-                    .as_ref()
-                    .and_then(|player| {
-                        let key = player.attributes.key(name)?;
-                        let handle = player.attributes.lookup(Some(&key))?;
-                        player
-                            .attributes
-                            .instance(&handle)
-                            .ok()
-                            .map(|value| value.base_value())
-                    })
-                    .unwrap_or(default)
-            };
-            let player_base = [
-                base("minecraft:attack_damage", 1.0),
-                base(
-                    "minecraft:attack_speed",
-                    horizon_client::attack_strength::BASE_ATTACK_SPEED,
-                ),
-            ];
-            for (text, c) in horizon_client::item_tooltip::attribute_lines(
-                &info.modifiers,
-                Some(player_base),
-                &translate,
-            ) {
-                push(&mut lines, text, c);
-            }
-        }
         if display.shows("minecraft:damage")
-            && let Some(info) = self.res.items().get(&stack.item)
+            && let Some(info) = item_info
             && info.max_damage > 0
             && stack.damage > 0
-            && self.options_advanced_tooltips()
+            && advanced
         {
             push(
                 &mut lines,
@@ -1900,8 +2032,23 @@ impl Game<'_> {
                 u32::MAX,
             );
         }
+        // ItemStack.addDetailsToTooltipTail: with advanced tooltips the item id
+        // and how many components the stack has.
+        if advanced {
+            let dark_gray = rgba(85, 85, 85, 255);
+            push(&mut lines, stack.item.to_string(), dark_gray);
+            let count = horizon_client::item_tooltip::component_count(stack, item_info);
+            if count > 0 {
+                let text = self.translate("item.components", "%s component(s)");
+                push(
+                    &mut lines,
+                    text.replacen("%s", &count.to_string(), 1),
+                    dark_gray,
+                );
+            }
+        }
         // ItemStack.OP_NBT_WARNING, for a player with game master permission.
-        if self.ui.registries.permission >= 2 && block_entity_item::op_warning(stack) {
+        if !nested && self.ui.registries.permission >= 2 && block_entity_item::op_warning(stack) {
             for (key, fallback) in [
                 ("item.op_warning.line1", "Warning:"),
                 (
diff --git a/crates/horizon-client/src/item_tooltip.rs b/crates/horizon-client/src/item_tooltip.rs
index 88f01439e..63a19b114 100644
--- a/crates/horizon-client/src/item_tooltip.rs
+++ b/crates/horizon-client/src/item_tooltip.rs
@@ -108,6 +108,32 @@ fn modifier_line(
     )
 }
 
+/// `Attribute.getStyle`: the colour of a line for an attribute whose value
+/// rises or falls. Gravity, scale and the waypoint ranges are neutral, burning
+/// time and fall damage are negative, every other attribute is positive.
+fn attribute_color(attribute: &str, rises: bool) -> u32 {
+    let (blue, red) = (rgba(85, 85, 255, 255), rgba(255, 85, 85, 255));
+    match attribute {
+        "burning_time" | "fall_damage_multiplier" => {
+            if rises {
+                red
+            } else {
+                blue
+            }
+        }
+        "gravity" | "scale" | "waypoint_transmit_range" | "waypoint_receive_range" => {
+            rgba(170, 170, 170, 255)
+        }
+        _ => {
+            if rises {
+                blue
+            } else {
+                red
+            }
+        }
+    }
+}
+
 /// `ItemStack.addAttributeTooltips`: slot groups, colors and optional player
 /// attack damage/speed bases. Recipe search has no player context.
 pub fn attribute_lines(
@@ -150,10 +176,8 @@ pub fn attribute_lines(
             ) {
                 let (line, color) = if base.is_some() {
                     (format!(" {line}"), rgba(0, 170, 0, 255))
-                } else if *amount > 0.0 {
-                    (line, rgba(85, 85, 255, 255))
                 } else {
-                    (line, rgba(255, 85, 85, 255))
+                    (line, attribute_color(path, *amount > 0.0))
                 };
                 lines.push((line, color));
             }
@@ -231,6 +255,235 @@ pub fn rarity<'a>(stack: &ItemStack, default: &'a str) -> &'a str {
     }
 }
 
+fn is_beehive(path: &str) -> bool {
+    matches!(path, "beehive" | "bee_nest")
+}
+
+/// `InstrumentComponent.addToTooltip`: the instrument's description. A goat
+/// horn without the component has the item's default, the ponder horn.
+pub fn instrument_line(
+    stack: &ItemStack,
+    display: &TooltipDisplay,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Option<String> {
+    if !display.shows("minecraft:instrument") {
+        return None;
+    }
+    let id = match stack.data().and_then(|d| d.other("minecraft:instrument")) {
+        Some(Tag::String(id)) => id.to_string_lossy(),
+        // An inline instrument carries its own description.
+        Some(inline) => {
+            return inline
+                .get("description")
+                .map(|d| crate::entity_nbt::name_text(d).plain());
+        }
+        None if &*stack.item == "minecraft:goat_horn" => "minecraft:ponder_goat_horn".to_owned(),
+        None => return None,
+    };
+    let key = format!("instrument.{}", id.replacen(':', ".", 1));
+    Some(translate(&key).unwrap_or(key))
+}
+
+/// `Bees.addToTooltip`: how many bees a hive item holds (a hive item without
+/// the component has the item's default, none).
+pub fn bees_line(
+    stack: &ItemStack,
+    display: &TooltipDisplay,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Option<String> {
+    if !display.shows("minecraft:bees") {
+        return None;
+    }
+    let bees = match stack.data().and_then(|d| d.other("minecraft:bees")) {
+        Some(Tag::List(bees)) => bees.len(),
+        Some(_) => return None,
+        None if is_beehive(stack.item.trim_start_matches("minecraft:")) => 0,
+        None => return None,
+    };
+    let text =
+        translate("container.beehive.bees").unwrap_or_else(|| "container.beehive.bees".into());
+    Some(
+        text.replacen("%s", &bees.to_string(), 1)
+            .replacen("%s", "3", 1),
+    )
+}
+
+/// `BlockItemStateProperties.addToTooltip`: a hive item's honey level (a hive
+/// item without the component has the item's default, 0).
+pub fn honey_line(
+    stack: &ItemStack,
+    display: &TooltipDisplay,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Option<String> {
+    if !display.shows("minecraft:block_state") {
+        return None;
+    }
+    let level = match stack.data().and_then(|d| d.other("minecraft:block_state")) {
+        Some(Tag::Compound(state)) => {
+            match state.get(&horizon_world::nbt::JavaString::from("honey_level")) {
+                Some(Tag::String(level)) => level.to_string_lossy().parse::<u32>().ok()?,
+                _ => return None,
+            }
+        }
+        Some(_) => return None,
+        None if is_beehive(stack.item.trim_start_matches("minecraft:")) => 0,
+        None => return None,
+    };
+    let text =
+        translate("container.beehive.honey").unwrap_or_else(|| "container.beehive.honey".into());
+    Some(
+        text.replacen("%s", &level.to_string(), 1)
+            .replacen("%s", "5", 1),
+    )
+}
+
+/// `WrittenBookContent.addToTooltip`: "by <author>" and the generation.
+pub fn written_book_lines(
+    stack: &ItemStack,
+    display: &TooltipDisplay,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Vec<String> {
+    let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned());
+    let Some(book) = stack
+        .data()
+        .and_then(|d| d.written.as_ref())
+        .filter(|_| display.shows("minecraft:written_book_content"))
+    else {
+        return Vec::new();
+    };
+    let mut lines = Vec::new();
+    if !book.author.trim().is_empty() {
+        lines.push(
+            crate::text::format_translation(
+                &text("book.byAuthor"),
+                &[crate::text::Text::literal(&book.author)],
+            )
+            .plain(),
+        );
+    }
+    lines.push(text(&format!("book.generation.{}", book.generation)));
+    lines
+}
+
+/// `JukeboxPlayable.addToTooltip`: the song's description.
+pub fn jukebox_line(
+    stack: &ItemStack,
+    info: Option<&ItemInfo>,
+    display: &TooltipDisplay,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Option<String> {
+    if !display.shows("minecraft:jukebox_playable") {
+        return None;
+    }
+    let song = match stack
+        .data()
+        .and_then(|d| d.other("minecraft:jukebox_playable"))
+    {
+        Some(Tag::String(song)) => song.to_string_lossy(),
+        // An inline song carries its own description.
+        Some(inline) => {
+            return inline
+                .get("description")
+                .map(|d| crate::entity_nbt::name_text(d).plain());
+        }
+        None => info?.jukebox_song.clone()?,
+    };
+    let key = format!("jukebox_song.{}", song.replacen(':', ".", 1));
+    Some(translate(&key).unwrap_or(key))
+}
+
+/// `DyedItemColor.addToTooltip`: "Dyed" (italic, the flag), or with advanced
+/// tooltips the colour's hex code.
+pub fn dyed_line(
+    stack: &ItemStack,
+    display: &TooltipDisplay,
+    advanced: bool,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Option<(String, bool)> {
+    let rgb = stack.data()?.dyed_color?;
+    if !display.shows("minecraft:dyed_color") {
+        return None;
+    }
+    let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned());
+    Some(if advanced {
+        let hex = format!("#{:06X}", rgb & 0xFF_FFFF);
+        (text("item.color").replacen("%s", &hex, 1), false)
+    } else {
+        (text("item.dyed"), true)
+    })
+}
+
+/// `ItemStack.UNBREAKABLE_TOOLTIP`.
+pub fn unbreakable_line(
+    stack: &ItemStack,
+    display: &TooltipDisplay,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Option<String> {
+    (stack.data()?.other("minecraft:unbreakable").is_some()
+        && display.shows("minecraft:unbreakable"))
+    .then(|| translate("item.unbreakable").unwrap_or_else(|| "item.unbreakable".into()))
+}
+
+/// `PotionContents.addPotionTooltip`'s attribute block: an empty line, "When
+/// Applied:" and the modifiers of the potion's effects (blue for a gain, red
+/// for a loss); nothing for a potion whose effects add none.
+pub fn potion_modifier_lines(
+    stack: &ItemStack,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Vec<(String, u32)> {
+    if !is_potion_item(&stack.item) {
+        return Vec::new();
+    }
+    let applied: Vec<(String, u32)> = stack
+        .potion()
+        .and_then(crate::brewing::potion)
+        .into_iter()
+        .flat_map(|p| p.effects.iter())
+        .filter_map(|(effect, _, amplifier)| {
+            let (attribute, amount, operation) = effect_modifier(effect)?;
+            let amount = amount * (*amplifier + 1) as f64;
+            let line = modifier_line(translate, attribute, amount, operation, false)?;
+            let color = if amount > 0.0 {
+                rgba(85, 85, 255, 255)
+            } else {
+                rgba(255, 85, 85, 255)
+            };
+            Some((line, color))
+        })
+        .collect();
+    if applied.is_empty() {
+        return applied;
+    }
+    let mut lines = vec![
+        (String::new(), u32::MAX),
+        (
+            translate("potion.whenDrank").unwrap_or_else(|| "potion.whenDrank".into()),
+            rgba(170, 0, 170, 255),
+        ),
+    ];
+    lines.extend(applied);
+    lines
+}
+
+/// `ItemStack.components.size()`: the item's default components with the
+/// stack's own changes applied.
+pub fn component_count(stack: &ItemStack, info: Option<&ItemInfo>) -> usize {
+    let mut keys: std::collections::HashSet<String> = info
+        .map(|i| i.components.iter().cloned().collect())
+        .unwrap_or_default();
+    if let Some(Tag::Compound(patch)) = crate::item_data::components_tag(stack.damage, stack.data())
+    {
+        for key in patch.keys() {
+            let key = key.to_string_lossy();
+            match key.strip_prefix('!') {
+                Some(removed) => keys.remove(removed),
+                None => keys.insert(key),
+            };
+        }
+    }
+    keys.len()
+}
+
 /// The lines of `stack` below its name that its components give, in
 /// `ItemStack.addDetailsToTooltip` order.
 pub fn detail_lines(
@@ -265,19 +518,9 @@ pub fn detail_lines(
             ))
         ));
     }
-    // BeehiveBlock: the block state components of the item.
-    if path == "beehive" {
-        lines.push(
-            text("container.beehive.bees")
-                .replacen("%s", "0", 1)
-                .replacen("%s", "3", 1),
-        );
-        lines.push(
-            text("container.beehive.honey")
-                .replacen("%s", "0", 1)
-                .replacen("%s", "5", 1),
-        );
-    }
+    let display = TooltipDisplay::for_stack(stack);
+    lines.extend(bees_line(stack, &display, translate));
+    lines.extend(honey_line(stack, &display, translate));
     let data = stack.data();
     // PotDecorations.addToTooltip.
     if let Some(sherds) = data
@@ -303,32 +546,13 @@ pub fn detail_lines(
                 .into_iter()
                 .map(|l| l.0),
         );
-        let applied: Vec<String> = stack
-            .potion()
-            .and_then(crate::brewing::potion)
-            .into_iter()
-            .flat_map(|p| p.effects.iter())
-            .filter_map(|(effect, _, amplifier)| {
-                let (attribute, amount, operation) = effect_modifier(effect)?;
-                modifier_line(
-                    translate,
-                    attribute,
-                    amount * (*amplifier + 1) as f64,
-                    operation,
-                    false,
-                )
-            })
-            .collect();
-        if !applied.is_empty() {
-            lines.push(String::new());
-            lines.push(text("potion.whenDrank"));
-            lines.extend(applied);
-        }
-    }
-    // JukeboxPlayable.addToTooltip: the song's description.
-    if path.starts_with("music_disc_") {
-        lines.push(text(&format!("item.minecraft.{path}.desc")));
+        lines.extend(
+            potion_modifier_lines(stack, translate)
+                .into_iter()
+                .map(|l| l.0),
+        );
     }
+    lines.extend(jukebox_line(stack, info, &display, translate));
     // Trim.addToTooltip.
     if let Some((material, pattern)) = data.and_then(|d| d.trim.as_ref()) {
         let short = |s: &str| s.trim_start_matches("minecraft:").to_owned();
@@ -342,10 +566,7 @@ pub fn detail_lines(
             text(&format!("trim_material.minecraft.{}", short(material)))
         ));
     }
-    // DyedItemColor.addToTooltip (without advanced tooltips).
-    if data.is_some_and(|d| d.dyed_color.is_some()) {
-        lines.push(text("item.dyed"));
-    }
+    lines.extend(dyed_line(stack, &display, false, translate).map(|l| l.0));
     if let Some(info) = info {
         lines.extend(
             attribute_lines(&info.modifiers, None, translate)
diff --git a/crates/horizon-client/src/items.rs b/crates/horizon-client/src/items.rs
index b4092a201..1749f8243 100644
--- a/crates/horizon-client/src/items.rs
+++ b/crates/horizon-client/src/items.rs
@@ -128,6 +128,8 @@ pub struct ItemInfo {
     pub block_transformer: Option<String>,
     /// Has a default `bundle_contents` (the bundles, `BundleItem`).
     pub bundle: bool,
+    /// The ids of the item's default components (its prototype's keys).
+    pub components: Vec<String>,
 }
 /// `Item.Properties.craftRemainder` (not a data component, so not in the
 /// default-component report): what an item leaves in the grid when crafted with.
@@ -614,6 +616,10 @@ impl Items {
                     cushion_color: c["minecraft:cushion/color"].as_str().map(str::to_owned),
                     block_transformer: c["minecraft:block_transformer"].as_str().map(str::to_owned),
                     bundle: c.get("minecraft:bundle_contents").is_some(),
+                    components: c
+                        .as_object()
+                        .map(|c| c.keys().cloned().collect())
+                        .unwrap_or_default(),
                     crafting_remainder: CRAFT_REMAINDERS
                         .iter()
                         .find(|(item, _)| *item == name)

From 85db9a23a942a5110d099771535edc7818467753 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:57:54 +0100
Subject: [PATCH 216/475] Use the small explosion particle when an explosion
 keeps blocks

---
 crates/horizon-client/src/game/explosion.rs    | 18 +++++++++---------
 .../horizon-client/src/game/lan_particles.rs   | 10 ++++++++--
 crates/horizon-client/src/particles.rs         |  9 +++++----
 3 files changed, 22 insertions(+), 15 deletions(-)

diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs
index 8800e29d8..5d6b4eb4f 100644
--- a/crates/horizon-client/src/game/explosion.rs
+++ b/crates/horizon-client/src/game/explosion.rs
@@ -573,16 +573,16 @@ impl Game<'_> {
         let pitch = (1.0 + (client_float() - client_float()) * 0.2) * 0.7;
         self.audio
             .play("minecraft:entity.generic.explode", Some(center), 4.0, pitch);
-        let block_count = if interaction == BlockInteraction::Keep {
-            0
-        } else {
-            targets.len()
-        };
+        // ServerLevel.explode sends toBlow.size() whatever the interaction, and
+        // `ServerExplosion.isSmall` also covers an explosion that keeps blocks.
+        let block_count = targets.len();
+        let small = radius < 2.0 || interaction == BlockInteraction::Keep;
         let (world, facts) = (&self.world, self.res.facts());
-        self.particles.explosion(center, radius, block_count, &|b| {
-            facts.is_air(world.block(b[0], b[1], b[2]))
-        });
-        self.lan_explode(center, radius, block_count);
+        self.particles
+            .explosion(center, small, block_count, radius, &|b| {
+                facts.is_air(world.block(b[0], b[1], b[2]))
+            });
+        self.lan_explode(center, small, radius, block_count);
         Ok(())
     }
     /// `BlockBehaviour.onExplosionHit` (TNT: `wasExploded` primes a short fuse).
diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs
index c41fdf1ad..0095da624 100644
--- a/crates/horizon-client/src/game/lan_particles.rs
+++ b/crates/horizon-client/src/game/lan_particles.rs
@@ -225,8 +225,14 @@ impl Game<'_> {
     /// `ServerLevel.explode`'s packet to each player within 64 blocks. The
     /// sound and the push reach them on their own (the level's sounds, the
     /// motion a hurt player is sent), so the packet carries neither.
-    pub(super) fn lan_explode(&self, center: [f64; 3], radius: f32, block_count: usize) {
-        let emitter = if radius < 2.0 {
+    pub(super) fn lan_explode(
+        &self,
+        center: [f64; 3],
+        small: bool,
+        radius: f32,
+        block_count: usize,
+    ) {
+        let emitter = if small {
             "minecraft:explosion"
         } else {
             "minecraft:explosion_emitter"
diff --git a/crates/horizon-client/src/particles.rs b/crates/horizon-client/src/particles.rs
index fa9dc9c6e..2e28603c4 100644
--- a/crates/horizon-client/src/particles.rs
+++ b/crates/horizon-client/src/particles.rs
@@ -1381,16 +1381,17 @@ impl ParticleEngine {
         }
     }
     /// `ClientPacketListener.handleExplosion` + `ClientExplosionTracker`: the
-    /// explosion particle (emitter for radius >= 2) and up to 512 poof/smoke
-    /// particles thrown from air inside the radius.
+    /// explosion particle (the emitter unless `ServerExplosion.isSmall`) and up
+    /// to 512 poof/smoke particles thrown from air inside the radius.
     pub fn explosion(
         &mut self,
         center: [f64; 3],
-        radius: f32,
+        small: bool,
         block_count: usize,
+        radius: f32,
         is_air: &dyn Fn([i32; 3]) -> bool,
     ) {
-        let ty = if radius < 2.0 {
+        let ty = if small {
             ParticleType::Explosion
         } else {
             ParticleType::ExplosionEmitter

From 4efa49ae820f957164aa5ad05eaaab18e8403f91 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:58:22 +0100
Subject: [PATCH 217/475] Raise sprint dust under running players

A sprinting player kicks up dust of the block under their feet every tick
(Entity.spawnSprintParticle). Horizon drew none, for the window's player
or for the other players it sees.
---
 .../horizon-client/src/game/client_ambient.rs | 91 +++++++++++++++++++
 crates/horizon-client/src/game/lan.rs         |  1 +
 crates/horizon-client/src/game/remote.rs      |  7 +-
 crates/horizon-client/src/mobs.rs             |  2 +
 4 files changed, 98 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game/client_ambient.rs b/crates/horizon-client/src/game/client_ambient.rs
index a10c6da49..b655aff3f 100644
--- a/crates/horizon-client/src/game/client_ambient.rs
+++ b/crates/horizon-client/src/game/client_ambient.rs
@@ -4,8 +4,12 @@
 //! on the game that has the window, in-frame or following a server, never on
 //! a server: nothing of them goes over the network.
 use super::Game;
+use horizon_client::blocks::RenderShape;
 use horizon_client::mobs::{MobEvent, ambient};
+use horizon_client::motion::{LAVA, WATER};
 use horizon_client::particles::{ParticleOptions, ParticleType};
+use horizon_client::pose::Pose;
+use horizon_core::{geometry::Vec3, random::RandomSource};
 
 impl Game<'_> {
     pub(super) fn tick_client_ambient(&mut self) {
@@ -33,5 +37,92 @@ impl Game<'_> {
             }
         }
         self.eye_particles();
+        self.sprint_dust();
+    }
+
+    /// `Entity.baseTick`'s `spawnSprintParticle` on a client: dust of the
+    /// block under a sprinting player's feet streams back from them every
+    /// tick, for the window's own player and for the other players it sees.
+    fn sprint_dust(&mut self) {
+        // Each runner's feet, movement and supporting block.
+        let mut runners: Vec<(Vec3, Vec3, Option<[i32; 3]>)> = Vec::new();
+        // Entity.canSpawnSprintParticle.
+        if let Some(p) = self.player.as_ref()
+            && p.sprinting
+            && !p.spectator
+            && p.pose != Pose::Crouching
+            && !p.health.dead_or_dying()
+            && !p.fluids.was_touching_water
+            && !p.is_in_lava()
+            && p.fluid_height(WATER) <= 0.0
+            && p.fluid_height(LAVA) <= 0.0
+        {
+            let support = p.ground.supporting_block.map(|b| [b.x, b.y, b.z]);
+            runners.push((p.position, p.velocity, support));
+        }
+        let guests = self.lan.iter().flat_map(|host| host.models.values());
+        for m in self.mobs.iter().chain(guests) {
+            // Another player's fluids aren't known here: none where they stand.
+            let feet = [
+                m.position.x.floor() as i32,
+                m.position.y.floor() as i32,
+                m.position.z.floor() as i32,
+            ];
+            if m.extra.sprinting
+                && !m.extra.crouching
+                && m.alive()
+                && &*m.kind.id == "minecraft:player"
+                && self
+                    .res
+                    .facts()
+                    .get(self.world.block(feet[0], feet[1], feet[2]))
+                    .fluid_level
+                    == 0
+            {
+                runners.push((m.position, m.position.subtract(m.previous), None));
+            }
+        }
+        for (position, movement, support) in runners {
+            // Entity.getOnPosLegacy: getOnPos(0.2).
+            let below = (position.y - f64::from(0.2f32)).floor() as i32;
+            let tall = |game: &Self, s: [i32; 3]| {
+                let name = game.block_name(s);
+                [
+                    "minecraft:fences",
+                    "minecraft:walls",
+                    "minecraft:fence_gates",
+                ]
+                .iter()
+                .any(|tag| game.block_in_tag(tag, &name))
+            };
+            let at = match support {
+                Some(s) if tall(self, s) => s,
+                Some(s) => [s[0], below, s[2]],
+                None => [position.x.floor() as i32, below, position.z.floor() as i32],
+            };
+            let state = self.world.block(at[0], at[1], at[2]);
+            if self.res.facts().get(state).render_shape == RenderShape::Invisible {
+                continue;
+            }
+            let Some((sprite, tint)) = self.particle_sprite(state, at) else {
+                continue;
+            };
+            let width = f64::from(0.6f32);
+            let r = self.particles.random();
+            let mut x = position.x + (r.next_double() - 0.5) * width;
+            let mut z = position.z + (r.next_double() - 0.5) * width;
+            // Clamped into the block when the feet are in another column.
+            if position.x.floor() as i32 != at[0] {
+                x = x.clamp(f64::from(at[0]), f64::from(at[0]) + 1.0);
+            }
+            if position.z.floor() as i32 != at[2] {
+                z = z.clamp(f64::from(at[2]), f64::from(at[2]) + 1.0);
+            }
+            self.particles.add(
+                &ParticleOptions::block(ParticleType::Block, sprite, tint),
+                [x, position.y + 0.1, z],
+                [movement.x * -4.0, 1.5, movement.z * -4.0],
+            );
+        }
     }
 }
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..0ee6c961d 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -1409,6 +1409,7 @@ impl Game<'_> {
                 .each_ref()
                 .map(|s| s.as_ref().map(|s| s.item.clone()));
             m.extra.crouching = g.sneaking;
+            m.extra.sprinting = g.sprinting;
             // Lying in its bed (LivingEntity.getBedOrientation).
             m.extra.ints[1] = g.bed.map_or(0, |b| self.bed_facing(b));
             // LivingEntity.updateSwingTime: the arm swing lan_swings started.
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3cfbd15e3..23dc6c2f8 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -1973,9 +1973,9 @@ impl Game<'_> {
                         }
                     }
                 }
-                // Entity.DATA_SHARED_FLAGS_ID's crouching bit: another
-                // player's or a mannequin's crouch (their model and
-                // Entity.isDiscrete's name tag).
+                // Entity.DATA_SHARED_FLAGS_ID's crouching and sprinting bits:
+                // another player's or a mannequin's crouch (their model and
+                // Entity.isDiscrete's name tag), and the dust a runner raises.
                 if (mannequin
                     || self
                         .remote
@@ -1986,6 +1986,7 @@ impl Game<'_> {
                     for (index, _, value) in &p.values {
                         if let (0, Value::Byte(flags)) = (index, value) {
                             m.extra.crouching = flags & 2 != 0;
+                            m.extra.sprinting = flags & 8 != 0;
                         }
                     }
                 }
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 6b1e16f5c..ffeb145eb 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -636,6 +636,8 @@ pub struct Attrs {
 pub struct Extra {
     /// Players: crouching and riding (HumanoidModel's poses).
     pub crouching: bool,
+    /// Players: sprinting (`Entity.DATA_SHARED_FLAGS_ID`), for the dust they raise.
+    pub sprinting: bool,
     pub passenger: bool,
     /// AgeableMob.age: negative while a baby (a tadpole counts up to 24000).
     pub age: i32,

From d241c54e059bbb9274f8e2c1b2a1db6e3f62e815 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 19:58:45 +0100
Subject: [PATCH 218/475] Official mod: Recipes, a recipe viewer

Every item sits in the item panel beside the inventory and container
screens, with a search box (words in the name or id, @namespace, #tag).
R or a click shows an item's recipes, U or a right click its uses, with a
tab per station; Back returns through the pages. + beside a crafting
recipe the player knows fills the grid as the recipe book does. In
creative mode, with "Click gives items" on, a click gives one item and a
right click a stack. The keys are rebindable in Controls.

Written from vanilla 26.3's recipe book and screens and Horizon's design
system only. On servers that are not Horizon it shows the game's own
26.3 recipes; known recipes and + follow the server's recipe book.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.lock                             |   7 +
 Cargo.toml                             |   2 +-
 docs/mods.md                           |   5 +-
 mods/official/recipes/Cargo.toml       |  16 ++
 mods/official/recipes/horizon-mod.toml |   9 +
 mods/official/recipes/src/lib.rs       | 364 +++++++++++++++++++++++++
 6 files changed, 400 insertions(+), 3 deletions(-)
 create mode 100644 mods/official/recipes/Cargo.toml
 create mode 100644 mods/official/recipes/horizon-mod.toml
 create mode 100644 mods/official/recipes/src/lib.rs

diff --git a/Cargo.lock b/Cargo.lock
index 0e93bba0e..4d48c48cb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2962,6 +2962,13 @@ dependencies = [
  "objc2-quartz-core 0.3.2",
 ]
 
+[[package]]
+name = "recipes"
+version = "1.0.0"
+dependencies = [
+ "horizon-mod-sdk",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.4.1"
diff --git a/Cargo.toml b/Cargo.toml
index e4628f962..f6ff38ad8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [workspace]
 exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"]
-members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/zoom", "xtask"]
+members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/recipes", "mods/official/zoom", "xtask"]
 resolver = "2"
 
 [workspace.package]
diff --git a/docs/mods.md b/docs/mods.md
index 706e48bd6..4c7ba012a 100644
--- a/docs/mods.md
+++ b/docs/mods.md
@@ -15,7 +15,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3.
 | The contract (WIT) | `crates/horizon-mod-sdk/wit/horizon.wit` | 0.1: log, game-read, chat, hud, storage, command, ui; tick, frame, chat and command hooks |
 | SDK for mod authors | `crates/horizon-mod-sdk` | 0.1 |
 | Example mods | `crates/horizon-mod-sdk/examples/coords-hud`, `examples/predator-missile` | coordinates, facing and time HUD, `/where`, `/coords`; `/missile`, a guided missile from vanilla commands |
-| Horizon's official mods | `mods/official/` | the extras moving to the registry: FPS Counter (`fps-overlay`), Keystrokes, Zoom, Minimap |
+| Horizon's official mods | `mods/official/` | the extras moving to the registry: FPS Counter (`fps-overlay`), Keystrokes, Zoom, Minimap; and Recipes, a recipe viewer |
 | Runtime | `crates/horizon-mods` | wasmtime 48 LTS, component model |
 | Authoring tool | `crates/cargo-horizon-mod` | `cargo horizon-mod new [--template code\|content] / build / run / test / check`, and the registry's CI (`registry build / review / list`) |
 | In the game | `crates/horizon-client/src/game/mods.rs`, Options > Mods | client mods |
@@ -521,7 +521,7 @@ says how). The formats: [api/mod-index.md](api/mod-index.md).
 
 ### Horizon's official mods
 
-The Horizon extras that are mods now live in `mods/official/<name>/`, one crate each in the game's workspace, so
+The Horizon extras that are mods now, and Horizon's own recipe viewer, live in `mods/official/<name>/`, one crate each in the game's workspace, so
 `cargo clippy --workspace` and pr_ready cover them. They use only the public API, like any other mod, with the same
 options on their settings page as the extra had and the same look. Each is published by a maintainer: build it on
 `main` with the toolchain CI uses (`cd mods/official/<name> && cargo horizon-mod build`), then open a pull request in
@@ -535,6 +535,7 @@ so the same rustc and `Cargo.lock` give the same file.
 | Keystrokes | `keystrokes` | Extras > Keystrokes | `corner`: as above, default `top_left`; `cps`: `true` (default), `false` |
 | Zoom | `zoom` | Extras > Zoom | `level`: `2`, `3`, `4` (default), `6`, `8`, `10`; `smooth`: `true` (default), `false`; `sensitivity` (slower turning): `true` (default), `false`. The key is the game's: `key.zoom.zoom` in `horizon-mods.txt`, default `key.keyboard.z` |
 | Minimap | `minimap` | Extras > Minimap | `corner`: as above, default `top_right`; `size`: `64`, `96` (default), `128`; `shape`: `square` (default), `round`; `zoom` (blocks per pixel): `0.5`, `1` (default), `2`, `4`; `rotate`: `false` (default), `true`. The game draws the map (`render.set-minimap`) |
+| Recipes | `recipes` | nothing (new) | `give` (a click on the item panel gives the item in creative mode: one, a stack with a right click): `false` (default), `true`. The keys are the game's: `key.recipes.recipe` (default `key.keyboard.r`) and `key.recipes.uses` (default `key.keyboard.u`) in `horizon-mods.txt`. Every item sits in the item panel (`browser`) with a search box (words in the name or id, `@namespace`, `#tag`); R or a click shows an item's recipes, U or a right click its uses, a tab per station, and + fills the grid with a recipe the player knows (`recipes.place`). On servers that are not Horizon it shows the game's own 26.3 recipes; known recipes and + follow the server's recipe book |
 
 ## Versions and compatibility
 
diff --git a/mods/official/recipes/Cargo.toml b/mods/official/recipes/Cargo.toml
new file mode 100644
index 000000000..5bf0f5d9c
--- /dev/null
+++ b/mods/official/recipes/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "recipes"
+version = "1.0.0"
+edition.workspace = true
+license.workspace = true
+publish = false
+description = "Horizon's official recipe viewer: every item beside the inventory, its recipes and uses."
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+horizon-mod-sdk = { path = "../../../crates/horizon-mod-sdk" }
+
+[lints]
+workspace = true
diff --git a/mods/official/recipes/horizon-mod.toml b/mods/official/recipes/horizon-mod.toml
new file mode 100644
index 000000000..f4c04af0d
--- /dev/null
+++ b/mods/official/recipes/horizon-mod.toml
@@ -0,0 +1,9 @@
+id = "recipes"
+name = "Recipes"
+version = "1.0.0"
+description = "Every item beside your inventory, with a search box. R over an item shows its recipes, U its uses (both rebindable in Controls), and + fills the crafting grid with a recipe you know. In creative mode a click can give you the item (Mod settings). On servers that are not Horizon, it shows this game's own 26.3 recipes; what you know and what + can fill follow the server's recipe book."
+authors = ["Horizon"]
+api = "0.1"
+side = "client"
+capabilities = ["recipes", "ui", "input", "game-read", "chat", "storage"]
+experimental = ["recipes", "ui", "input"]
diff --git a/mods/official/recipes/src/lib.rs b/mods/official/recipes/src/lib.rs
new file mode 100644
index 000000000..42f856016
--- /dev/null
+++ b/mods/official/recipes/src/lib.rs
@@ -0,0 +1,364 @@
+//! Horizon's official recipe viewer. Every item sits in the item panel the
+//! game draws beside the inventory and container screens (`browser`), with
+//! a search box. R over an item, the panel's or any slot's, shows its
+//! recipes, U its uses (`input.register-key`, so both can be rebound in
+//! Controls); a click does the same, left for recipes and right for uses.
+//! A recipe page has a tab per station, and + beside a crafting recipe the
+//! player knows fills the grid as the recipe book does (`recipes.place`).
+//! In creative mode, with "Click gives items" on, a click on a panel item
+//! gives one, a right click a stack (`recipes.give`).
+//!
+//! On a server that is not Horizon the recipes are the game's own 26.3
+//! ones; `known` and `place` follow the server's recipe book.
+use horizon_mod_sdk::{
+    Mod, Registration, browser, chat, game, input, recipes,
+    recipes::Kind,
+    storage,
+    ui::{self, ButtonWidget, Widget},
+};
+
+const RECIPE_KEY: &str = "recipe";
+const USES_KEY: &str = "uses";
+const GIVE_BUTTON: u32 = 1;
+/// What `set-recipes` takes at most.
+const MAX_RECIPES: usize = 256;
+const MAX_STACKS: usize = 64;
+/// The stations, in the order of their tabs, with each one's icon.
+const STATIONS: [&str; 8] = [
+    "minecraft:crafting_table",
+    "minecraft:furnace",
+    "minecraft:blast_furnace",
+    "minecraft:smoker",
+    "minecraft:campfire",
+    "minecraft:stonecutter",
+    "minecraft:smithing_table",
+    "minecraft:brewing_stand",
+];
+
+fn station(kind: Kind) -> usize {
+    match kind {
+        Kind::CraftingShaped | Kind::CraftingShapeless => 0,
+        Kind::Smelting => 1,
+        Kind::Blasting => 2,
+        Kind::Smoking => 3,
+        Kind::Campfire => 4,
+        Kind::Stonecutting => 5,
+        Kind::Smithing => 6,
+        Kind::Brewing => 7,
+    }
+}
+
+fn stack(item: &str) -> browser::Stack {
+    browser::Stack {
+        item: item.into(),
+        count: 1,
+        components: String::new(),
+    }
+}
+
+/// A recipe page: an item's recipes or its uses, on one station's tab.
+#[derive(Clone)]
+struct View {
+    item: browser::Stack,
+    uses: bool,
+    tab: usize,
+}
+
+#[derive(Default)]
+struct Recipes {
+    items: Vec<recipes::Item>,
+    all: Vec<recipes::Recipe>,
+    /// The panel's items now: indexes into `items`, after the search.
+    listed: Vec<usize>,
+    search: String,
+    /// The page shown, then the ones Back returns to.
+    history: Vec<View>,
+    /// The book id behind each recipe the page shows (-1: none).
+    shown: Vec<i32>,
+    give: bool,
+}
+
+impl Recipes {
+    fn id(&self, s: &recipes::Stack) -> &str {
+        self.items
+            .get(s.item as usize)
+            .map_or("minecraft:air", |i| &i.id)
+    }
+    fn convert(&self, s: &recipes::Stack) -> browser::Stack {
+        browser::Stack {
+            item: self.id(s).into(),
+            count: s.count,
+            components: s.components.clone(),
+        }
+    }
+    /// The same item, and the same components when `want` names some.
+    fn matches(&self, s: &recipes::Stack, want: &browser::Stack) -> bool {
+        self.id(s) == want.item && (want.components.is_empty() || s.components == want.components)
+    }
+    fn name<'a>(&'a self, item: &'a str) -> &'a str {
+        self.items
+            .iter()
+            .find(|i| i.id == item)
+            .map_or(item, |i| &i.name)
+    }
+
+    /// Loads the tables once a world is open, and drops them when it closes.
+    fn load(&mut self) {
+        let in_world = game::get_player().is_some();
+        if in_world && self.items.is_empty() {
+            self.items = recipes::items();
+            self.all = recipes::all();
+            self.list();
+        } else if !in_world && !self.items.is_empty() {
+            browser::set_recipes("", &[], 0, &[]);
+            browser::set_items(&[]);
+            *self = Recipes {
+                give: self.give,
+                ..Recipes::default()
+            };
+        }
+    }
+
+    /// Fills the panel with the items the search keeps: every word must be
+    /// in the name or the id; `@minecraft` keeps a namespace, `#logs` a tag.
+    fn list(&mut self) {
+        let words: Vec<String> = self
+            .search
+            .to_lowercase()
+            .split_whitespace()
+            .map(String::from)
+            .collect();
+        let keeps = |item: &recipes::Item| {
+            words.iter().all(|w| {
+                if let Some(ns) = w.strip_prefix('@') {
+                    item.id.split(':').next().is_some_and(|n| n.starts_with(ns))
+                } else if let Some(tag) = w.strip_prefix('#') {
+                    item.tags.iter().any(|t| t.contains(tag))
+                } else {
+                    item.name.to_lowercase().contains(w.as_str()) || item.id.contains(w.as_str())
+                }
+            })
+        };
+        self.listed = (self.items.iter().enumerate())
+            .filter(|(_, i)| i.id != "minecraft:air" && keeps(i))
+            .map(|(n, _)| n)
+            .collect();
+        let stacks: Vec<_> = self
+            .listed
+            .iter()
+            .map(|&n| stack(&self.items[n].id))
+            .collect();
+        browser::set_items(&stacks);
+    }
+
+    /// The recipes a view lists, all stations together.
+    fn found(&self, view: &View) -> Vec<&recipes::Recipe> {
+        (self.all.iter())
+            .filter(|r| {
+                if view.uses {
+                    r.slots
+                        .iter()
+                        .flatten()
+                        .any(|s| self.matches(s, &view.item))
+                } else {
+                    r.results.iter().any(|s| self.matches(s, &view.item))
+                }
+            })
+            .collect()
+    }
+
+    /// Opens a page, pushing it on the history; nothing when it is empty.
+    fn open(&mut self, item: browser::Stack, uses: bool) {
+        let view = View { item, uses, tab: 0 };
+        if self.found(&view).is_empty() {
+            return;
+        }
+        self.history.push(view);
+        self.show();
+    }
+
+    /// Sends the page on top of the history, or the items when there is none.
+    fn show(&mut self) {
+        let Some(mut view) = self.history.last().cloned() else {
+            self.shown.clear();
+            browser::set_recipes("", &[], 0, &[]);
+            return;
+        };
+        let found = self.found(&view);
+        let stations: Vec<usize> = (0..STATIONS.len())
+            .filter(|&s| found.iter().any(|r| station(r.kind) == s))
+            .collect();
+        view.tab = view.tab.min(stations.len().saturating_sub(1));
+        let on: Vec<&recipes::Recipe> = (found.iter().copied())
+            .filter(|r| stations.get(view.tab) == Some(&station(r.kind)))
+            .take(MAX_RECIPES)
+            .collect();
+        let known = recipes::known();
+        let views: Vec<browser::RecipeView> = on.iter().map(|r| self.view(r, &known)).collect();
+        let mut title = format!(
+            "{}: {}",
+            if view.uses { "Uses" } else { "Recipes" },
+            self.name(&view.item.item)
+        );
+        let total = found
+            .iter()
+            .filter(|r| stations.get(view.tab) == Some(&station(r.kind)))
+            .count();
+        if total > on.len() {
+            title.push_str(&format!(" ({} of {total})", on.len()));
+        }
+        let tabs: Vec<_> = stations.iter().map(|&s| stack(STATIONS[s])).collect();
+        browser::set_recipes(&title, &tabs, view.tab as u32, &views);
+        self.shown = on.iter().map(|r| r.book_id).collect();
+        if let Some(top) = self.history.last_mut() {
+            top.tab = view.tab;
+        }
+    }
+
+    fn view(&self, r: &recipes::Recipe, known: &[i32]) -> browser::RecipeView {
+        let mut slots: Vec<Vec<browser::Stack>> = (r.slots.iter())
+            .map(|s| s.iter().take(MAX_STACKS).map(|s| self.convert(s)).collect())
+            .collect();
+        let results = r
+            .results
+            .iter()
+            .take(MAX_STACKS)
+            .map(|s| self.convert(s))
+            .collect();
+        let (layout, width, height, note) = match r.kind {
+            Kind::CraftingShaped => (browser::Layout::Grid, r.width, r.height, String::new()),
+            Kind::CraftingShapeless => {
+                let n = slots.len() as u32;
+                let width = match n {
+                    0 | 1 => 1,
+                    2..=4 => 2,
+                    _ => 3,
+                };
+                let height = n.div_ceil(width).max(1);
+                slots.resize((width * height) as usize, Vec::new());
+                (browser::Layout::Grid, width, height, "Shapeless".into())
+            }
+            Kind::Smelting | Kind::Blasting | Kind::Smoking | Kind::Campfire => {
+                let seconds = r.cooking_time as f32 / 20.0;
+                let note = format!("{seconds} s, {} XP", (r.experience * 100.0).round() / 100.0);
+                (browser::Layout::Cooking, 1, 1, note)
+            }
+            Kind::Stonecutting => (browser::Layout::Single, 1, 1, String::new()),
+            Kind::Smithing => (browser::Layout::Smithing, 3, 1, String::new()),
+            Kind::Brewing => (browser::Layout::Brewing, 2, 1, String::new()),
+        };
+        // + only for what the recipe book shows; greyed until the book has it.
+        let action = (r.book_id >= 0).then(|| known.contains(&r.book_id));
+        browser::RecipeView {
+            layout,
+            width,
+            height,
+            slots,
+            results,
+            note,
+            action,
+        }
+    }
+
+    fn handle(&mut self, event: browser::Event) {
+        match event {
+            browser::Event::Search(text) => {
+                self.search = text;
+                self.list();
+            }
+            browser::Event::Clicked(c) => {
+                let Some(&n) = self.listed.get(c.index as usize) else {
+                    return;
+                };
+                let item = self.items[n].id.clone();
+                if self.give {
+                    let count = if c.right { 99 } else { 1 };
+                    let gift = recipes::Stack {
+                        item: n as u32,
+                        count,
+                        components: String::new(),
+                    };
+                    if recipes::give(&gift).is_ok() {
+                        return;
+                    }
+                }
+                self.open(stack(&item), c.right);
+            }
+            browser::Event::Key(k) if k.key == RECIPE_KEY || k.key == USES_KEY => {
+                let item = browser::Stack {
+                    count: 1,
+                    ..k.stack
+                };
+                self.open(item, k.key == USES_KEY);
+            }
+            browser::Event::SlotClicked(c) => {
+                let item = browser::Stack {
+                    count: 1,
+                    ..c.stack
+                };
+                self.open(item, c.right);
+            }
+            browser::Event::Tab(i) => {
+                if let Some(top) = self.history.last_mut() {
+                    top.tab = i as usize;
+                }
+                self.show();
+            }
+            browser::Event::Action(i) => {
+                let book = self.shown.get(i as usize).copied();
+                if let Some(Err(e)) = book.map(|b| recipes::place(b, false)) {
+                    chat::show(&e);
+                }
+            }
+            browser::Event::Back => {
+                self.history.pop();
+                self.show();
+            }
+            _ => {}
+        }
+    }
+
+    fn page(&self) {
+        ui::set_settings(&[Widget::Button(ButtonWidget {
+            id: GIVE_BUTTON,
+            label: format!(
+                "Click gives items (creative): {}",
+                if self.give { "ON" } else { "OFF" }
+            ),
+        })]);
+    }
+}
+
+impl Mod for Recipes {
+    fn init() -> Result<(Self, Registration), String> {
+        input::register_key(RECIPE_KEY, "Show recipes", "key.keyboard.r")?;
+        input::register_key(USES_KEY, "Show uses", "key.keyboard.u")?;
+        let give = storage::get("give").is_some_and(|v| v == b"true");
+        let me = Recipes {
+            give,
+            ..Recipes::default()
+        };
+        me.page();
+        Ok((me, Registration::new().on_frame()))
+    }
+    fn frame(&mut self, _seconds: f32) {
+        self.load();
+        // The keys matter only over an item, which `browser` reports.
+        let _ = input::poll();
+        for event in browser::poll() {
+            self.handle(event);
+        }
+    }
+    fn ui_select(&mut self, id: u32, _row: u32) {
+        if id == GIVE_BUTTON {
+            self.give = !self.give;
+            let _ = storage::set("give", if self.give { b"true" } else { b"false" });
+            self.page();
+        }
+    }
+    fn ui_settings_opened(&mut self) {
+        self.page();
+    }
+}
+
+horizon_mod_sdk::export_mod!(Recipes);

From 29eae3a1afc1f725a69a43cc8da3d44c878c43ff Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:58:51 +0100
Subject: [PATCH 219/475] Throw a burst of spit particles when a llama spits

---
 crates/horizon-client/src/game/creatures.rs          |  5 +++++
 crates/horizon-client/src/game/remote_projectiles.rs |  4 ++++
 crates/horizon-client/src/particles.rs               | 12 ++++++++++++
 3 files changed, 21 insertions(+)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 86a7954e9..7343064e5 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1013,6 +1013,11 @@ impl Game<'_> {
                     self.next_entity += 1;
                     p.id = self.next_entity;
                     let (owner, at) = (p.owner, [p.position.x, p.position.y, p.position.z]);
+                    // LlamaSpit.recreateFromPacket: the spit's burst on the client.
+                    if p.kind == ProjectileKind::LlamaSpit {
+                        let v = p.velocity;
+                        self.particles.llama_spit_burst(at, [v.x, v.y, v.z]);
+                    }
                     self.creatures.projectiles.push(p);
                     self.projectile_event("minecraft:projectile_shoot", owner, at);
                 }
diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs
index 897999c6b..64f09d72a 100644
--- a/crates/horizon-client/src/game/remote_projectiles.rs
+++ b/crates/horizon-client/src/game/remote_projectiles.rs
@@ -161,6 +161,10 @@ impl Game<'_> {
                 let Some(k) = projectile_kind(kind) else {
                     return false;
                 };
+                if k == ProjectileKind::LlamaSpit {
+                    self.particles
+                        .llama_spit_burst(position, [velocity.x, velocity.y, velocity.z]);
+                }
                 let mut p = Projectile::new(k, at, None);
                 p.id = id;
                 p.velocity = velocity;
diff --git a/crates/horizon-client/src/particles.rs b/crates/horizon-client/src/particles.rs
index fa9dc9c6e..fd05a1ac1 100644
--- a/crates/horizon-client/src/particles.rs
+++ b/crates/horizon-client/src/particles.rs
@@ -1398,6 +1398,18 @@ impl ParticleEngine {
         self.add(&ParticleOptions::simple(ty), center, [1.0, 0.0, 0.0]);
         self.explosion_blocks(center, radius, block_count, is_air);
     }
+    /// `LlamaSpit.recreateFromPacket`: seven spit particles thrown ahead of a
+    /// new spit, each faster than the last along x and z.
+    pub fn llama_spit_burst(&mut self, at: [f64; 3], movement: [f64; 3]) {
+        for i in 0..7 {
+            let k = 0.4 + 0.1 * f64::from(i);
+            self.add(
+                &ParticleOptions::simple(ParticleType::Spit),
+                at,
+                [movement[0] * k, movement[1], movement[2] * k],
+            );
+        }
+    }
     /// `ClientExplosionTracker` with `Level.DEFAULT_EXPLOSION_BLOCK_PARTICLES`.
     pub fn explosion_blocks(
         &mut self,

From 96b538d48f6e8e9da03faa04a8f9b8c85f1cf281 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 19:59:59 +0100
Subject: [PATCH 220/475] Throw up landing dust where a hard fall lands

A landing that hurts sends the block's crumbs from the server
(LivingEntity.checkFallDamage). Horizon built the event but dropped it, for
the window's player and for every server player.
---
 crates/horizon-client/src/game.rs             |  7 ++
 crates/horizon-client/src/game/lan_actions.rs |  7 ++
 .../horizon-client/src/game/lan_particles.rs  | 79 +++++++++++++++++--
 3 files changed, 87 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index a51bdcbcb..5b69799fc 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4578,6 +4578,13 @@ impl Game<'_> {
                     };
                     self.audio.play(name, Some(feet), volume, pitch);
                 }
+                // LivingEntity.checkFallDamage: the block's crumbs where the fall landed.
+                MotionEvent::Fall(horizon_client::landing::FallEvent::Particles {
+                    state,
+                    position,
+                    count,
+                    speed,
+                }) => self.landing_dust(None, state, position, count, speed),
                 MotionEvent::Fall(event) => self.landing_block_updates(&event),
                 MotionEvent::Snowflake { position, velocity } => self.snowflake(position, velocity),
                 MotionEvent::EnterBlock { state } => self.trigger_enter_block(state),
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 43bb573dc..31bb454cb 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -2310,6 +2310,13 @@ impl Game<'_> {
         for event in events {
             match event {
                 MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, at),
+                // LivingEntity.checkFallDamage: the crumbs reach every player.
+                MotionEvent::Fall(horizon_client::landing::FallEvent::Particles {
+                    state,
+                    position,
+                    count,
+                    speed,
+                }) => self.landing_dust(Some(host), state, position, count, speed),
                 MotionEvent::Fall(event) => self.landing_block_updates(&event),
                 _ => {}
             }
diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs
index c41fdf1ad..888264bcc 100644
--- a/crates/horizon-client/src/game/lan_particles.rs
+++ b/crates/horizon-client/src/game/lan_particles.rs
@@ -1,7 +1,8 @@
 //! Particles a server sends its players and its clients draw:
 //! `ClientboundLevelParticlesPacket` (`ServerLevel.sendParticles`, which
 //! `/particle` uses) and `ClientboundExplodePacket` (`ServerLevel.explode`).
-use super::Game;
+use super::{Game, lan::LanHost};
+use horizon_client::lan::hub::Hub;
 use horizon_client::particles::{ParticleOptions, ParticleType};
 use horizon_core::{geometry::Vec3, random::RandomSource};
 use horizon_protocol::{
@@ -52,6 +53,66 @@ impl Game<'_> {
         }
     }
 
+    /// `LivingEntity.checkFallDamage`'s `ServerLevel.sendParticles` of the
+    /// landing block's crumbs: drawn in this window, when it has one, and
+    /// sent to each player within 32 blocks. `host` is the hub of a guest's
+    /// turn, which is out of `self.lan` meanwhile.
+    pub(super) fn landing_dust(
+        &mut self,
+        host: Option<&LanHost>,
+        state: BlockStateId,
+        at: Vec3,
+        count: i32,
+        speed: f64,
+    ) {
+        let at = [at.x, at.y, at.z];
+        if self.serving.is_none() && self.options.dedicated.is_none() {
+            let block = [
+                at[0].floor() as i32,
+                (at[1] - 0.2).floor() as i32,
+                at[2].floor() as i32,
+            ];
+            if let Some((sprite, tint)) = self.particle_sprite(state, block) {
+                self.particles.send_particles(
+                    &ParticleOptions::block(ParticleType::Block, sprite, tint),
+                    at,
+                    [0.0; 3],
+                    speed,
+                    count as u32,
+                );
+            }
+        }
+        let Some(hub) = host.or(self.lan.as_ref()).map(|h| &h.hub) else {
+            return;
+        };
+        let Some(particle) = Self::hub_particle(
+            hub,
+            &ParticleOptions::simple(ParticleType::Block),
+            Some(state),
+        ) else {
+            return;
+        };
+        let packet = C::LevelParticles(play::LevelParticles {
+            particle,
+            override_limiter: false,
+            always_show: false,
+            pos: at,
+            dist: [0.0; 3],
+            max_speed: [speed as f32; 3],
+            count,
+            randomization: 0,
+        });
+        for g in hub.guests.iter().filter(|g| hub.here(g)) {
+            // ServerLevel compares the player's block centre, strictly within 32.
+            let distance: f64 = (0..3)
+                .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2))
+                .sum();
+            if distance < 32.0 * 32.0 {
+                g.send(&packet);
+            }
+        }
+    }
+
     /// `ParticleTypes.STREAM_CODEC`'s value for `options`: the type's
     /// network id and the data it carries (`state` for the block particles).
     /// None while not serving, or for a particle whose data isn't sent from
@@ -60,13 +121,19 @@ impl Game<'_> {
         &self,
         options: &ParticleOptions,
         state: Option<BlockStateId>,
+    ) -> Option<Particle> {
+        Self::hub_particle(&self.lan.as_ref()?.hub, options, state)
+    }
+
+    /// `network_particle` for a hub that is out of `self.lan` meanwhile (a
+    /// guest's turn).
+    fn hub_particle(
+        hub: &Hub,
+        options: &ParticleOptions,
+        state: Option<BlockStateId>,
     ) -> Option<Particle> {
         let name = format!("minecraft:{}", options.ty.name());
-        let id = self
-            .lan
-            .as_ref()?
-            .hub
-            .registry_id("minecraft:particle_type", &name)?;
+        let id = hub.registry_id("minecraft:particle_type", &name)?;
         use ParticleType as T;
         let c = options.color;
         let data = match options.ty {

From a08f3eb2fa74ccff9d3565b8c0cab520a55276d8 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:02:36 +0100
Subject: [PATCH 221/475] Select a bundle's item with the mouse wheel

---
 crates/horizon-client/src/bundle.rs           |  56 ++++++++--
 crates/horizon-client/src/game.rs             |  12 ++
 crates/horizon-client/src/game/bundles.rs     | 103 ++++++++++++++++++
 crates/horizon-client/src/game/lan_actions.rs |   6 +
 crates/horizon-client/src/game/remote.rs      |   4 +-
 crates/horizon-client/src/game/stations.rs    |  22 +++-
 crates/horizon-client/src/item_data.rs        |  17 +++
 crates/horizon-client/src/item_render.rs      |   1 +
 crates/horizon-client/src/lan/containers.rs   |  36 ++++++
 crates/horizon-client/src/lan/menu.rs         |   5 +-
 crates/horizon-client/src/menu/bundle.rs      |   7 +-
 crates/horizon-protocol/src/packets/play.rs   |   6 +
 12 files changed, 260 insertions(+), 15 deletions(-)
 create mode 100644 crates/horizon-client/src/game/bundles.rs

diff --git a/crates/horizon-client/src/bundle.rs b/crates/horizon-client/src/bundle.rs
index 42473729f..948e2f4a9 100644
--- a/crates/horizon-client/src/bundle.rs
+++ b/crates/horizon-client/src/bundle.rs
@@ -1,6 +1,7 @@
 //! `BundleContents.Mutable`: what a bundle takes in and gives back, by
 //! weight. The menus (`menu`, `lan::menu`) run `BundleItem`'s click
 //! overrides on it.
+use crate::item_data::BundleSelected;
 use crate::items::{ItemStack, Items};
 use horizon_world::nbt::Tag;
 
@@ -97,6 +98,8 @@ pub fn can_be_in_bundle(stack: &ItemStack) -> bool {
 pub struct Contents {
     items: Vec<ItemStack>,
     weight: Weight,
+    /// `selectedItem`: an index into `items`, -1 for none.
+    selected: i32,
 }
 
 impl Contents {
@@ -104,9 +107,11 @@ impl Contents {
     pub fn of(items: &Items, stack: &ItemStack) -> Option<Self> {
         let inside = contents_of(items, stack)?.to_vec();
         let weight = contents_weight(items, &inside);
+        let selected = stack.data().map_or(-1, |d| d.bundle_selected.0);
         Some(Self {
             items: inside,
             weight,
+            selected,
         })
     }
 
@@ -154,18 +159,26 @@ impl Contents {
         amount
     }
 
-    /// `removeOne`: the first stack (Horizon keeps no selected item).
+    /// `removeOne`: the selected stack, else the first; nothing is selected after.
     pub fn remove_one(&mut self, items: &Items) -> Option<ItemStack> {
         if self.items.is_empty() {
             return None;
         }
-        let stack = self.items.remove(0);
+        let at =
+            usize::try_from(self.selected).map_or(0, |i| if i < self.items.len() { i } else { 0 });
+        let stack = self.items.remove(at);
         self.weight = self
             .weight
             .sub(item_weight(items, &stack).times(stack.count));
+        self.selected = -1;
         Some(stack)
     }
 
+    /// `getSelectedItemIndex`.
+    pub fn selected(&self) -> i32 {
+        self.selected
+    }
+
     /// The stacks inside, in display order (the first is the next out).
     pub fn items(&self) -> &[ItemStack] {
         &self.items
@@ -200,11 +213,28 @@ impl Contents {
 
     /// `toImmutable`, written back into the bundle's component.
     pub fn store(self, bundle: &mut ItemStack) {
-        bundle.data_mut().bundle_contents = self.items;
+        let data = bundle.data_mut();
+        data.bundle_contents = self.items;
+        data.bundle_selected = BundleSelected(self.selected);
         bundle.tidy();
     }
 }
 
+/// `BundleItem.toggleSelectedItem`: select `index`, or nothing when it is the
+/// selected one already or outside the contents.
+pub fn toggle_selected(bundle: &mut ItemStack, index: i32) {
+    let Some(data) = bundle.extra.as_deref_mut() else {
+        return;
+    };
+    let inside = (0..data.bundle_contents.len() as i32).contains(&index);
+    let selected = if data.bundle_selected.0 != index && inside {
+        index
+    } else {
+        -1
+    };
+    data.bundle_selected = BundleSelected(selected);
+}
+
 #[cfg(test)]
 mod tests {
     use super::Weight;
@@ -232,8 +262,10 @@ pub struct TooltipLayout {
     /// The component's own width (96) and height, the text's excluded.
     pub width: f32,
     pub height: f32,
-    /// Each slot's top-left and the stack in it, in reading order.
+    /// Each slot's top-left and the stack in it, in drawing order.
     pub slots: Vec<([f32; 2], ItemStack)>,
+    /// The position in `slots` of the selected item, which is drawn highlighted.
+    pub selected: Option<usize>,
     /// The `+N` of the items past the grid: its top-left and the count.
     pub overflow: Option<([f32; 2], u32)>,
     /// The progress bar's top-left, its fill's width out of 94, and whether
@@ -266,6 +298,7 @@ pub fn tooltip_layout(
             width: 96.0,
             height: description_height + 13.0 + 8.0,
             slots: Vec::new(),
+            selected: None,
             overflow: None,
             bar: [x + offset, y + description_height + 4.0],
             fill: 0.0,
@@ -282,6 +315,7 @@ pub fn tooltip_layout(
     let x_start = x + offset + 96.0;
     let y_start = y + grid_height;
     let mut slots = Vec::with_capacity(shown.len());
+    let mut selected = None;
     let mut overflow = None;
     // Rows fill bottom-up and columns right-to-left, as vanilla draws them.
     let mut slot = 0;
@@ -290,8 +324,13 @@ pub fn tooltip_layout(
             let at = [x_start - column as f32 * 24.0, y_start - row as f32 * 24.0];
             if hidden > 0 && row == 1 && column == 1 {
                 overflow = Some((at, hidden));
-            } else if let Some(stack) = shown.get(slot) {
-                slots.push((at, stack.clone()));
+            } else if slot < shown.len() {
+                // `extractSlot`: the cell of slot number n holds item `size - n`.
+                let index = shown.len() - 1 - slot;
+                if usize::try_from(contents.selected()) == Ok(index) {
+                    selected = Some(slots.len());
+                }
+                slots.push((at, shown[index].clone()));
                 slot += 1;
             }
         }
@@ -301,6 +340,7 @@ pub fn tooltip_layout(
         width: 96.0,
         height: grid_height + 13.0 + 8.0,
         slots,
+        selected,
         overflow,
         bar: [x + offset, y + grid_height + 4.0],
         // `Mth.mulAndTruncate(weight, 94)`, kept within the bar.
@@ -349,8 +389,8 @@ mod tooltip_tests {
         assert_eq!(layout.slots.len(), 12);
         assert_eq!(layout.overflow, None);
         assert_eq!(layout.height, 3.0 * 24.0 + 13.0 + 8.0);
-        // Rows fill bottom-up and columns right-to-left: the first item is in
-        // the bottom-right cell, the twelfth in the top-left.
+        // Rows fill bottom-up and columns right-to-left: the twelfth item is in
+        // the bottom-right cell, the first in the top-left.
         assert_eq!(layout.slots[0].0, [96.0 - 24.0, 3.0 * 24.0 - 24.0]);
         assert_eq!(&*layout.slots[0].1.item, "minecraft:stone");
         assert_eq!(layout.slots[11].0, [0.0, 0.0]);
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index de7eb448b..fc92a6c6f 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -18,6 +18,7 @@ mod boats;
 mod books;
 mod bossbars;
 mod breezes;
+mod bundles;
 mod campfire;
 mod campfire_douse;
 mod cartography;
@@ -1254,6 +1255,8 @@ struct Game<'a> {
     inv_clicks: horizon_client::container_screen::Clicks,
     /// The Mouse Tweaks extra's drag and wheel (`tweaks`).
     tweaks: tweaks::Tweaks,
+    /// The wheel and hovered slot of `BundleMouseActions`.
+    bundle_mouse: bundles::BundleMouse,
     /// The last inventory click, for the double click that gathers a stack.
     last_inv_click: Option<(std::time::Instant, usize, bool)>,
     /// `lastQuickMoved`: what the last Shift click moved, which a Shift
@@ -4653,6 +4656,7 @@ impl Game<'_> {
         self.shield_cooldown = self.shield_cooldown.saturating_sub(1);
         self.cooldowns.tick();
         horizon_client::spans::time("tick_using", || self.tick_using());
+        self.tick_bundle_hover();
         horizon_client::spans::time("tick_hud", || self.tick_hud());
         // The player's digging comes in with its packets, before the level
         // ticks; ServerLevel.tick then runs the scheduled and random block
@@ -5847,6 +5851,12 @@ impl Game<'_> {
     /// Several clicks on one menu instance (a quick craft drag is three).
     fn menu_ops(&mut self, ops: &[(Option<usize>, i32, horizon_client::menu::Input)]) -> bool {
         use horizon_client::menu::Input;
+        // BundleMouseActions.onSlotClicked: a Shift click or a swap clears the bundle's selection.
+        for &(slot, _, input) in ops {
+            if let (Some(slot), Input::QuickMove | Input::Swap) = (slot, input) {
+                self.unselect_bundle(slot);
+            }
+        }
         if self.remote.is_some() && self.screen == Screen::Inventory {
             // On a server the clicks are the server's: predicted and sent.
             return self.remote_menu_ops(ops);
@@ -11660,6 +11670,7 @@ impl ApplicationHandler for Game<'_> {
                     }
                     if self.screen == Screen::Inventory
                         && d != 0.0
+                        && !self.bundle_scroll(scaled(raw_x), scaled(raw_y))
                         && !self.tweak_scroll(d, self.inventory_target().0)
                     {
                         self.station_scroll(d);
@@ -12441,6 +12452,7 @@ impl<'a> Game<'a> {
             craft_table: None,
             inv_drag: None,
             tweaks: Default::default(),
+            bundle_mouse: Default::default(),
             inv_clicks: Default::default(),
             last_inv_click: None,
             last_quick_moved: None,
diff --git a/crates/horizon-client/src/game/bundles.rs b/crates/horizon-client/src/game/bundles.rs
new file mode 100644
index 000000000..198964803
--- /dev/null
+++ b/crates/horizon-client/src/game/bundles.rs
@@ -0,0 +1,103 @@
+//! `BundleMouseActions`: the wheel over a bundle in a container screen selects
+//! one of the items it shows, which a click that takes one out of it then takes
+//! (`BundleContents.Mutable.removeOne`). Moving off the bundle clears the
+//! selection. On a server the selection is sent to it (`ServerboundSelectBundleItemPacket`).
+use super::{Game, Screen};
+use horizon_client::{
+    bundle::{Contents, toggle_selected},
+    mouse::ScrollWheelHandler,
+};
+use horizon_protocol::packets::play::{self, Serverbound as S};
+
+#[derive(Default)]
+pub(super) struct BundleMouse {
+    wheel: ScrollWheelHandler,
+    /// The slot under the cursor at the last tick (`AbstractContainerScreen.hoveredSlot`).
+    hovered: Option<usize>,
+}
+
+impl Game<'_> {
+    /// A slot a bundle can be selected in: the player's inventory, the off hand and a
+    /// container's own slots. A server only knows these in the inventory and chest-like menus.
+    fn bundle_slot(&mut self, slot: usize) -> bool {
+        (slot < 36 || slot == 504 || (300..500).contains(&slot))
+            && (self.remote.is_none() || self.remote_storage_open())
+            && (slot < 36 || slot == 504 || self.slots().contains(&slot))
+    }
+
+    /// `BundleMouseActions.onMouseScrolled`: the wheel over a bundle moves the selection
+    /// through the items its tooltip shows. True when the bundle took the wheel.
+    pub(super) fn bundle_scroll(&mut self, x: f64, y: f64) -> bool {
+        let Some(slot) = self.inventory_target().0 else {
+            return false;
+        };
+        if !self.bundle_slot(slot) {
+            return false;
+        }
+        let stack = self.slot_mut(slot).clone();
+        let items = self.res.items();
+        let Some(bundle) = stack.filter(|s| items.get(&s.item).is_some_and(|i| i.bundle)) else {
+            return false;
+        };
+        let shown = Contents::of(items, &bundle).map_or(0, |c| c.shown_count());
+        if shown == 0 {
+            return false;
+        }
+        let (wheel_x, wheel_y) = self.bundle_mouse.wheel.on_mouse_scroll(x, y);
+        let wheel = if wheel_y == 0 { -wheel_x } else { wheel_y };
+        if wheel != 0 {
+            let selected = bundle.data().map_or(-1, |d| d.bundle_selected.0);
+            let next = ScrollWheelHandler::next_selection(f64::from(wheel), selected, shown as i32);
+            if next != selected {
+                self.select_bundle(slot, next);
+            }
+        }
+        true
+    }
+
+    /// `BundleMouseActions.toggleSelectedBundleItem`: the stack here and, on a server, there.
+    fn select_bundle(&mut self, slot: usize, index: i32) {
+        if let Some(stack) = self.slot_mut(slot) {
+            toggle_selected(stack, index);
+        }
+        if self.remote.is_some() {
+            let (_, menu) = self.remote_menu();
+            if let Some(menu_slot) = Self::menu_slot_index(&menu, slot) {
+                self.send(S::SelectBundleItem(play::SelectBundleItem {
+                    slot: menu_slot as i32,
+                    index,
+                }));
+            }
+        }
+    }
+
+    /// `BundleMouseActions.unselectedBundleItem` for the bundle in `slot`, if it has a selection.
+    pub(super) fn unselect_bundle(&mut self, slot: usize) {
+        if !self.bundle_slot(slot) {
+            return;
+        }
+        let selected = self
+            .slot_mut(slot)
+            .as_ref()
+            .and_then(|s| s.data())
+            .is_some_and(|d| d.bundle_selected.0 >= 0);
+        if selected {
+            self.select_bundle(slot, -1);
+        }
+    }
+
+    /// `AbstractContainerScreen.onStopHovering` (and `onClose`): leaving a slot, or the
+    /// screen, clears the bundle's selection.
+    pub(super) fn tick_bundle_hover(&mut self) {
+        let now = if self.screen == Screen::Inventory {
+            self.inventory_target().0
+        } else {
+            None
+        };
+        if let Some(left) = std::mem::replace(&mut self.bundle_mouse.hovered, now)
+            && Some(left) != now
+        {
+            self.unselect_bundle(left);
+        }
+    }
+}
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 43bb573dc..df651b102 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -1216,6 +1216,12 @@ impl Game<'_> {
             {
                 self.guest_carried_back(host, gi);
             }
+            S::SelectBundleItem(p) => {
+                if !spectator && let Ok(slot) = usize::try_from(p.slot) {
+                    host.hub
+                        .select_bundle_item(conn, slot, p.index, &mut self.world);
+                }
+            }
             S::ContainerClick(p) => {
                 let rules = ItemRules(self.res.items());
                 let slots = host.hub.guests[gi]
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3cfbd15e3..32f5f6093 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -1558,7 +1558,7 @@ impl Game<'_> {
         }
     }
     /// Find a game slot in the menu's complete, contiguous slot mapping.
-    fn menu_slot_index(menu: &str, internal: usize) -> Option<usize> {
+    pub(super) fn menu_slot_index(menu: &str, internal: usize) -> Option<usize> {
         (0..)
             .map_while(|slot| Self::menu_slot(menu, slot))
             .position(|slot| slot == internal)
@@ -4701,7 +4701,7 @@ impl Game<'_> {
     }
     /// The server's open menu: its window id and menu type (0, "inventory"
     /// when none is open).
-    fn remote_menu(&self) -> (i32, String) {
+    pub(super) fn remote_menu(&self) -> (i32, String) {
         match self.remote.as_ref().and_then(|r| r.menu.clone()) {
             Some((id, name)) => (id, name),
             None => (0, "inventory".to_owned()),
diff --git a/crates/horizon-client/src/game/stations.rs b/crates/horizon-client/src/game/stations.rs
index 56b19e393..8efd6eed9 100644
--- a/crates/horizon-client/src/game/stations.rs
+++ b/crates/horizon-client/src/game/stations.rs
@@ -2104,12 +2104,18 @@ impl Game<'_> {
         batch: &mut HudBatch,
         layout: &horizon_client::bundle::TooltipLayout,
     ) {
-        for (at, stack) in &layout.slots {
+        for (i, (at, stack)) in layout.slots.iter().enumerate() {
+            let selected = layout.selected == Some(i);
+            let sprite = |name: &str| format!("gui/sprites/container/bundle/{name}");
             // Each draw takes the atlas on its own: the item's needs `&mut self`.
             horizon_client::ui::nine_slice(
                 batch,
                 &self.gui.atlas,
-                "gui/sprites/container/bundle/slot_background",
+                &sprite(if selected {
+                    "slot_highlight_back"
+                } else {
+                    "slot_background"
+                }),
                 at[0],
                 at[1],
                 24.0,
@@ -2119,6 +2125,18 @@ impl Game<'_> {
             let stack = stack.clone();
             let [x, y] = *at;
             self.draw_item(batch, &stack, x + 4.0, y + 4.0);
+            if selected {
+                horizon_client::ui::nine_slice(
+                    batch,
+                    &self.gui.atlas,
+                    &sprite("slot_highlight_front"),
+                    x,
+                    y,
+                    24.0,
+                    24.0,
+                    u32::MAX,
+                );
+            }
         }
         let atlas = &self.gui.atlas;
         if let Some((at, hidden)) = layout.overflow {
diff --git a/crates/horizon-client/src/item_data.rs b/crates/horizon-client/src/item_data.rs
index ac624e85b..253bc6cc5 100644
--- a/crates/horizon-client/src/item_data.rs
+++ b/crates/horizon-client/src/item_data.rs
@@ -52,6 +52,8 @@ pub struct StackData {
     pub pot_decorations: Option<Box<[Option<ItemStack>; 4]>>,
     /// `minecraft:bundle_contents`.
     pub bundle_contents: Vec<ItemStack>,
+    /// `BundleContents.selectedItem`: runtime only, never saved or sent.
+    pub bundle_selected: BundleSelected,
     /// `minecraft:suspicious_stew_effects`: (effect id, duration).
     pub stew_effects: Vec<(Arc<str>, i32)>,
     /// `minecraft:map_post_processing`: 0 lock, 1 scale.
@@ -60,6 +62,20 @@ pub struct StackData {
     /// max stack size...), kept as their saved values in key order.
     pub other: Vec<(String, Tag)>,
 }
+/// A bundle's selected item index (-1: none). Like vanilla's
+/// `BundleContents.equals` it is left out when stacks are compared.
+#[derive(Clone, Copy, Debug)]
+pub struct BundleSelected(pub i32);
+impl Default for BundleSelected {
+    fn default() -> Self {
+        Self(-1)
+    }
+}
+impl PartialEq for BundleSelected {
+    fn eq(&self, _: &Self) -> bool {
+        true
+    }
+}
 /// The components `components_tag` writes from modelled fields.
 const MODELLED: &[&str] = &[
     "minecraft:banner_patterns",
@@ -791,6 +807,7 @@ pub fn decode_components(components: Option<&Tag>) -> (u32, Option<Box<StackData
                 Arc::from(t.get("pattern").and_then(string)?.as_str()),
             ))
         }),
+        bundle_selected: BundleSelected::default(),
         other: Vec::new(),
     };
     let mut data = data;
diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs
index 4f981b874..8188eb712 100644
--- a/crates/horizon-client/src/item_render.rs
+++ b/crates/horizon-client/src/item_render.rs
@@ -653,6 +653,7 @@ pub fn tag_json(tag: &Tag) -> Value {
 /// The resolver's view of a client stack: its item, count and component patch.
 pub fn stack_view(stack: &crate::items::ItemStack) -> StackView {
     let mut view = StackView::new(&stack.item, stack.count as i32);
+    view.bundle_selected = stack.data().map_or(-1, |d| d.bundle_selected.0);
     if let Some(Tag::Compound(c)) = crate::item_data::components_tag(stack.damage, stack.data()) {
         for (k, v) in &c {
             let key = k.to_string_lossy();
diff --git a/crates/horizon-client/src/lan/containers.rs b/crates/horizon-client/src/lan/containers.rs
index 002f95cbb..c5fede5c6 100644
--- a/crates/horizon-client/src/lan/containers.rs
+++ b/crates/horizon-client/src/lan/containers.rs
@@ -421,6 +421,42 @@ impl Hub {
         drops
     }
 
+    /// `AbstractContainerMenu.setSelectedBundleItemIndex` on the guest's open
+    /// menu: a container's own slots, or the inventory's. A bundle's selection
+    /// lives on the server's stack until the click that takes from it.
+    pub fn select_bundle_item(&mut self, conn: u32, slot: usize, index: i32, world: &mut World) {
+        let Some(g) = self.guests.iter_mut().find(|g| g.conn == conn) else {
+            return;
+        };
+        let open = g.menu.as_ref().map(|m| (m.size, m.slots));
+        let mut items = match open {
+            Some((size, source)) if slot < size => source.read(world, g),
+            _ => None,
+        };
+        let stack = match open {
+            Some((size, _)) if slot < size => items
+                .as_mut()
+                .and_then(|items| items.get_mut(slot))
+                .and_then(Option::as_mut),
+            Some((size, _)) => g
+                .inventory
+                .get_mut(player_slot(slot - size))
+                .and_then(Option::as_mut),
+            None => match slot {
+                9..=35 => g.inventory.get_mut(slot).and_then(Option::as_mut),
+                36..=44 => g.inventory.get_mut(slot - 36).and_then(Option::as_mut),
+                45 => g.offhand.as_mut(),
+                _ => None,
+            },
+        };
+        if let Some(stack) = stack {
+            crate::bundle::toggle_selected(stack, index);
+        }
+        if let (Some((_, source)), Some(items)) = (open, items) {
+            source.write(world, g, items);
+        }
+    }
+
     /// A click on the inventory menu (window 0) the game applied itself
     /// (the crafting grid): the client is corrected like after any click.
     pub fn inventory_clicked(
diff --git a/crates/horizon-client/src/lan/menu.rs b/crates/horizon-client/src/lan/menu.rs
index 859bafa23..641e45b1b 100644
--- a/crates/horizon-client/src/lan/menu.rs
+++ b/crates/horizon-client/src/lan/menu.rs
@@ -5,7 +5,7 @@
 //! menu are returned for the game to drop.
 use super::guest::Guest;
 use crate::{
-    bundle::{Contents, can_be_in_bundle},
+    bundle::{Contents, can_be_in_bundle, toggle_selected},
     items::{ItemStack, Items},
     world::World,
 };
@@ -514,7 +514,10 @@ fn bundle_click(view: &mut View, i: usize, right: bool, rules: &dyn Rules) -> bo
             }
         }
         (carried, _) => {
+            // toggleSelectedItem(-1), then the click goes on.
             view.guest.carried = carried;
+            toggle_selected(&mut bundle, -1);
+            view.set(i, Some(bundle));
             return false;
         }
     }
diff --git a/crates/horizon-client/src/menu/bundle.rs b/crates/horizon-client/src/menu/bundle.rs
index fba4a488e..78a52655a 100644
--- a/crates/horizon-client/src/menu/bundle.rs
+++ b/crates/horizon-client/src/menu/bundle.rs
@@ -1,7 +1,7 @@
 //! `BundleItem`'s click overrides in a PICKUP click
 //! (`tryItemClickBehaviourOverride`).
 use super::{Env, Menu, tidy};
-use crate::bundle::{Contents, INSERT, INSERT_FAIL, REMOVE_ONE, can_be_in_bundle};
+use crate::bundle::{Contents, INSERT, INSERT_FAIL, REMOVE_ONE, can_be_in_bundle, toggle_selected};
 
 impl Menu {
     /// The carried stack's `overrideStackedOnOther`, then the clicked
@@ -88,8 +88,11 @@ impl Menu {
                 }
             }
             (carried, _) => {
-                // toggleSelectedItem(-1): Horizon keeps no selected item.
+                // toggleSelectedItem(-1), then the click goes on.
                 self.carried = carried;
+                toggle_selected(&mut bundle, -1);
+                let slot = self.slots[s];
+                self.containers[slot.container][slot.index] = Some(bundle);
                 return false;
             }
         }
diff --git a/crates/horizon-protocol/src/packets/play.rs b/crates/horizon-protocol/src/packets/play.rs
index 26bc09a84..7ab82720d 100644
--- a/crates/horizon-protocol/src/packets/play.rs
+++ b/crates/horizon-protocol/src/packets/play.rs
@@ -2249,6 +2249,11 @@ packet!(
     /// Input flags: forward 1, backward 2, left 4, right 8, jump 16, shift 32, sprint 64.
     PlayerInput { flags: u8 => UByte }
 );
+packet!(
+    /// ServerboundSelectBundleItemPacket: the menu slot of a bundle and the
+    /// index of its selected item (-1: none).
+    SelectBundleItem { slot: i32 => VarInt, index: i32 => VarInt }
+);
 packet!(SetCarriedItem { slot: i16 => Short });
 packet!(SetCreativeModeSlot { slot: i16 => Short, item: Option<Stack> => Slot });
 packet!(UseItem { hand: i32 => VarInt, sequence: i32 => VarInt, yaw: f32 => Float, pitch: f32 => Float });
@@ -2317,6 +2322,7 @@ packet_enum!(Serverbound, crate::ids::play::serverbound {
     ContainerSlotStateChanged(ContainerSlotStateChanged) = CONTAINER_SLOT_STATE_CHANGED,
     Punch(Empty) = PUNCH,
     ResourcePack(ResourcePackResponse) = RESOURCE_PACK,
+    SelectBundleItem(SelectBundleItem) = BUNDLE_ITEM_SELECTED,
     SelectTrade(SelectTrade) = SELECT_TRADE,
     SetBeacon(SetBeacon) = SET_BEACON,
     SetCarriedItem(SetCarriedItem) = SET_CARRIED_ITEM,

From cf6b91a710eb52fa1b856d11da197514694eb243 Mon Sep 17 00:00:00 2001
From: masa-masa-0314 <348336850+masa-masa-0314@users.noreply.github.com>
Date: Tue, 27 Oct 2026 00:29:02 +0800
Subject: [PATCH 222/475] Items: draw the enchantment glint from
 enchanted_glint_item

Horizon invented the glint: the GUI drew sine bands in screen space and
the entity shader layered the same over held and dropped items. Vanilla
26.3 samples `misc/enchanted_glint_item` through `GLINT_TEXTURING`
(`item.vsh`/`item.fsh`, `TextureTransform.setupGlintTexturing`), so
items now carry the real texture:

- `ItemQuad.foil_uv` keeps the model UV the glint samples; `Glint` turns
  it into the atlas UV with the 26.3 transform (translation(-o0, o1) *
  rotateZ(PI/18) * scale) and `WorldSink` gives foil quads overlay 7 and
  the per-corner glint UV.
- The GUI glint is a separate additive HUD pass masked by the item's
  texture alpha (`item.fsh`'s ALPHA_CUTOUT 0.1 and GLINT path).
- `entity.wgsl` samples the glint at overlay 7/8 like vanilla's
  `color.rgb += glintColor.rgb * glintColor.rgb`.
- The Accessibility options Glint Speed and Glint Strength work: both
  sliders persist to `options.txt` (they were hidden placeholders), the
  GUI pass takes them per draw, and `Frame.glint_alpha` feeds the entity
  shader every frame instead of whatever the last HUD item set.
- GUI items use `GLINT_TEXTURING`'s scale 8, world items
  `ENTITY_GLINT_TEXTURING`'s scale 0.5.

Co-Authored-By: ZCode <agent@zcode.dev>
---
 .../horizon-client/src/block_entity_render.rs |  7 ++
 crates/horizon-client/src/breaking.rs         |  2 +
 crates/horizon-client/src/clouds.rs           |  2 +
 crates/horizon-client/src/entity.wgsl         | 24 +++---
 crates/horizon-client/src/entity_culling.rs   |  2 +
 crates/horizon-client/src/fire_render.rs      |  2 +
 crates/horizon-client/src/game.rs             |  6 ++
 .../horizon-client/src/game/armor_stands.rs   |  1 +
 crates/horizon-client/src/game/creatures.rs   |  4 +
 crates/horizon-client/src/game/dragon.rs      |  6 ++
 crates/horizon-client/src/game/end.rs         |  4 +
 crates/horizon-client/src/game/fishing.rs     |  2 +
 crates/horizon-client/src/game/frames.rs      |  2 +
 crates/horizon-client/src/game/item_draw.rs   | 19 +++++
 crates/horizon-client/src/game/leads.rs       |  2 +
 crates/horizon-client/src/game/maps.rs        |  6 ++
 crates/horizon-client/src/game/minecarts.rs   |  1 +
 crates/horizon-client/src/game/mob_blocks.rs  |  2 +
 crates/horizon-client/src/game/names.rs       |  1 +
 crates/horizon-client/src/game/paintings.rs   |  2 +
 crates/horizon-client/src/game/perspective.rs |  2 +
 .../horizon-client/src/game/text_displays.rs  |  2 +
 crates/horizon-client/src/game/tnt.rs         |  2 +
 crates/horizon-client/src/gfx.rs              | 11 ++-
 crates/horizon-client/src/gfx/end_sky.rs      |  2 +
 .../horizon-client/src/gfx/end_sky/tests.rs   | 16 ++--
 crates/horizon-client/src/gfx/entity_batch.rs |  2 +
 crates/horizon-client/src/gfx/lightning.rs    |  2 +
 .../src/gfx/lightning/tests/mod.rs            |  2 +
 crates/horizon-client/src/gfx/pack_weather.rs |  2 +
 crates/horizon-client/src/hud.rs              | 38 ++++++++-
 crates/horizon-client/src/hud.wgsl            | 14 ++--
 crates/horizon-client/src/item_render.rs      | 50 ++++++++++-
 crates/horizon-client/src/item_render/gui.rs  | 83 ++++++++++---------
 .../src/item_render/gui/depth.rs              |  5 ++
 .../horizon-client/src/item_render/special.rs |  1 +
 crates/horizon-client/src/mesher.rs           |  2 +
 crates/horizon-client/src/mobs.rs             |  3 +-
 crates/horizon-client/src/mobs/guardian.rs    |  2 +
 crates/horizon-client/src/mobs/render.rs      |  1 +
 crates/horizon-client/src/options_ui.rs       | 12 +--
 crates/horizon-client/src/particles.rs        |  2 +
 crates/horizon-client/src/shadows.rs          |  2 +
 43 files changed, 280 insertions(+), 75 deletions(-)

diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs
index 28a876d80..19af406e1 100644
--- a/crates/horizon-client/src/block_entity_render.rs
+++ b/crates/horizon-client/src/block_entity_render.rs
@@ -149,6 +149,8 @@ pub fn draw_part(
                 layer: 0,
                 color,
                 light,
+
+                glint_uv: [0.0, 0.0],
             });
         }
     }
@@ -648,6 +650,8 @@ fn draw_text(scene: &Scene, call: &TextCall, out: &mut Vec<Vertex>) {
                         layer: 0,
                         color: c,
                         light: call.light,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
@@ -1714,6 +1718,8 @@ impl BeamPart {
                     layer: 6,
                     color,
                     light: self.wrap,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
@@ -1784,6 +1790,7 @@ fn portal_cube(m: Mat4, faces: &[Direction], layer: u32, out: &mut Vec<Vertex>)
                 layer,
                 color: 0,
                 light: 0,
+                glint_uv: [0.0, 0.0],
             });
         }
     }
diff --git a/crates/horizon-client/src/breaking.rs b/crates/horizon-client/src/breaking.rs
index 84eedae75..df6d0f33b 100644
--- a/crates/horizon-client/src/breaking.rs
+++ b/crates/horizon-client/src/breaking.rs
@@ -49,6 +49,8 @@ pub fn geometry(
                     color: 0xffff_ffff,
                     light: stage_light(stage),
                     normal: [0; 4],
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
diff --git a/crates/horizon-client/src/clouds.rs b/crates/horizon-client/src/clouds.rs
index 70f29c132..5e9bb731a 100644
--- a/crates/horizon-client/src/clouds.rs
+++ b/crates/horizon-client/src/clouds.rs
@@ -179,6 +179,8 @@ impl Mesh {
                         layer: 4,
                         color: u32::MAX,
                         light: shade,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             };
diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl
index 79e11719f..307f3fbba 100644
--- a/crates/horizon-client/src/entity.wgsl
+++ b/crates/horizon-client/src/entity.wgsl
@@ -44,6 +44,8 @@ struct Out {
     // entity.vsh's lightMapColor, multiplied in after the overlay.
     @location(9) light_color: vec4<f32>,
     @location(10) @interpolate(flat) weather_rect: vec4<f32>,
+    // The `GLINT_TEXTURING` sample for overlay 7 (item foil).
+    @location(11) glint_uv: vec2<f32>,
 }
 // Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed.
 fn entity_light(normal: vec3<f32>, nether: bool) -> f32 {
@@ -103,12 +105,16 @@ fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
     out.spherical = select(length(position), 0.0, overlay >= 2u && overlay <= 4u);
     out.cylindrical = select(max(length(position.xz), abs(position.y)), 0.0, overlay >= 2u && overlay <= 4u);
     out.overlay = overlay;
+    out.glint_uv = vec2(0.0);
     if overlay == 4u { out.spherical = length(position); }
     return out;
 }
 @vertex fn vs_entity(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
-    @location(2) overlay: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>, @location(5) normal: vec4<f32>) -> Out {
-    return entity_vertex(position, uv, overlay, color, light, normal);
+    @location(2) overlay: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>,
+    @location(5) normal: vec4<f32>, @location(6) glint_uv: vec2<f32>) -> Out {
+    var out = entity_vertex(position, uv, overlay, color, light, normal);
+    out.glint_uv = glint_uv;
+    return out;
 }
 // Retained bolt-local geometry, translated using the same f64 camera
 // subtraction as the former CPU path before adding each local f32 position.
@@ -204,15 +210,11 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
     color = vec4(mix(in.overlay_color.rgb, color.rgb, in.overlay_color.a), color.a);
     color *= in.light_color;
     if in.overlay == 7u || in.overlay == 8u {
-        // Enchantment glint (overlay 7, 8 with the hurt tint): the purple
-        // enchanted_glint sheen drifting diagonally over the item's shape.
-        let px = in.uv * vec2<f32>(textureDimensions(atlas));
-        let t = globals.misc.y * 0.05;
-        let band = sin((px.x + px.y) * 0.9 - t * 6.0) * 0.5 + 0.5;
-        let band2 = sin((px.x - px.y) * 0.6 + t * 4.0) * 0.5 + 0.5;
-        let shimmer = pow(band * 0.6 + band2 * 0.4, 2.0);
-        let glint = vec3(0.50, 0.25, 0.80) * (0.25 + 0.75 * shimmer);
-        color = vec4(min(color.rgb + glint * 0.6, vec3(1.0)), color.a);
+        // Enchantment glint: item.fsh's GLINT path, sampled from
+        // enchanted_glint_item at the `GLINT_TEXTURING` UV.
+        let alpha = globals.fog_ends.w;
+        let glint = alpha * textureSample(atlas, atlas_sampler, in.glint_uv);
+        color = vec4(color.rgb + glint.rgb * glint.rgb, max(color.a, alpha));
     }
     let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
                 linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
diff --git a/crates/horizon-client/src/entity_culling.rs b/crates/horizon-client/src/entity_culling.rs
index 16de17465..0c309041a 100644
--- a/crates/horizon-client/src/entity_culling.rs
+++ b/crates/horizon-client/src/entity_culling.rs
@@ -186,6 +186,8 @@ mod tests {
             color: u32::MAX,
             light: 0,
             normal: [0; 4],
+
+            glint_uv: [0.0, 0.0],
         };
         let prior = vertex([0.0; 3]);
         let body = [vertex([8.0, -1.0, -1.0]), vertex([10.0, 1.0, 1.0])];
diff --git a/crates/horizon-client/src/fire_render.rs b/crates/horizon-client/src/fire_render.rs
index c3a9f6a92..98eff6f9d 100644
--- a/crates/horizon-client/src/fire_render.rs
+++ b/crates/horizon-client/src/fire_render.rs
@@ -48,6 +48,8 @@ pub fn flames(
                 color: 0xffff_ffff,
                 light: 0xf000 | (u32::from(scene_light >> 4) * 16),
                 normal: [0; 4],
+
+                glint_uv: [0.0, 0.0],
             });
         }
         remaining -= 0.45;
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 45fe3a8b1..91045ada5 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -7380,6 +7380,8 @@ impl Game<'_> {
                         layer: 0,
                         color,
                         light: packed,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
@@ -7999,6 +8001,8 @@ impl Game<'_> {
                     layer: 2,
                     color,
                     light: 0,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         };
@@ -10801,6 +10805,7 @@ impl Game<'_> {
             debug_lines_on_top: &debug_lines_on_top,
             debug_crosshair: &debug_crosshair,
             hud: &hud,
+            glint_alpha: self.settings.file.double("glintStrength") as f32,
             clouds: (!title
                 && self.dim == Dim::Overworld
                 && horizon_client::clouds::visible(&self.settings.clouds, sky.cloud_color[3]))
@@ -13478,6 +13483,7 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> {
         debug_lines_on_top: &[],
         debug_crosshair: &[],
         hud,
+        glint_alpha: 0.75,
         nether_lighting: false,
         entities: &[],
         entity_spans: &[],
diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs
index f175af401..92080b70c 100644
--- a/crates/horizon-client/src/game/armor_stands.rs
+++ b/crates/horizon-client/src/game/armor_stands.rs
@@ -872,6 +872,7 @@ impl Game<'_> {
                 lights: Some(horizon_client::block_entity_render::diffuse_lights(
                     self.dim == super::Dim::Nether,
                 )),
+                glint: self.glint(),
             };
             let profile = stack
                 .extra
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 86a7954e9..366420557 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -145,6 +145,8 @@ fn flame_geometry(
                 layer: 0,
                 color: 0xFFFF_FFFF,
                 light: packed,
+
+                glint_uv: [0.0, 0.0],
             });
         }
         h -= 0.45;
@@ -3316,6 +3318,8 @@ impl Game<'_> {
                     layer: 0,
                     color: 0xFFFF_FFFF,
                     light: packed,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index fff03ef1c..9cea0f48a 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -2482,6 +2482,8 @@ impl Game<'_> {
                         layer: 2,
                         color: c,
                         light: 0,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
@@ -2547,6 +2549,8 @@ impl Game<'_> {
                     layer: 6,
                     color: c,
                     light: wrap_light,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
             (last_sin, last_cos, last_u) = (sin, cos, uu);
@@ -2592,6 +2596,8 @@ impl Game<'_> {
                     layer: 0,
                     color: 0xFFFF_FFFF,
                     light: 240 | 240 << 8,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs
index 32d5113b0..6d845c259 100644
--- a/crates/horizon-client/src/game/end.rs
+++ b/crates/horizon-client/src/game/end.rs
@@ -247,6 +247,8 @@ impl Game<'_> {
                     layer: 2,
                     color,
                     light: 0,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
@@ -1240,6 +1242,8 @@ impl Game<'_> {
                     layer: 0,
                     color: 0xFFFF_FFFF,
                     light: full,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs
index 39f9e5ffe..55c1d46fd 100644
--- a/crates/horizon-client/src/game/fishing.rs
+++ b/crates/horizon-client/src/game/fishing.rs
@@ -643,6 +643,8 @@ impl Game<'_> {
                     layer: 0,
                     color: 0xFFFF_FFFF,
                     light: packed,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
diff --git a/crates/horizon-client/src/game/frames.rs b/crates/horizon-client/src/game/frames.rs
index d08c5f283..b9ba0b1cc 100644
--- a/crates/horizon-client/src/game/frames.rs
+++ b/crates/horizon-client/src/game/frames.rs
@@ -377,6 +377,8 @@ impl Game<'_> {
                             layer: 0,
                             color: 0xFFFF_FFFF,
                             light,
+
+                            glint_uv: [0.0, 0.0],
                         });
                     }
                 };
diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs
index b6b7e2fb7..580701ccd 100644
--- a/crates/horizon-client/src/game/item_draw.rs
+++ b/crates/horizon-client/src/game/item_draw.rs
@@ -296,8 +296,25 @@ impl Game<'_> {
             x,
             y,
             self.started.elapsed().as_secs_f32(),
+            self.settings.file.double("glintSpeed") as f32,
+            self.settings.file.double("glintStrength") as f32,
         );
     }
+    /// The `GLINT_TEXTURING` inputs the atlas and options provide.
+    pub(super) fn glint(&self) -> Option<item_render::Glint> {
+        self.gui
+            .atlas
+            .sprites
+            .get("misc/enchanted_glint_item")
+            .copied()
+            .map(|rect| item_render::Glint {
+                rect,
+                speed: self.settings.file.double("glintSpeed") as f32,
+                alpha: self.settings.file.double("glintStrength") as f32,
+                millis: self.started.elapsed().as_secs_f32() * 1000.0,
+                scale: 0.5,
+            })
+    }
     /// Submit a resolved item under `pose` (camera-relative) at `light`
     /// (packed lightmap coordinates).
     pub(super) fn submit_item_world(
@@ -311,6 +328,7 @@ impl Game<'_> {
             out,
             light,
             lights: Some(diffuse_lights(self.dim == Dim::Nether)),
+            glint: self.glint(),
         };
         state.submit(
             &self.pack.item_renderer,
@@ -332,6 +350,7 @@ impl Game<'_> {
             out,
             light,
             lights: None,
+            glint: self.glint(),
         };
         state.submit(
             &self.pack.item_renderer,
diff --git a/crates/horizon-client/src/game/leads.rs b/crates/horizon-client/src/game/leads.rs
index 8867157ee..b14cc351a 100644
--- a/crates/horizon-client/src/game/leads.rs
+++ b/crates/horizon-client/src/game/leads.rs
@@ -381,6 +381,8 @@ impl Game<'_> {
                                 layer: 0,
                                 color,
                                 light: packed,
+
+                                glint_uv: [0.0, 0.0],
                             });
                         }
                     }
diff --git a/crates/horizon-client/src/game/maps.rs b/crates/horizon-client/src/game/maps.rs
index 6da65c592..97e7996d0 100644
--- a/crates/horizon-client/src/game/maps.rs
+++ b/crates/horizon-client/src/game/maps.rs
@@ -1133,6 +1133,8 @@ impl Game<'_> {
                     layer: 0,
                     color: 0xFFFF_FFFF,
                     light,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         };
@@ -1180,6 +1182,8 @@ impl Game<'_> {
                         layer: 0,
                         color: 0xFFFF_FFFF,
                         light,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             };
@@ -1251,6 +1255,8 @@ impl Game<'_> {
                     layer: 0,
                     color: 0xFFFF_FFFF,
                     light,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index 072059e49..eeedbc9f5 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -1297,6 +1297,7 @@ impl Game<'_> {
                         layer: 0,
                         color,
                         light,
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
diff --git a/crates/horizon-client/src/game/mob_blocks.rs b/crates/horizon-client/src/game/mob_blocks.rs
index 083c96a66..5b26cd615 100644
--- a/crates/horizon-client/src/game/mob_blocks.rs
+++ b/crates/horizon-client/src/game/mob_blocks.rs
@@ -203,6 +203,8 @@ impl Game<'_> {
                     layer: overlay,
                     color,
                     light,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs
index 9f7561e53..9bc3200ec 100644
--- a/crates/horizon-client/src/game/names.rs
+++ b/crates/horizon-client/src/game/names.rs
@@ -377,6 +377,7 @@ impl Game<'_> {
                         layer,
                         color,
                         light,
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             };
diff --git a/crates/horizon-client/src/game/paintings.rs b/crates/horizon-client/src/game/paintings.rs
index 321e59f7d..1c0a74a47 100644
--- a/crates/horizon-client/src/game/paintings.rs
+++ b/crates/horizon-client/src/game/paintings.rs
@@ -308,6 +308,8 @@ impl Game<'_> {
                         layer: 0,
                         color,
                         light: packed,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             };
diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs
index caf49883b..a558dede2 100644
--- a/crates/horizon-client/src/game/perspective.rs
+++ b/crates/horizon-client/src/game/perspective.rs
@@ -710,6 +710,8 @@ mod preview_tests {
                     color: u32::MAX,
                     light: 0,
                     normal: [0; 4],
+
+                    glint_uv: [0.0, 0.0],
                 })
         };
         // A shield and arm can intersect: neither average depth orders both ends.
diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs
index 45bd64fa7..226046fec 100644
--- a/crates/horizon-client/src/game/text_displays.rs
+++ b/crates/horizon-client/src/game/text_displays.rs
@@ -268,6 +268,8 @@ impl Game<'_> {
                         light,
                         layer: if through { 2 } else { 0 },
                         normal: [0; 4],
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
diff --git a/crates/horizon-client/src/game/tnt.rs b/crates/horizon-client/src/game/tnt.rs
index 6bd2ae956..2e87fa185 100644
--- a/crates/horizon-client/src/game/tnt.rs
+++ b/crates/horizon-client/src/game/tnt.rs
@@ -332,6 +332,8 @@ impl Game<'_> {
                         layer: if lit { 5 } else { 0 },
                         color,
                         light: packed,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index 70d882a98..bd3c0b59c 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -172,7 +172,8 @@ struct Globals {
     inverse_view: [[f32; 4]; 4],
     sunrise: [f32; 4],
     sun: [f32; 4],
-    /// x: sky fog end, y: cloud fog end, z: dark disc (camera below the horizon), w: unused.
+    /// x: sky fog end, y: cloud fog end, z: dark disc (camera below the horizon),
+    /// w: the glint strength (`GlintAlpha`).
     fog_ends: [f32; 4],
     /// Atlas rects (u0, v0, width, height) of end_sky.png and end_portal.png.
     end_portal_sprites: [[f32; 4]; 2],
@@ -256,6 +257,9 @@ pub struct Frame<'a> {
     /// drawn after the hand at its projection, without the bob or fog.
     pub debug_crosshair: &'a [[f32; 8]],
     pub hud: &'a HudBatch,
+    /// `GlintAlpha` (accessibility Glint Strength); the entity shader uses it
+    /// for held/world items, independent of what the HUD batch last drew.
+    pub glint_alpha: f32,
     /// CardinalLighting.Type.NETHER, otherwise DEFAULT.
     pub nether_lighting: bool,
     /// Camera-relative entity geometry textured from the shared atlas.
@@ -1724,7 +1728,7 @@ impl Renderer {
             usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
             mapped_at_creation: false,
         });
-        let entity_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4];
+        let entity_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2];
         let entity_vertex = [Some(wgpu::VertexBufferLayout {
             array_stride: std::mem::size_of::<Vertex>() as u64,
             step_mode: wgpu::VertexStepMode::Vertex,
@@ -3475,7 +3479,7 @@ impl Renderer {
                 frame.fog.map_or(frame.distance.min(512.0), |f| f.sky_end),
                 frame.fog.map_or(2048.0, |f| f.cloud_end),
                 if frame.dark_disc { 1.0 } else { 0.0 },
-                0.0,
+                frame.glint_alpha,
             ],
             end_portal_sprites: frame.end_portal_sprites,
             crumbling_sprite: frame.crumbling_sprite,
@@ -5222,6 +5226,7 @@ mod tests {
                 color: 0xffff_ffff,
                 light: id,
                 normal: [0; 4],
+                glint_uv: [0.0, 0.0],
             }; 4]
         };
         let entities: Vec<_> = [
diff --git a/crates/horizon-client/src/gfx/end_sky.rs b/crates/horizon-client/src/gfx/end_sky.rs
index 15e9001fc..d74e053df 100644
--- a/crates/horizon-client/src/gfx/end_sky.rs
+++ b/crates/horizon-client/src/gfx/end_sky.rs
@@ -72,6 +72,8 @@ fn vertices(uv: [f32; 4]) -> Vec<Vertex> {
                         layer: 2,
                         color: 0xFF28_2828,
                         light: 0,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
diff --git a/crates/horizon-client/src/gfx/end_sky/tests.rs b/crates/horizon-client/src/gfx/end_sky/tests.rs
index 61266003d..5cd2bcf7f 100644
--- a/crates/horizon-client/src/gfx/end_sky/tests.rs
+++ b/crates/horizon-client/src/gfx/end_sky/tests.rs
@@ -12,15 +12,15 @@ fn geometry_matches_pre_residency_vertex_snapshots() {
     for (uv, expected) in [
         (
             [0.0, 0.0, 1.0, 1.0],
-            "f7ee23457fc557b33ecf09c9afaf858f3d8907e108abf06055f627523f733536",
+            "82a9be3f3ed1f733017df2c81dc6dff163f67bf739c768e3fd0f90f00c7802f6",
         ),
         (
             [0.125, 0.25, 0.375, 0.5],
-            "f74c4b8d23ec2b7c11b5752821d0733851bf11358f1b26f9448226ff62a6a318",
+            "05a058bd8e70cff900c8e1c81061892ed27866d86498ebe1e8ae5af4c3b770ef",
         ),
         (
             [0.13, 0.27, 0.41, 0.59],
-            "f0aaa39c5b22168bdc7c6c329acb4d3598a2feb61ff7b6f2850b644682749b39",
+            "93064b9fd2e745da46b927b2625edc8a381bb8c6e20b0f0880e816c4c1745ec1",
         ),
     ] {
         let mut mesh = vertices(uv);
@@ -31,10 +31,8 @@ fn geometry_matches_pre_residency_vertex_snapshots() {
                 if n == 0.0 { 0.0 } else { n }
             });
         }
-        assert_eq!(
-            format!("{:x}", Sha256::digest(bytemuck::cast_slice(&mesh))),
-            expected
-        );
+        let hash = format!("{:x}", Sha256::digest(bytemuck::cast_slice(&mesh)));
+        assert_eq!(hash, expected);
     }
 }
 
@@ -95,7 +93,7 @@ fn separate_draws_match_combined_celestial_pixels() {
         label: Some("End sky differential shader"),
         source: wgpu::ShaderSource::Wgsl(crate::gfx::entity_shader().into()),
     });
-    let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4];
+    let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2];
     let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
         label: Some("End sky differential pipeline"),
         layout: None,
@@ -305,6 +303,8 @@ fn separate_draws_match_combined_celestial_pixels() {
                             color: level * 0x01010101,
                             light: 0,
                             normal: [0; 4],
+
+                            glint_uv: [0.0, 0.0],
                         })
                         .to_vec()
                 };
diff --git a/crates/horizon-client/src/gfx/entity_batch.rs b/crates/horizon-client/src/gfx/entity_batch.rs
index 8153699fc..9d6c4bf65 100644
--- a/crates/horizon-client/src/gfx/entity_batch.rs
+++ b/crates/horizon-client/src/gfx/entity_batch.rs
@@ -130,6 +130,8 @@ mod tests {
                 color: index as u32,
                 light: (index * 3) as u32,
                 normal: [1, 2, 3, 4],
+
+                glint_uv: [0.0, 0.0],
             })
             .collect()
     }
diff --git a/crates/horizon-client/src/gfx/lightning.rs b/crates/horizon-client/src/gfx/lightning.rs
index 251dbf00e..d979bb368 100644
--- a/crates/horizon-client/src/gfx/lightning.rs
+++ b/crates/horizon-client/src/gfx/lightning.rs
@@ -77,6 +77,8 @@ fn geometry(seed: i64, uv: [f32; 2]) -> Vec<Vertex> {
                             layer: 2,
                             color,
                             light: 240 | 240 << 8,
+
+                            glint_uv: [0.0, 0.0],
                         });
                     }
                 }
diff --git a/crates/horizon-client/src/gfx/lightning/tests/mod.rs b/crates/horizon-client/src/gfx/lightning/tests/mod.rs
index f89f402de..ccaf963a5 100644
--- a/crates/horizon-client/src/gfx/lightning/tests/mod.rs
+++ b/crates/horizon-client/src/gfx/lightning/tests/mod.rs
@@ -60,6 +60,8 @@ fn reference(seed: i64, at: [f64; 3], camera: DVec3, uv: [f32; 2]) -> Vec<Vertex
                                 layer: 2,
                                 color,
                                 light: 240 | 240 << 8,
+
+                                glint_uv: [0.0, 0.0],
                             });
                         }
                     }
diff --git a/crates/horizon-client/src/gfx/pack_weather.rs b/crates/horizon-client/src/gfx/pack_weather.rs
index 3479450af..f6bef0219 100644
--- a/crates/horizon-client/src/gfx/pack_weather.rs
+++ b/crates/horizon-client/src/gfx/pack_weather.rs
@@ -135,6 +135,8 @@ impl PackWeather {
                 color: v.color,
                 light: v.light,
                 normal: [0; 4],
+
+                glint_uv: [0.0, 0.0],
             }
         }));
         if self.scratch.len() > self.capacity {
diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs
index 2b6acda41..41eae1ec7 100644
--- a/crates/horizon-client/src/hud.rs
+++ b/crates/horizon-client/src/hud.rs
@@ -554,6 +554,8 @@ pub struct HudVertex {
     pub uv: [f32; 2],
     pub color: u32,
     pub depth: f32,
+    /// The glint sprite UV (`GLINT_TEXTURING`), unused unless `uv.x >= 2`.
+    pub glint_uv: [f32; 2],
 }
 /// The GUI Scale option (0 = auto).
 pub static GUI_SCALE: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
@@ -569,6 +571,8 @@ pub struct HudBatch {
     pub blends: Vec<(std::ops::Range<u32>, Blend)>,
     /// The textures and time of the `Blend::EndPortal` runs.
     pub end_portal: EndPortalFill,
+    /// `options.glintStrength` for the glint pass (`GlintAlpha`).
+    pub glint_alpha: f32,
     /// Screen's first vertex: the preceding HUD is part of its blurred background.
     pub blur_at: u32,
 }
@@ -620,6 +624,7 @@ impl HudBatch {
             patches: Vec::new(),
             blends: Vec::new(),
             end_portal: EndPortalFill::default(),
+            glint_alpha: 0.75,
             blur_at: 0,
         }
     }
@@ -695,6 +700,26 @@ impl HudBatch {
                 uv: uv[i],
                 color,
                 depth: 0.0,
+                glint_uv: [0.0, 0.0],
+            });
+        }
+    }
+    /// A quad whose texture is the `GLINT_TEXTURING` sample at `glint_uv`;
+    /// `uv` is the item's atlas UV, which the shader masks by.
+    pub fn quad_glint(
+        &mut self,
+        p: [[f32; 2]; 4],
+        uv: [[f32; 2]; 4],
+        glint_uv: [[f32; 2]; 4],
+        color: u32,
+    ) {
+        for i in [0, 1, 2, 0, 2, 3] {
+            self.vertices.push(HudVertex {
+                pos: p[i],
+                uv: uv[i],
+                color,
+                depth: 0.0,
+                glint_uv: glint_uv[i],
             });
         }
     }
@@ -705,6 +730,7 @@ impl HudBatch {
                 uv: uv[i],
                 color,
                 depth: p[i][2],
+                glint_uv: [0.0, 0.0],
             });
         }
     }
@@ -875,6 +901,7 @@ impl HudBatch {
                 uv,
                 color: c[i],
                 depth: 0.0,
+                glint_uv: [0.0, 0.0],
             });
         }
     }
@@ -1122,7 +1149,8 @@ impl HudRenderer {
             bind_group_layouts: &[Some(&layout)],
             ..Default::default()
         });
-        let attributes = wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4,3=>Float32];
+        let attributes =
+            wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4,3=>Float32,4=>Float32x2];
         let create = |label, blend, fragment_entry, depth: bool| {
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                 label: Some(label),
@@ -1337,7 +1365,12 @@ impl HudRenderer {
             &self.uniform,
             0,
             bytemuck::bytes_of(&HudUniform::new(
-                [size[0] as f32, size[1] as f32, batch.scale, 0.0],
+                [
+                    size[0] as f32,
+                    size[1] as f32,
+                    batch.scale,
+                    batch.glint_alpha,
+                ],
                 batch.end_portal,
             )),
         );
@@ -1787,6 +1820,7 @@ mod tests {
                 patches: Vec::new(),
                 blends: Vec::new(),
                 end_portal: EndPortalFill::default(),
+                glint_alpha: 0.75,
                 blur_at: 0,
             };
             for (image_width, image_height) in [(195, 136), (176, 166), (176, 222)] {
diff --git a/crates/horizon-client/src/hud.wgsl b/crates/horizon-client/src/hud.wgsl
index ebb6dc2cb..1f6d5797e 100644
--- a/crates/horizon-client/src/hud.wgsl
+++ b/crates/horizon-client/src/hud.wgsl
@@ -13,22 +13,26 @@ struct Out {
     @location(1) color: vec4<f32>,
     // projection_from_position(gl_Position): the End portal's texProj0.
     @location(2) proj: vec4<f32>,
+    @location(3) glint_uv: vec2<f32>,
 }
-@vertex fn vs_main(@location(0) pos: vec2<f32>, @location(1) uv: vec2<f32>, @location(2) color: vec4<f32>, @location(3) depth: f32) -> Out {
+@vertex fn vs_main(@location(0) pos: vec2<f32>, @location(1) uv: vec2<f32>, @location(2) color: vec4<f32>, @location(3) depth: f32, @location(4) glint_uv: vec2<f32>) -> Out {
     let pixels = pos * hud.size.z;
     var out: Out;
     out.clip = vec4(pixels.x / hud.size.x * 2.0 - 1.0, 1.0 - pixels.y / hud.size.y * 2.0, depth, 1.0);
     out.uv = uv;
     out.color = color;
     out.proj = vec4(out.clip.xy * 0.5 + 0.5, out.clip.zw);
+    out.glint_uv = glint_uv;
     return out;
 }
 @fragment fn fs_main(in: Out) -> @location(0) vec4<f32> {
-    // u >= 2: flat vertex colour masked by the texture's alpha (enchantment glint).
+    // u >= 2: the GLINT_TEXTURING sample over the item, masked by the item's
+    // texture alpha (item.fsh's ALPHA_CUTOUT and GLINT path).
     if in.uv.x >= 2.0 {
-        let m = textureSample(atlas, atlas_sampler, in.uv - vec2(2.0, 0.0)).a * in.color.a;
-        if m < 0.004 { discard; }
-        return vec4(in.color.rgb, m);
+        let mask = textureSample(atlas, atlas_sampler, in.uv - vec2(2.0, 0.0)).a;
+        if mask < 0.1 { discard; }
+        let glint = hud.size.w * textureSample(atlas, atlas_sampler, in.glint_uv);
+        return vec4(glint.rgb * glint.rgb, mask);
     }
     let c = textureSample(atlas, atlas_sampler, in.uv) * in.color;
     if c.a < 0.004 { discard; }
diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs
index 4f981b874..0a72b2ecc 100644
--- a/crates/horizon-client/src/item_render.rs
+++ b/crates/horizon-client/src/item_render.rs
@@ -41,12 +41,48 @@ use std::{
 pub struct ItemQuad {
     pub pos: [Vec3; 4],
     pub uv: [[f32; 2]; 4],
+    /// The model UVs `GLINT_TEXTURING` scrolls for the glint (vanilla's UV0,
+    /// or UV3 for a special model).
+    pub foil_uv: [[f32; 2]; 4],
     pub normal: Vec3,
     pub color: u32,
     pub foil: Foil,
     /// `MaterialInfo.lightEmission` (block light floor).
     pub light_emission: u8,
 }
+/// `TextureTransform.setupGlintTexturing`'s inputs and the glint sprite.
+#[derive(Clone, Copy, Debug)]
+pub struct Glint {
+    pub rect: crate::hud::Rect,
+    /// `options.glintSpeed` (vanilla default 0.5).
+    pub speed: f32,
+    /// `options.glintStrength` / shader `GlintAlpha` (vanilla default 0.75).
+    pub alpha: f32,
+    /// `Util.getMillis()`.
+    pub millis: f32,
+    /// The transform's scale: `GLINT_TEXTURING`'s 8.0 for GUI items,
+    /// `ENTITY_GLINT_TEXTURING`'s 0.5 for items in the world.
+    pub scale: f32,
+}
+impl Glint {
+    /// `TextureTransform.setupGlintTexturing(scale)`: translation(-o0, o1) *
+    /// rotateZ(PI/18) * scale, wrapped and mapped into the glint sprite.
+    pub fn atlas_uv(&self, model: [f32; 2]) -> [f32; 2] {
+        let millis = (f64::from(self.millis) * f64::from(self.speed) * 8.0) as i64;
+        let offset0 = (millis % 110000) as f32 / 110000.0;
+        let offset1 = (millis % 30000) as f32 / 30000.0;
+        let angle = std::f32::consts::PI / 18.0;
+        let (sin, cos) = angle.sin_cos();
+        let x = model[0] * self.scale * cos - model[1] * self.scale * sin - offset0;
+        let y = model[0] * self.scale * sin + model[1] * self.scale * cos + offset1;
+        let u = (x - x.floor()).clamp(0.5 / self.rect.w as f32, 1.0 - 0.5 / self.rect.w as f32);
+        let v = (y - y.floor()).clamp(0.5 / self.rect.h as f32, 1.0 - 0.5 / self.rect.h as f32);
+        [
+            self.rect.u0 + u * (self.rect.u1 - self.rect.u0),
+            self.rect.v0 + v * (self.rect.v1 - self.rect.v0),
+        ]
+    }
+}
 /// Which glint render type a quad uses.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Foil {
@@ -242,6 +278,7 @@ fn submit_quads(
         sink.quad(ItemQuad {
             pos,
             uv,
+            foil_uv: q.uv,
             normal: transform_normal(m, direction_vector(q.facing)),
             color: argb(color),
             foil,
@@ -679,6 +716,8 @@ pub struct WorldSink<'a> {
     pub light: u32,
     /// The level's diffuse lights; `None` leaves the colour unshaded.
     pub lights: Option<(Vec3, Vec3)>,
+    /// The `GLINT_TEXTURING` sample for foil quads (`None` leaves them unglinted).
+    pub glint: Option<Glint>,
 }
 impl ItemSink for WorldSink<'_> {
     fn quad(&mut self, q: ItemQuad) {
@@ -693,8 +732,14 @@ impl ItemSink for WorldSink<'_> {
         } else {
             self.light
         };
-        let overlay = if q.foil == Foil::None { 0 } else { 7 };
-        for (p, uv) in q.pos.iter().zip(q.uv) {
+        let glint = if q.foil == Foil::None {
+            None
+        } else {
+            self.glint
+        };
+        let overlay = if glint.is_some() { 7 } else { 0 };
+        for (i, (p, uv)) in q.pos.iter().zip(q.uv).enumerate() {
+            let glint_uv = glint.map_or([0.0, 0.0], |glint| glint.atlas_uv(q.foil_uv[i]));
             self.out.push(Vertex {
                 normal: [0; 4],
                 pos: p.to_array(),
@@ -702,6 +747,7 @@ impl ItemSink for WorldSink<'_> {
                 layer: overlay,
                 color,
                 light,
+                glint_uv,
             });
         }
     }
diff --git a/crates/horizon-client/src/item_render/gui.rs b/crates/horizon-client/src/item_render/gui.rs
index ff25fff1d..87dfb354e 100644
--- a/crates/horizon-client/src/item_render/gui.rs
+++ b/crates/horizon-client/src/item_render/gui.rs
@@ -5,7 +5,7 @@
 //! drawn far to near, and clipped to the item's 16x16 slot unless the model
 //! is oversized in the GUI (`GuiItemAtlas` draws each item into a scissored
 //! 16x16 slot; oversized items get a picture-in-picture of their bounds).
-use super::{Foil, ItemQuad, ItemRenderState, ItemRenderer, SpecialHost};
+use super::{Foil, Glint, ItemQuad, ItemRenderState, ItemRenderer, SpecialHost};
 use crate::hud::{HudBatch, Rect};
 use glam::{EulerRot, Mat4, Vec2, Vec3};
 use std::{collections::HashMap, f32::consts::PI, sync::Arc};
@@ -43,6 +43,7 @@ pub fn items_3d_lights() -> (Vec3, Vec3) {
 struct Point {
     p: Vec2,
     uv: [f32; 2],
+    glint_uv: [f32; 2],
 }
 fn lerp(a: Point, b: Point, t: f32) -> Point {
     Point {
@@ -51,6 +52,10 @@ fn lerp(a: Point, b: Point, t: f32) -> Point {
             a.uv[0] + (b.uv[0] - a.uv[0]) * t,
             a.uv[1] + (b.uv[1] - a.uv[1]) * t,
         ],
+        glint_uv: [
+            a.glint_uv[0] + (b.glint_uv[0] - a.glint_uv[0]) * t,
+            a.glint_uv[1] + (b.glint_uv[1] - a.glint_uv[1]) * t,
+        ],
     }
 }
 /// Sutherland-Hodgman against one half plane `dot(p, n) <= limit`.
@@ -97,37 +102,25 @@ pub fn lit_color(q: &ItemQuad, lights: (Vec3, Vec3)) -> u32 {
     let c = |v: u8| (f32::from(v) * light) as u8;
     crate::hud::rgba(c(r), c(g), c(b), a)
 }
-/// The glint's moving sheen at a GUI position (a stand-in for the
-/// `GLINT_TEXTURING`-scrolled `enchanted_glint_item` texture added on top).
-fn glint_color(p: Vec2, time: f32) -> u32 {
-    let d = ((p.x + p.y) / 32.0 - time * 0.35).rem_euclid(1.0);
-    let band = (1.0 - (d - 0.5).abs() * 6.0).max(0.0);
-    crate::hud::rgba(
-        (170.0 + 70.0 * band) as u8,
-        (90.0 + 110.0 * band) as u8,
-        255,
-        (45.0 + 110.0 * band) as u8,
-    )
-}
-
-fn emit(batch: &mut HudBatch, fan: &[Point], color: impl Fn(Vec2) -> u32, glint: bool) {
-    let shift = if glint { 2.0 } else { 0.0 };
+fn emit(batch: &mut HudBatch, fan: &[Point], color: impl Fn(Vec2) -> u32, glint: Option<&Glint>) {
     for i in 1..fan.len().saturating_sub(1) {
         let (a, b, c) = (fan[0], fan[i], fan[i + 1]);
         let corners = [a, b, c, c];
-        // `HudBatch.quad` draws (0, 1, 2) and (0, 2, 3): the second is empty.
-        batch.quad(
-            corners.map(|v| v.p.to_array()),
-            corners.map(|v| [v.uv[0] + shift, v.uv[1]]),
-            color(a.p),
-        );
-        if glint {
-            // Per-vertex colours are flat per quad in the HUD batch: use the
-            // fan centre for the sheen.
-            let n = batch.vertices.len();
-            for v in &mut batch.vertices[n - 6..] {
-                v.color = color(Vec2::from(v.pos));
-            }
+        if let Some(glint) = glint {
+            let start = batch.vertices.len();
+            batch.quad_glint(
+                corners.map(|v| v.p.to_array()),
+                corners.map(|v| [v.uv[0] + 2.0, v.uv[1]]),
+                corners.map(|v| glint.atlas_uv(v.glint_uv)),
+                u32::MAX,
+            );
+            batch.blend_since(start, crate::hud::Blend::Additive);
+        } else {
+            batch.quad(
+                corners.map(|v| v.p.to_array()),
+                corners.map(|v| v.uv),
+                color(a.p),
+            );
         }
     }
 }
@@ -144,6 +137,8 @@ pub fn draw(
     x: f32,
     y: f32,
     time: f32,
+    glint_speed: f32,
+    glint_alpha: f32,
 ) {
     if state.is_empty() {
         return;
@@ -256,7 +251,18 @@ fn draw_now(
     } else {
         [x, y, x + 16.0, y + 16.0]
     };
-    draw_quads(&quads, lights, batch, rect, time);
+    let glint = sprites
+        .get("misc/enchanted_glint_item")
+        .copied()
+        .map(|rect| Glint {
+            rect,
+            speed: glint_speed,
+            alpha: glint_alpha,
+            millis: time * 1000.0,
+            scale: 8.0,
+        });
+    batch.glint_alpha = glint_alpha;
+    draw_quads(&quads, lights, batch, rect, glint.as_ref());
 }
 
 /// Lights, culls, sorts far to near and clips `quads` (GUI positions) to
@@ -266,7 +272,7 @@ fn draw_quads(
     lights: (Vec3, Vec3),
     batch: &mut HudBatch,
     rect: [f32; 4],
-    time: f32,
+    glint: Option<&Glint>,
 ) {
     for face in depth::sort(quads) {
         let q = &quads[face.quad];
@@ -276,6 +282,7 @@ fn draw_quads(
             .map(|v| Point {
                 p: v.pos.truncate(),
                 uv: v.uv,
+                glint_uv: v.glint_uv,
             })
             .collect();
         let color = lit_color(q, lights);
@@ -285,9 +292,9 @@ fn draw_quads(
             if fan.len() < 3 {
                 continue;
             }
-            emit(batch, &fan, |_| color, false);
+            emit(batch, &fan, |_| color, None);
             if q.foil != Foil::None {
-                emit(batch, &fan, |p| glint_color(p, time), true);
+                emit(batch, &fan, |_| color, glint);
             }
         }
     }
@@ -342,7 +349,7 @@ pub fn draw_banner_result(
         items_flat_lights(),
         batch,
         [x0, y0, x0 + 20.0, y0 + 40.0],
-        0.0,
+        None,
     );
 }
 
@@ -354,6 +361,7 @@ mod tests {
         ItemQuad {
             pos: [(0.0, y0), (0.0, y1), (8.0, y1), (8.0, y0)].map(|(x, y)| Vec3::new(x, y, z(y))),
             uv: [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]],
+            foil_uv: [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]],
             normal: Vec3::Z,
             color,
             foil: Foil::None,
@@ -394,7 +402,7 @@ mod tests {
             (Vec3::Z, Vec3::Z),
             &mut batch,
             [0.0, 0.0, 16.0, 16.0],
-            0.0,
+            None,
         );
         assert_eq!(color_at(&batch, Vec2::new(4.0, 0.5)), Some(u32::MAX));
     }
@@ -410,7 +418,7 @@ mod tests {
                 (Vec3::Z, Vec3::Z),
                 &mut batch,
                 [0.0, 0.0, 16.0, 16.0],
-                0.0,
+                None,
             );
             assert_eq!(
                 color_at(&batch, Vec2::new(4.0, 2.0)),
@@ -442,7 +450,7 @@ mod tests {
             (Vec3::Z, Vec3::Z),
             &mut batch,
             [0.0, 0.0, 16.0, 16.0],
-            0.0,
+            None,
         );
         for y in [0.5, 6.0] {
             assert_eq!(
@@ -468,6 +476,7 @@ mod tests {
         let p = |x: f32, y: f32| Point {
             p: Vec2::new(x, y),
             uv: [x, y],
+            glint_uv: [0.0, 0.0],
         };
         let fan = clip_triangle(
             [p(-4.0, 0.0), p(8.0, 0.0), p(8.0, 8.0)],
diff --git a/crates/horizon-client/src/item_render/gui/depth.rs b/crates/horizon-client/src/item_render/gui/depth.rs
index 9fecfdee7..aaaa0c55d 100644
--- a/crates/horizon-client/src/item_render/gui/depth.rs
+++ b/crates/horizon-client/src/item_render/gui/depth.rs
@@ -10,6 +10,7 @@ use glam::{Vec3, Vec4};
 pub(super) struct Corner {
     pub pos: Vec3,
     pub uv: [f32; 2],
+    pub glint_uv: [f32; 2],
 }
 
 pub(super) struct Face {
@@ -38,6 +39,9 @@ fn split(face: Face, distances: &[f32]) -> (Face, Face) {
             let corner = Corner {
                 pos: a.pos.lerp(b.pos, t),
                 uv: std::array::from_fn(|k| a.uv[k] + (b.uv[k] - a.uv[k]) * t),
+                glint_uv: std::array::from_fn(|k| {
+                    a.glint_uv[k] + (b.glint_uv[k] - a.glint_uv[k]) * t
+                }),
             };
             back.push(corner);
             front.push(corner);
@@ -73,6 +77,7 @@ pub(super) fn sort(quads: &[ItemQuad]) -> Vec<Face> {
                 corners: std::array::from_fn::<_, 4, _>(|k| Corner {
                     pos: q.pos[k],
                     uv: q.uv[k],
+                    glint_uv: q.foil_uv[k],
                 })
                 .to_vec(),
             })
diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs
index d42378db1..6d8477ead 100644
--- a/crates/horizon-client/src/item_render/special.rs
+++ b/crates/horizon-client/src/item_render/special.rs
@@ -115,6 +115,7 @@ fn draw(
                     sprite.v0 + (sprite.v1 - sprite.v0) * v[4],
                 ]
             }),
+            foil_uv: poly.map(|v| [v[3], v[4]]),
             normal,
             color,
             foil,
diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs
index 48d2f08bd..7594e7e31 100644
--- a/crates/horizon-client/src/mesher.rs
+++ b/crates/horizon-client/src/mesher.rs
@@ -38,6 +38,8 @@ pub struct Vertex {
     pub light: u32,
     /// RGBA8_SNORM face normal; w = -127 for two-sided lighting, 0 to keep baked/unlit colour.
     pub normal: [i8; 4],
+    /// The `GLINT_TEXTURING` atlas UV for a foil item quad; zero elsewhere.
+    pub glint_uv: [f32; 2],
 }
 /// A section vertex: vanilla's `DefaultVertexFormat.BLOCK` (position, colour,
 /// UV0, UV2) with the sprite's array layer beside the light, in 24 bytes
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 6b1e16f5c..61db8c909 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -2013,6 +2013,7 @@ pub fn render_model(
                     layer: overlay,
                     color: 0xFFFF_FFFF,
                     light,
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
@@ -2147,7 +2148,7 @@ mod lighting_tests {
     #[test]
     fn packed_normal_uses_native_snorm_bytes_without_changing_vertex_offsets() {
         assert_eq!(std::mem::offset_of!(Vertex, normal), 32);
-        assert_eq!(std::mem::size_of::<Vertex>(), 36);
+        assert_eq!(std::mem::size_of::<Vertex>(), 44);
         let part = plane([0.0, 1.0, 0.0]);
         assert_eq!(
             part.polygons[0].vertex_normal(ModelNormals::new(Mat4::from_scale(Vec3::ZERO))),
diff --git a/crates/horizon-client/src/mobs/guardian.rs b/crates/horizon-client/src/mobs/guardian.rs
index 9704de044..e57e6ee9f 100644
--- a/crates/horizon-client/src/mobs/guardian.rs
+++ b/crates/horizon-client/src/mobs/guardian.rs
@@ -396,6 +396,8 @@ pub fn beam_geometry(
             layer: 0,
             color,
             light: 240 | 240 << 8,
+
+            glint_uv: [0.0, 0.0],
         });
     };
     // Sides: one quad per texture repeat.
diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs
index 077fd38a6..8620d88f5 100644
--- a/crates/horizon-client/src/mobs/render.rs
+++ b/crates/horizon-client/src/mobs/render.rs
@@ -968,6 +968,7 @@ fn draw_normals(
                     layer: overlay,
                     color,
                     light,
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs
index 61fda9878..cd26f2203 100644
--- a/crates/horizon-client/src/options_ui.rs
+++ b/crates/horizon-client/src/options_ui.rs
@@ -167,8 +167,6 @@ impl Opt {
                 | Opt::NarratorHotkey
                 | Opt::ChatDelay
                 | Opt::DistortionEffects
-                | Opt::GlintSpeed
-                | Opt::GlintStrength
                 | Opt::MonochromeLogo
                 | Opt::RotateWithMinecarts
                 | Opt::HighContrastBlockOutlines
@@ -625,10 +623,12 @@ impl Opt {
                 self.file_key().unwrap(),
                 crate::options_file::V::Double(f64::from(v).powi(2)),
             ),
-            Opt::DamageTilt | Opt::PanoramaSpeed => s.file.set(
-                self.file_key().unwrap(),
-                crate::options_file::V::Double(f64::from(v)),
-            ),
+            Opt::DamageTilt | Opt::PanoramaSpeed | Opt::GlintSpeed | Opt::GlintStrength => {
+                s.file.set(
+                    self.file_key().unwrap(),
+                    crate::options_file::V::Double(f64::from(v)),
+                )
+            }
             Opt::Fov => s.fov = step(30.0, 110.0),
             Opt::RenderDistance => s.render_distance = step(2.0, 64.0) as i32,
             Opt::SimulationDistance => s.simulation_distance = step(5.0, 32.0) as i32,
diff --git a/crates/horizon-client/src/particles.rs b/crates/horizon-client/src/particles.rs
index fa9dc9c6e..23679cfb7 100644
--- a/crates/horizon-client/src/particles.rs
+++ b/crates/horizon-client/src/particles.rs
@@ -3946,6 +3946,8 @@ impl ParticleEngine {
                         },
                         color,
                         light,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
diff --git a/crates/horizon-client/src/shadows.rs b/crates/horizon-client/src/shadows.rs
index dece7f726..613eb0bb1 100644
--- a/crates/horizon-client/src/shadows.rs
+++ b/crates/horizon-client/src/shadows.rs
@@ -119,6 +119,8 @@ pub fn shadow(
                         layer: crate::gfx::SHADOW_OVERLAY,
                         color,
                         light: 240 | 240 << 8,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }

From a1761dcb658b8ac5401251320e3d18237067e42d Mon Sep 17 00:00:00 2001
From: masa-masa-0314 <348336850+masa-masa-0314@users.noreply.github.com>
Date: Tue, 27 Oct 2026 00:57:16 +0800
Subject: [PATCH 223/475] Lightning: move the bolt offset to vertex attribute 7

The retained bolt offset and the entity vertex's new glint UV were both
declared at attribute location 6, and the lightning pipeline builds its
vertex buffers from the entity layout plus the bolt-offset instance
buffer, so Device::create_render_pipeline rejected the location clash
and the client crashed at startup.

Co-Authored-By: ZCode <agent@zcode.dev>
---
 crates/horizon-client/src/entity.wgsl                | 3 ++-
 crates/horizon-client/src/gfx.rs                     | 3 ++-
 crates/horizon-client/src/gfx/lightning/tests/mod.rs | 5 +++--
 3 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl
index 307f3fbba..2e7abda21 100644
--- a/crates/horizon-client/src/entity.wgsl
+++ b/crates/horizon-client/src/entity.wgsl
@@ -118,9 +118,10 @@ fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
 }
 // Retained bolt-local geometry, translated using the same f64 camera
 // subtraction as the former CPU path before adding each local f32 position.
+// The bolt offset is instance attribute 7: 6 is the entity vertex's glint UV.
 @vertex fn vs_lightning(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
     @location(2) overlay: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>, @location(5) normal: vec4<f32>,
-    @location(6) offset: vec3<f32>) -> Out {
+    @location(7) offset: vec3<f32>) -> Out {
     return entity_vertex(offset + position, uv, overlay, color, light, normal);
 }
 struct CloudInfo {
diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index bd3c0b59c..bd2b932f0 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -1869,7 +1869,8 @@ impl Renderer {
             alpha_blend,
             false,
         );
-        let lightning_attributes = wgpu::vertex_attr_array![6=>Float32x3];
+        // Attribute 7: 6 is the entity vertex buffer's glint UV.
+        let lightning_attributes = wgpu::vertex_attr_array![7=>Float32x3];
         let lightning_vertex = [
             entity_vertex[0].clone(),
             Some(wgpu::VertexBufferLayout {
diff --git a/crates/horizon-client/src/gfx/lightning/tests/mod.rs b/crates/horizon-client/src/gfx/lightning/tests/mod.rs
index ccaf963a5..66959ce54 100644
--- a/crates/horizon-client/src/gfx/lightning/tests/mod.rs
+++ b/crates/horizon-client/src/gfx/lightning/tests/mod.rs
@@ -227,8 +227,9 @@ fn retained_gpu_draw_matches_transient_additive_draw() {
         label: Some("Lightning differential shader"),
         source: wgpu::ShaderSource::Wgsl(crate::gfx::entity_shader().into()),
     });
-    let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4];
-    let offsets = wgpu::vertex_attr_array![6=>Float32x3];
+    let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2];
+    // Attribute 7: 6 is the entity vertex buffer's glint UV.
+    let offsets = wgpu::vertex_attr_array![7=>Float32x3];
     let vertices = [Some(wgpu::VertexBufferLayout {
         array_stride: std::mem::size_of::<Vertex>() as u64,
         step_mode: wgpu::VertexStepMode::Vertex,

From 43d1f4b80185a11e405199188a6ba993c520bf42 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:06:26 +0100
Subject: [PATCH 224/475] Draw the swirls of potion effects around players and
 mobs

A client draws the particles of an entity's visible effects itself, from
the synched effect particle list (LivingEntity.tickEffects). Horizon drew
none and sent no such list: now the window's own player, a server's mobs
and players, and the mobs and guests of a game in the frame all swirl.
---
 .../horizon-client/src/game/client_ambient.rs | 119 +++++++++++++++++-
 crates/horizon-client/src/game/lan.rs         |  11 ++
 .../src/game/remote_mob_data.rs               |  31 ++++-
 crates/horizon-client/src/lan/hub.rs          |  62 ++++++++-
 crates/horizon-client/src/mobs.rs             |   4 +
 5 files changed, 223 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/game/client_ambient.rs b/crates/horizon-client/src/game/client_ambient.rs
index a10c6da49..48bfc663c 100644
--- a/crates/horizon-client/src/game/client_ambient.rs
+++ b/crates/horizon-client/src/game/client_ambient.rs
@@ -5,7 +5,8 @@
 //! a server: nothing of them goes over the network.
 use super::Game;
 use horizon_client::mobs::{MobEvent, ambient};
-use horizon_client::particles::{ParticleOptions, ParticleType};
+use horizon_client::particles::{ParticleEngine, ParticleOptions, ParticleType};
+use horizon_core::{geometry::Vec3, random::RandomSource};
 
 impl Game<'_> {
     pub(super) fn tick_client_ambient(&mut self) {
@@ -33,5 +34,121 @@ impl Game<'_> {
             }
         }
         self.eye_particles();
+        self.effect_swirls();
+    }
+
+    /// `LivingEntity.tickEffects` on a client: the swirls around an entity
+    /// with visible effects, from the particles its synched data lists. The
+    /// window's player has its own effects, a server's mobs and players the
+    /// list the server sent, and the mobs and guests of a game in the frame
+    /// theirs.
+    fn effect_swirls(&mut self) {
+        if let Some(p) = self.player.as_ref() {
+            let effects = &self.potions.effects.list;
+            let list: Vec<_> = effects
+                .iter()
+                .filter(|e| e.visible)
+                .filter_map(|e| effect_particle(e.id, e.ambient))
+                .collect();
+            let ambient = effects.iter().filter(|e| e.visible).all(|e| e.ambient);
+            let invisible = effects.iter().any(|e| e.id == "invisibility");
+            let size = (
+                f64::from(p.dimensions.width),
+                f64::from(p.dimensions.height),
+            );
+            swirl(
+                &mut self.particles,
+                p.position,
+                size,
+                &list,
+                ambient,
+                invisible,
+            );
+        }
+        let guests = self.lan.iter().flat_map(|host| host.models.values());
+        for m in self.mobs.iter().chain(guests) {
+            if !m.alive() {
+                continue;
+            }
+            let size = (f64::from(m.width()), f64::from(m.height()));
+            let invisible = m.invisible || m.has_effect("minecraft:invisibility");
+            if m.extra.effect_particles.is_empty() {
+                // A mob of this game: its own effects, visible and not ambient.
+                if m.extra.effects.is_empty() {
+                    continue;
+                }
+                let list: Vec<_> = m
+                    .extra
+                    .effects
+                    .iter()
+                    .filter_map(|e| effect_particle(e.0, false))
+                    .collect();
+                swirl(
+                    &mut self.particles,
+                    m.position,
+                    size,
+                    &list,
+                    false,
+                    invisible,
+                );
+            } else {
+                let list = &m.extra.effect_particles;
+                let ambient = m.extra.effect_ambient;
+                swirl(
+                    &mut self.particles,
+                    m.position,
+                    size,
+                    list,
+                    ambient,
+                    invisible,
+                );
+            }
+        }
     }
 }
+
+/// `MobEffect.particleFactory`: the omens have particles of their own, any
+/// other effect an entity effect in its colour, faint when ambient.
+pub(super) fn effect_particle(effect: &str, ambient: bool) -> Option<ParticleOptions> {
+    Some(match effect.trim_start_matches("minecraft:") {
+        "trial_omen" => ParticleOptions::simple(ParticleType::TrialOmen),
+        "raid_omen" => ParticleOptions::simple(ParticleType::RaidOmen),
+        other => {
+            let color = horizon_client::brewing::effect(other)?.color;
+            let channel = |shift: u32| ((color >> shift) & 255) as f32 / 255.0;
+            // MobEffect.AMBIENT_ALPHA is 38 of 255.
+            let alpha = if ambient { 38.0 / 255.0 } else { 1.0 };
+            ParticleOptions::colored(
+                ParticleType::EntityEffect,
+                [channel(16), channel(8), channel(0), alpha],
+            )
+        }
+    })
+}
+
+/// One tick of `LivingEntity.tickEffects`' client branch: a one in four
+/// chance (one in fifteen while invisible, a fifth of either when all the
+/// effects are ambient) of one of the particles at a random spot of the box.
+fn swirl(
+    particles: &mut ParticleEngine,
+    feet: Vec3,
+    size: (f64, f64),
+    list: &[ParticleOptions],
+    ambient: bool,
+    invisible: bool,
+) {
+    if list.is_empty() {
+        return;
+    }
+    let bound = if invisible { 15 } else { 4 } * if ambient { 5 } else { 1 };
+    let r = particles.random();
+    let Ok(0) = r.next_int_bound(bound) else {
+        return;
+    };
+    // Util.getRandom, then getRandomX(0.5), getRandomY and getRandomZ.
+    let pick = r.next_int_bound(list.len() as i32).unwrap_or_default() as usize;
+    let x = feet.x + size.0 * (2.0 * r.next_double() - 1.0) * 0.5;
+    let y = feet.y + size.1 * r.next_double();
+    let z = feet.z + size.0 * (2.0 * r.next_double() - 1.0) * 0.5;
+    particles.add(&list[pick], [x, y, z], [1.0; 3]);
+}
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..a48c30656 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -178,6 +178,11 @@ fn mob_meta(
         meta.push((9, serializer::FLOAT, Value::Float(health)));
     }
     defaults.push((9, serializer::FLOAT, Value::Float(1.0)));
+    // LivingEntity.DATA_EFFECT_PARTICLES and DATA_EFFECT_AMBIENCE_ID: the
+    // swirls of its effects (the ones a mob has are visible, not ambient).
+    meta.extend(hub.effect_meta(m.extra.effects.iter().map(|e| (e.0, false))));
+    defaults.push((10, serializer::PARTICLES, Value::Particles(Vec::new())));
+    defaults.push((11, serializer::BOOLEAN, Value::Bool(false)));
     // Mob.DATA_MOB_FLAGS_ID: no AI 1, left-handed 2, aggressive 4 (what
     // draws a vindicator's axe, a skeleton's drawn bow, a piglin's raised
     // weapon).
@@ -1409,6 +1414,12 @@ impl Game<'_> {
                 .each_ref()
                 .map(|s| s.as_ref().map(|s| s.item.clone()));
             m.extra.crouching = g.sneaking;
+            // LivingEntity.DATA_EFFECT_PARTICLES: the swirls of its visible effects.
+            let visible = || g.effects.list.iter().filter(|e| e.visible);
+            m.extra.effect_particles = visible()
+                .filter_map(|e| super::client_ambient::effect_particle(e.id, e.ambient))
+                .collect();
+            m.extra.effect_ambient = visible().all(|e| e.ambient);
             // Lying in its bed (LivingEntity.getBedOrientation).
             m.extra.ints[1] = g.bed.map_or(0, |b| self.bed_facing(b));
             // LivingEntity.updateSwingTime: the arm swing lan_swings started.
diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs
index c6702dfb6..3c7d6fb49 100644
--- a/crates/horizon-client/src/game/remote_mob_data.rs
+++ b/crates/horizon-client/src/game/remote_mob_data.rs
@@ -5,7 +5,8 @@
 use super::Game;
 use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES};
 use horizon_client::mobs::{Mob, Species, Who, bat, tame};
-use horizon_protocol::entity_data::Value;
+use horizon_client::particles::{ParticleOptions, ParticleType};
+use horizon_protocol::entity_data::{Particle, ParticleData, Value};
 use horizon_protocol::registry::Builtin;
 
 /// The values `apply` takes from one SetEntityData packet, by vanilla's entry
@@ -34,6 +35,10 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
             // LivingEntity.DATA_HEALTH_ID: the boss bars and the death
             // animation follow it.
             (9, Value::Float(health)) => m.health = *health,
+            // LivingEntity.DATA_EFFECT_PARTICLES and DATA_EFFECT_AMBIENCE_ID:
+            // the swirls of its effects (`tickEffects` draws them).
+            (10, Value::Particles(list)) => m.extra.effect_particles = swirls(list, builtin),
+            (11, Value::Bool(ambient)) => m.extra.effect_ambient = *ambient,
             // Mob.DATA_MOB_FLAGS_ID: no AI 1, left-handed 2, aggressive 4.
             // Mob.isAggressive draws the illagers' and skeletons' attack
             // poses and the vindicator's axe.
@@ -100,6 +105,30 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
     }
 }
 
+/// The options of a synched particle list: an entity effect carries its ARGB
+/// colour, the omens none.
+fn swirls(list: &[Particle], builtin: &Builtin) -> Vec<ParticleOptions> {
+    let channel = |argb: i32, shift: u32| ((argb >> shift) & 255) as f32 / 255.0;
+    list.iter()
+        .filter_map(|p| {
+            let name = builtin.get("minecraft:particle_type")?.name(p.id)?;
+            let ty = ParticleType::from_name(name)?;
+            Some(match p.data {
+                Some(ParticleData::Color(argb)) => ParticleOptions::colored(
+                    ty,
+                    [
+                        channel(argb, 16),
+                        channel(argb, 8),
+                        channel(argb, 0),
+                        channel(argb, 24),
+                    ],
+                ),
+                _ => ParticleOptions::simple(ty),
+            })
+        })
+        .collect()
+}
+
 /// VillagerData as the network sends it: the type and the profession by
 /// their built-in registry ids, then the level.
 fn villager_data(m: &mut Mob, data: &[i32], builtin: &Builtin) {
diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs
index b1a8cbc62..c76404291 100644
--- a/crates/horizon-client/src/lan/hub.rs
+++ b/crates/horizon-client/src/lan/hub.rs
@@ -21,7 +21,7 @@ use crate::{
 use horizon_core::geometry::{Aabb, ShapeOp, Vec3, VoxelShape};
 use horizon_protocol::ids::play::clientbound as ids;
 use horizon_protocol::{
-    entity_data::{Value, serializer},
+    entity_data::{Particle, ParticleData, Value, serializer},
     packets::play::{self, Clientbound as C, Serverbound as S},
     text::{literal, translatable},
 };
@@ -1500,6 +1500,49 @@ impl Hub {
 
     // ---- entities ------------------------------------------------------
 
+    /// `LivingEntity.updateSynchronizedMobEffectParticles`: DATA_EFFECT_PARTICLES
+    /// (10) and DATA_EFFECT_AMBIENCE_ID (11) for the visible `effects`, as
+    /// (effect, ambient). The entries are left out when there is nothing to
+    /// show, which is their default.
+    pub fn effect_meta<'a>(
+        &self,
+        effects: impl IntoIterator<Item = (&'a str, bool)>,
+    ) -> Vec<(u8, i32, Value)> {
+        let mut particles = Vec::new();
+        let mut all_ambient = true;
+        for (effect, ambient) in effects {
+            let effect = effect.trim_start_matches("minecraft:");
+            // MobEffect.particleFactory: the omens have their own particles,
+            // the others an entity effect in their colour (faint if ambient).
+            let (name, data) = match effect {
+                "trial_omen" | "raid_omen" => (effect, None),
+                _ => {
+                    let Some(def) = crate::brewing::effect(effect) else {
+                        continue;
+                    };
+                    let alpha = if ambient { 38 } else { 255 };
+                    let argb = (alpha << 24) | def.color as i32;
+                    ("entity_effect", Some(ParticleData::Color(argb)))
+                }
+            };
+            let Some(id) =
+                self.registry_id("minecraft:particle_type", &format!("minecraft:{name}"))
+            else {
+                continue;
+            };
+            particles.push(Particle { id, data });
+            all_ambient &= ambient;
+        }
+        if particles.is_empty() {
+            return Vec::new();
+        }
+        let mut meta = vec![(10, serializer::PARTICLES, Value::Particles(particles))];
+        if all_ambient {
+            meta.push((11, serializer::BOOLEAN, Value::Bool(true)));
+        }
+        meta
+    }
+
     fn player_state(
         &self,
         id: i32,
@@ -1514,6 +1557,7 @@ impl Hub {
         health: f32,
         equipment: Vec<(u8, Option<horizon_protocol::item::Stack>)>,
         attributes: Vec<play::AttributeSnapshot>,
+        effects: &[EffectInstance],
     ) -> EntityState {
         let (sneaking, sprinting, gliding, sleeping) = flags;
         let shared = shared_flags(sneaking, sprinting, gliding);
@@ -1547,6 +1591,14 @@ impl Hub {
         if skin != 0 {
             meta.push((16, serializer::BYTE, Value::Byte(skin as i8)));
         }
+        meta.extend(
+            self.effect_meta(
+                effects
+                    .iter()
+                    .filter(|e| e.visible)
+                    .map(|e| (e.id, e.ambient)),
+            ),
+        );
         EntityState {
             id,
             uuid,
@@ -1559,7 +1611,11 @@ impl Hub {
             velocity: [0.0; 3],
             data: 0,
             meta,
-            defaults: Vec::new(),
+            // The effect swirls go back to none.
+            defaults: vec![
+                (10, serializer::PARTICLES, Value::Particles(Vec::new())),
+                (11, serializer::BOOLEAN, Value::Bool(false)),
+            ],
             equipment,
             attributes,
             precise: false,
@@ -1614,6 +1670,7 @@ impl Hub {
                 h.health,
                 equipment,
                 h.attributes.clone(),
+                &[],
             ));
         }
         let placed: Vec<usize> = (0..self.guests.len())
@@ -1649,6 +1706,7 @@ impl Hub {
                         .as_ref()
                         .map(|m| super::attributes::syncable(&m.attributes))
                         .unwrap_or_default(),
+                    &g.effects.list,
                 )
             })
             .collect();
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 6b1e16f5c..0bc37bcc7 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -715,6 +715,10 @@ pub struct Extra {
     pub vector: [f64; 3],
     /// Active status effects: (effect id, ticks left, amplifier).
     pub effects: Vec<(&'static str, i32, i32)>,
+    /// `LivingEntity.DATA_EFFECT_PARTICLES` and `DATA_EFFECT_AMBIENCE_ID` as a
+    /// server gave them: the swirls around it, and whether they are all faint.
+    pub effect_particles: Vec<crate::particles::ParticleOptions>,
+    pub effect_ambient: bool,
     /// An invisible illusioner's mirror images.
     pub illusions: Option<illusioner::Illusions>,
     /// A villager's claimed bed head and meeting bell.

From efd6c60a272d20f69e498a48afe3e96a759cf164 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:07:36 +0100
Subject: [PATCH 225/475] Axolotl air: refill only where it rains locally, not
 in deserts or snowy biomes

---
 crates/horizon-client/src/mobs/ai.rs    |  2 +-
 crates/horizon-client/src/mobs/world.rs | 19 +++++++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 403f63101..3499ab29d 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -458,7 +458,7 @@ fn axolotl_air_supply(m: &mut Mob, w: &MobWorld) {
         m.position.z.floor() as i32,
     );
     let top = (m.position.y + f64::from(m.height())).floor() as i32;
-    let in_rain = w.raining && (w.can_see_sky(x, y, z) || w.can_see_sky(x, top, z));
+    let in_rain = w.raining_at(x, y, z) || w.raining_at(x, top, z);
     if m.fluids.in_water || in_rain {
         m.air = super::axolotl::MAX_AIR;
     } else {
diff --git a/crates/horizon-client/src/mobs/world.rs b/crates/horizon-client/src/mobs/world.rs
index 7836a49ef..db2557e72 100644
--- a/crates/horizon-client/src/mobs/world.rs
+++ b/crates/horizon-client/src/mobs/world.rs
@@ -177,6 +177,25 @@ impl MobWorld<'_> {
         }
         self.world.light(x, y, z) >> 4 == 15
     }
+    /// Level.isRainingAt: raining, open to the sky, nothing motion blocking
+    /// above, and the biome's precipitation at the position (its temperature
+    /// lowered above the snow level) is rain, not snow or none.
+    pub fn raining_at(&self, x: i32, y: i32, z: i32) -> bool {
+        if !self.raining || !self.can_see_sky(x, y, z) || self.motion_blocking_height(x, z) > y {
+            return false;
+        }
+        let Some(chunk) = self.world.chunks.get(&(x >> 4, z >> 4)) else {
+            return false;
+        };
+        let biome = self.biomes.get(chunk.biome(x, y, z));
+        let snow_level = self.sea_level + 17;
+        let temperature = if y > snow_level {
+            biome.temperature - (y - snow_level) as f32 * 0.05 / 40.0
+        } else {
+            biome.temperature
+        };
+        biome.precipitation && temperature >= 0.15
+    }
     /// Level.getLightLevelDependentMagicValue: the dimension's brightness curve
     /// at the raw (sky darkened) light level.
     pub fn brightness(&self, x: i32, y: i32, z: i32) -> f32 {

From 18f8a6868bb18d843562663835a5298bfdcae1a9 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:09:23 +0100
Subject: [PATCH 226/475] Burst a breaking potion into item crumbs and coloured
 spell particles

A thrown potion or experience bottle that breaks sends level events 2002 or
2007 with its colour and the splash sound (1053, 1054). Horizon spawned only
eight terrain crumbs, on the server's own side, so a server player saw
nothing.
---
 crates/horizon-client/src/game.rs             | 17 ++++-
 .../src/game/level_particles.rs               | 63 +++++++++++++++++++
 crates/horizon-client/src/game/potions.rs     | 61 +++++-------------
 3 files changed, 93 insertions(+), 48 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 8b82f7bed..54e017943 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2926,6 +2926,17 @@ impl Game<'_> {
                     pos,
                     data,
                 } => self.smash_dust(pos, data),
+                // LevelEventHandler 2002 and 2007: a potion's splash.
+                LevelEvent::LevelEvent {
+                    id: 2002,
+                    pos,
+                    data,
+                } => self.potion_splash_particles(pos, data, false),
+                LevelEvent::LevelEvent {
+                    id: 2007,
+                    pos,
+                    data,
+                } => self.potion_splash_particles(pos, data, true),
                 LevelEvent::LevelEvent {
                     id: id @ 3002..=3005,
                     pos,
@@ -2958,6 +2969,8 @@ impl Game<'_> {
                         1044 => Some(("minecraft:block.smithing_table.use", 1.0)),
                         // LevelEvent.SOUND_PAGE_TURN (a lectern's page).
                         1043 => Some(("minecraft:item.book.page_turn", 1.0)),
+                        // LevelEvent.SOUND_SPLASH_POTION and its instant twin.
+                        1053 | 1054 => Some(("minecraft:entity.splash_potion.break", 1.0)),
                         _ => None,
                     };
                     if let Some((name, volume)) = sound {
@@ -2967,12 +2980,12 @@ impl Game<'_> {
                                     - self.world.random.next_float())
                                     * 0.8
                             }
-                            1029 | 1030 | 1042 | 1043 | 1044 => {
+                            1029 | 1030 | 1042 | 1043 | 1044 | 1053 | 1054 => {
                                 self.world.random.next_float() * 0.1 + 0.9
                             }
                             _ => 1.0,
                         };
-                        if matches!(id, 1029 | 1030) {
+                        if matches!(id, 1029 | 1030 | 1053 | 1054) {
                             // Clients play the anvil sound from its level event;
                             // capturing it also sends a duplicate sound packet.
                             self.audio.play_unshared(name, c, volume, pitch);
diff --git a/crates/horizon-client/src/game/level_particles.rs b/crates/horizon-client/src/game/level_particles.rs
index f12aedc5b..9fa53eb25 100644
--- a/crates/horizon-client/src/game/level_particles.rs
+++ b/crates/horizon-client/src/game/level_particles.rs
@@ -3,6 +3,7 @@
 //! consumable's teleport (2017), electric sparks (3002), waxing (3003), wax
 //! off (3004) and scraping (3005).
 use super::Game;
+use horizon_client::items::ItemStack;
 use horizon_client::particles::{self, ParticleOptions, ParticleType};
 use horizon_core::{position::BlockPos, random::RandomSource};
 use horizon_world::level::LevelEvent;
@@ -134,6 +135,68 @@ impl Game<'_> {
         // Each guest plays it from the global packet.
         self.audio.play_unshared(sound, at, volume, 1.0);
     }
+    /// `LevelEventHandler.potionSplashParticles` (2002 with `Effect`, 2007
+    /// with `InstantEffect`): eight splash potion crumbs, and a hundred
+    /// spell particles in the potion's colour `data`, flung out in a disc.
+    pub(super) fn potion_splash_particles(&mut self, pos: BlockPos, data: i32, instant: bool) {
+        let ty = if instant {
+            ParticleType::InstantEffect
+        } else {
+            ParticleType::Effect
+        };
+        // Vec3.atBottomCenterOf.
+        let at = [
+            f64::from(pos.x) + 0.5,
+            f64::from(pos.y),
+            f64::from(pos.z) + 0.5,
+        ];
+        let crumb = self.item_particle(&ItemStack::new("minecraft:splash_potion", 1));
+        let r = self.particles.level_random();
+        let crumbs: Vec<[f64; 3]> = (0..8)
+            .map(|_| {
+                [
+                    r.next_gaussian() * 0.15,
+                    r.next_double() * 0.2,
+                    r.next_gaussian() * 0.15,
+                ]
+            })
+            .collect();
+        for v in crumbs {
+            self.particles.add(&crumb, at, v);
+        }
+        let channel = |shift: i32| ((data >> shift) & 0xFF) as f32 / 255.0;
+        let color = [channel(16), channel(8), channel(0)];
+        for _ in 0..100 {
+            let r = self.particles.level_random();
+            let dist = r.next_double() * 4.0;
+            let angle = r.next_double() * std::f64::consts::PI * 2.0;
+            let velocity = [
+                angle.cos() * dist,
+                0.01 + r.next_double() * 0.5,
+                angle.sin() * dist,
+            ];
+            let brightness = 0.75 + r.next_float() * 0.25;
+            let options = ParticleOptions {
+                color: [
+                    color[0] * brightness,
+                    color[1] * brightness,
+                    color[2] * brightness,
+                    1.0,
+                ],
+                scale: dist as f32,
+                ..ParticleOptions::simple(ty)
+            };
+            self.particles.add(
+                &options,
+                [
+                    at[0] + velocity[0] * 0.1,
+                    at[1] + 0.3,
+                    at[2] + velocity[2] * 0.1,
+                ],
+                velocity,
+            );
+        }
+    }
     /// Queue and play level event `id` at `pos` (`Level.levelEvent`).
     pub(super) fn level_event_at(&mut self, id: i32, pos: [i32; 3], data: i32) {
         self.level_events.push(LevelEvent::LevelEvent {
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index 13eae7d3e..0061fd5d3 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -674,62 +674,31 @@ impl Game<'_> {
     }
     /// `ThrownSplashPotion.onHitAsPotion` (lingering clouds apply as a weaker splash).
     fn splash(&mut self, stack: &ItemStack, at: Vec3) {
+        let block = [at.x, at.y, at.z].map(|v| v.floor() as i32);
         if &*stack.item == "minecraft:experience_bottle" {
             // ThrownExperienceBottle.onHit: the water-coloured splash (level
-            // event 2002) and 3 to 11 experience.
-            let pitch = self.world.random.next_float() * 0.1 + 0.9;
-            self.audio.play(
-                "minecraft:entity.splash_potion.break",
-                Some([at.x, at.y, at.z]),
-                1.0,
-                pitch,
-            );
-            for _ in 0..8 {
-                let v = [
-                    f64::from(self.world.random.next_float() - 0.5) * 0.3,
-                    0.2,
-                    f64::from(self.world.random.next_float() - 0.5) * 0.3,
-                ];
-                let p = horizon_client::particles::Particle::terrain(
-                    &mut self.world.random,
-                    [at.x, at.y, at.z],
-                    v,
-                    "item/splash_potion".into(),
-                    0x38_5DC6,
-                );
-                self.particles.push(p);
-            }
+            // event 2002, its sound 1053) and 3 to 11 experience.
+            self.level_event_at(2002, block, 0xFF38_5DC6u32 as i32);
+            self.level_event_at(1053, block, 0);
             let r = &mut self.world.random;
             let value = 3 + r.next_int_bound(5).unwrap_or(0) + r.next_int_bound(5).unwrap_or(0);
             self.spawn_orbs([at.x, at.y, at.z], value as u32);
             return;
         }
         let lingering = &*stack.item == "minecraft:lingering_potion";
-        let event = if lingering {
-            "minecraft:entity.lingering_potion.break"
-        } else {
-            "minecraft:entity.splash_potion.break"
-        };
-        let pitch = self.world.random.next_float() * 0.1 + 0.9;
-        self.audio.play(event, Some([at.x, at.y, at.z]), 1.0, pitch);
+        // AbstractThrownPotion.onHit: level event 2007 and sound 1054 for a
+        // potion with instant effects, 2002 and 1053 otherwise.
+        let potion = stack.potion().and_then(brewing::potion);
+        let instant = potion.is_some_and(|d| {
+            d.effects
+                .iter()
+                .any(|(id, ..)| brewing::effect(id).is_some_and(|e| e.instant))
+        });
         let color = brewing::potion_color(stack.potion());
-        for _ in 0..8 {
-            let v = [
-                f64::from(self.world.random.next_float() - 0.5) * 0.3,
-                0.2,
-                f64::from(self.world.random.next_float() - 0.5) * 0.3,
-            ];
-            let p = horizon_client::particles::Particle::terrain(
-                &mut self.world.random,
-                [at.x, at.y, at.z],
-                v,
-                "item/splash_potion".into(),
-                color,
-            );
-            self.particles.push(p);
-        }
+        self.level_event_at(if instant { 2007 } else { 2002 }, block, color as i32);
+        self.level_event_at(if instant { 1054 } else { 1053 }, block, 0);
         let scale = if lingering { 0.25 } else { 1.0 };
-        let Some(def) = stack.potion().and_then(brewing::potion) else {
+        let Some(def) = potion else {
             return;
         };
         // Every player in range (`ThrownSplashPotion.applySplash` over

From 1c6c6c0b97ae6144bf476d76962d744c6d29a815 Mon Sep 17 00:00:00 2001
From: masa-masa-0314 <348336850+masa-masa-0314@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:45:23 +0800
Subject: [PATCH 227/475] Items: sample the glint from its own repeating
 texture

Vanilla's GlintSampler repeats enchanted_glint_item per pixel, and the
GLINT transform's scale 8 spans about 8 repeats across an item. Folding
the UV per vertex into the shared atlas could only interpolate between
the four corners, so the pattern rendered as one wide diagonal band
instead of the texture's fine weave. The glint now binds as its own
128x128 texture with a repeat, linear, mip-free sampler (the texture's
mcmeta: clamp false, blur true) in the HUD and entity pipelines, and
`Glint` passes the unwrapped `GLINT_TEXTURING` UV through.

Co-Authored-By: ZCode <agent@zcode.dev>
---
 crates/horizon-client/src/entity.wgsl        |  5 +-
 crates/horizon-client/src/game.rs            |  7 ++
 crates/horizon-client/src/game/item_draw.rs  |  3 +-
 crates/horizon-client/src/gfx.rs             | 71 +++++++++++++++++++-
 crates/horizon-client/src/hud.rs             | 43 +++++++++++-
 crates/horizon-client/src/hud.wgsl           |  5 +-
 crates/horizon-client/src/item_render.rs     | 21 +++---
 crates/horizon-client/src/item_render/gui.rs | 23 +++++--
 8 files changed, 154 insertions(+), 24 deletions(-)

diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl
index 2e7abda21..993f86947 100644
--- a/crates/horizon-client/src/entity.wgsl
+++ b/crates/horizon-client/src/entity.wgsl
@@ -27,6 +27,9 @@ struct Globals {
 @group(0) @binding(2) var atlas_sampler: sampler;
 @group(0) @binding(3) var lightmap: texture_2d<f32>;
 @group(0) @binding(4) var lightmap_sampler: sampler;
+// enchanted_glint_item on its own repeating texture (vanilla's GlintSampler).
+@group(0) @binding(5) var glint_tex: texture_2d<f32>;
+@group(0) @binding(6) var glint_sampler: sampler;
 struct Out {
     @builtin(position) clip: vec4<f32>,
     @location(0) uv: vec2<f32>,
@@ -214,7 +217,7 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
         // Enchantment glint: item.fsh's GLINT path, sampled from
         // enchanted_glint_item at the `GLINT_TEXTURING` UV.
         let alpha = globals.fog_ends.w;
-        let glint = alpha * textureSample(atlas, atlas_sampler, in.glint_uv);
+        let glint = alpha * textureSample(glint_tex, glint_sampler, in.glint_uv);
         color = vec4(color.rgb + glint.rgb * glint.rgb, max(color.a, alpha));
     }
     let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 91045ada5..f4663c844 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -13385,6 +13385,7 @@ fn build_renderer(
         &assets.sprite_mips,
         &assets.animations,
         (&atlas.pixels, atlas.width, atlas.height),
+        (&atlas.glint.0, atlas.glint.1, atlas.glint.2),
         (&pack.forcefield.2, pack.forcefield.0),
         &gui.panorama,
         prepared,
@@ -13411,6 +13412,7 @@ fn loading_renderer(
 ) -> Result<Renderer> {
     static FORCEFIELD: [u8; 4] = [0; 4];
     static EMPTY_HUD: [u8; 4] = [0, 0, 0, 255];
+    static EMPTY_GLINT: [u8; 4] = [0; 4];
     let empty_panorama = horizon_client::gfx::panorama::Faces {
         size: 1,
         pixels: [0u8; 4].repeat(6),
@@ -13421,6 +13423,10 @@ fn loading_renderer(
         Some(atlas) => (atlas.pixels.as_slice(), atlas.width, atlas.height),
         None => (EMPTY_HUD.as_slice(), 1, 1),
     };
+    let (glint_pixels, glint_width, glint_height) = match atlas {
+        Some(atlas) => (atlas.glint.0.as_slice(), atlas.glint.1, atlas.glint.2),
+        None => (EMPTY_GLINT.as_slice(), 1, 1),
+    };
     // A glyph rasterized into an earlier texture is not in these pixels; the
     // new texture gets it again when the character is drawn (see
     // `build_renderer`).
@@ -13437,6 +13443,7 @@ fn loading_renderer(
         &[],
         &[],
         (pixels, width, height),
+        (glint_pixels, glint_width, glint_height),
         (&FORCEFIELD[..], 1),
         panorama,
         None,
diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs
index 580701ccd..2dac91f77 100644
--- a/crates/horizon-client/src/game/item_draw.rs
+++ b/crates/horizon-client/src/game/item_draw.rs
@@ -307,8 +307,7 @@ impl Game<'_> {
             .sprites
             .get("misc/enchanted_glint_item")
             .copied()
-            .map(|rect| item_render::Glint {
-                rect,
+            .map(|_| item_render::Glint {
                 speed: self.settings.file.double("glintSpeed") as f32,
                 alpha: self.settings.file.double("glintStrength") as f32,
                 millis: self.started.elapsed().as_secs_f32() * 1000.0,
diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index bd2b932f0..339f7e7c2 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -1023,6 +1023,7 @@ impl Renderer {
         sprite_mips: &[crate::mipmap::Settings],
         animations: &[SpriteAnimation],
         hud_atlas: (&[u8], u32, u32),
+        glint: (&[u8], u32, u32),
         forcefield: (&[u8], u32),
         panorama_faces: &panorama::Faces,
         prepared: Option<PreparedTextures>,
@@ -1576,7 +1577,45 @@ impl Renderer {
             atlas_pixels,
         );
         let atlas_view = atlas.create_view(&Default::default());
-        let mut hud = HudRenderer::new(&device, config.format.remove_srgb_suffix(), &atlas_view)?;
+        // vanilla's `GlintSampler`: enchanted_glint_item as its own texture,
+        // repeated per pixel (`clamp: false`), linear without mipmaps
+        // (`blur: true`).
+        let (glint_pixels, glint_width, glint_height) = glint;
+        let glint_texture = device.create_texture_with_data(
+            &queue,
+            &wgpu::TextureDescriptor {
+                label: Some("Enchanted glint"),
+                size: wgpu::Extent3d {
+                    width: glint_width,
+                    height: glint_height,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: wgpu::TextureFormat::Rgba8Unorm,
+                usage: wgpu::TextureUsages::TEXTURE_BINDING,
+                view_formats: &[],
+            },
+            wgpu::util::TextureDataOrder::LayerMajor,
+            glint_pixels,
+        );
+        let glint_view = glint_texture.create_view(&Default::default());
+        let glint_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            label: Some("Glint"),
+            address_mode_u: wgpu::AddressMode::Repeat,
+            address_mode_v: wgpu::AddressMode::Repeat,
+            mag_filter: wgpu::FilterMode::Linear,
+            min_filter: wgpu::FilterMode::Linear,
+            ..Default::default()
+        });
+        let mut hud = HudRenderer::new(
+            &device,
+            config.format.remove_srgb_suffix(),
+            &atlas_view,
+            &glint_view,
+            &glint_sampler,
+        )?;
         hud.atlas_texture = Some(atlas.clone());
         let entity_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some("Horizon entities"),
@@ -1622,6 +1661,20 @@ impl Renderer {
                     vf,
                     wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                 ),
+                entry(
+                    5,
+                    vf,
+                    wgpu::BindingType::Texture {
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                ),
+                entry(
+                    6,
+                    vf,
+                    wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                ),
             ],
         });
         let weather = weather::Weather::new(
@@ -1658,6 +1711,14 @@ impl Renderer {
                     binding: 4,
                     resource: wgpu::BindingResource::Sampler(&lightmap_sampler),
                 },
+                wgpu::BindGroupEntry {
+                    binding: 5,
+                    resource: wgpu::BindingResource::TextureView(&glint_view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 6,
+                    resource: wgpu::BindingResource::Sampler(&glint_sampler),
+                },
             ],
         });
         let hand_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
@@ -1684,6 +1745,14 @@ impl Renderer {
                     binding: 4,
                     resource: wgpu::BindingResource::Sampler(&lightmap_sampler),
                 },
+                wgpu::BindGroupEntry {
+                    binding: 5,
+                    resource: wgpu::BindingResource::TextureView(&glint_view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 6,
+                    resource: wgpu::BindingResource::Sampler(&glint_sampler),
+                },
             ],
         });
         let entity_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs
index 41eae1ec7..7f0d31ab0 100644
--- a/crates/horizon-client/src/hud.rs
+++ b/crates/horizon-client/src/hud.rs
@@ -67,6 +67,9 @@ pub struct HudAtlas {
     pub fire_animations: Vec<(Rect, crate::sprites::SpriteAnimation)>,
     /// The default font (bitmap sheets in this atlas, unifont rasterized on demand).
     pub font: crate::font::Font,
+    /// `misc/enchanted_glint_item` as its own image: vanilla's `GlintSampler`
+    /// repeats it per pixel, which one sprite inside this atlas cannot.
+    pub glint: (Vec<u8>, u32, u32),
     white: Rect,
 }
 /// Atlas rows reserved for glyphs rasterized at run time.
@@ -526,6 +529,7 @@ impl HudAtlas {
             }
         }
         let white = sprites["horizon/white"];
+        let glint = Self::glint_texture(root, defaults);
         let font = crate::font::Font::load(
             root,
             &sprites,
@@ -542,10 +546,20 @@ impl HudAtlas {
             translucent,
             flags,
             fire_animations,
+            glint,
             font,
             white,
         })
     }
+    /// `misc/enchanted_glint_item.png` on its own, or a transparent texel if
+    /// the resource pack lacks it.
+    fn glint_texture(root: &Path, defaults: &Path) -> (Vec<u8>, u32, u32) {
+        let mut path = root.join("assets/minecraft/textures/misc/enchanted_glint_item.png");
+        if !path.exists() && defaults != root {
+            path = defaults.join("assets/minecraft/textures/misc/enchanted_glint_item.png");
+        }
+        decode(&path).map_or((vec![0; 4], 1, 1), |(w, h, pixels)| (pixels, w, h))
+    }
 }
 #[repr(C)]
 #[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
@@ -554,7 +568,8 @@ pub struct HudVertex {
     pub uv: [f32; 2],
     pub color: u32,
     pub depth: f32,
-    /// The glint sprite UV (`GLINT_TEXTURING`), unused unless `uv.x >= 2`.
+    /// The `GLINT_TEXTURING` UV into the repeating glint texture, unused
+    /// unless `uv.x >= 2`.
     pub glint_uv: [f32; 2],
 }
 /// The GUI Scale option (0 = auto).
@@ -1080,6 +1095,8 @@ impl HudRenderer {
         device: &wgpu::Device,
         format: wgpu::TextureFormat,
         view: &wgpu::TextureView,
+        glint_view: &wgpu::TextureView,
+        glint_sampler: &wgpu::Sampler,
     ) -> Result<Self> {
         let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some("Horizon HUD"),
@@ -1124,6 +1141,22 @@ impl HudRenderer {
                     ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                     count: None,
                 },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 3,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Texture {
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 4,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                    count: None,
+                },
             ],
         });
         let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
@@ -1142,6 +1175,14 @@ impl HudRenderer {
                     binding: 2,
                     resource: wgpu::BindingResource::Sampler(&sampler),
                 },
+                wgpu::BindGroupEntry {
+                    binding: 3,
+                    resource: wgpu::BindingResource::TextureView(glint_view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 4,
+                    resource: wgpu::BindingResource::Sampler(glint_sampler),
+                },
             ],
         });
         let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
diff --git a/crates/horizon-client/src/hud.wgsl b/crates/horizon-client/src/hud.wgsl
index 1f6d5797e..435f7f062 100644
--- a/crates/horizon-client/src/hud.wgsl
+++ b/crates/horizon-client/src/hud.wgsl
@@ -7,6 +7,9 @@ struct Hud {
 @group(0) @binding(0) var<uniform> hud: Hud;
 @group(0) @binding(1) var atlas: texture_2d<f32>;
 @group(0) @binding(2) var atlas_sampler: sampler;
+// enchanted_glint_item on its own repeating texture (vanilla's GlintSampler).
+@group(0) @binding(3) var glint_tex: texture_2d<f32>;
+@group(0) @binding(4) var glint_sampler: sampler;
 struct Out {
     @builtin(position) clip: vec4<f32>,
     @location(0) uv: vec2<f32>,
@@ -31,7 +34,7 @@ struct Out {
     if in.uv.x >= 2.0 {
         let mask = textureSample(atlas, atlas_sampler, in.uv - vec2(2.0, 0.0)).a;
         if mask < 0.1 { discard; }
-        let glint = hud.size.w * textureSample(atlas, atlas_sampler, in.glint_uv);
+        let glint = hud.size.w * textureSample(glint_tex, glint_sampler, in.glint_uv);
         return vec4(glint.rgb * glint.rgb, mask);
     }
     let c = textureSample(atlas, atlas_sampler, in.uv) * in.color;
diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs
index 0a72b2ecc..76b13dbca 100644
--- a/crates/horizon-client/src/item_render.rs
+++ b/crates/horizon-client/src/item_render.rs
@@ -50,10 +50,9 @@ pub struct ItemQuad {
     /// `MaterialInfo.lightEmission` (block light floor).
     pub light_emission: u8,
 }
-/// `TextureTransform.setupGlintTexturing`'s inputs and the glint sprite.
+/// `TextureTransform.setupGlintTexturing`'s inputs.
 #[derive(Clone, Copy, Debug)]
 pub struct Glint {
-    pub rect: crate::hud::Rect,
     /// `options.glintSpeed` (vanilla default 0.5).
     pub speed: f32,
     /// `options.glintStrength` / shader `GlintAlpha` (vanilla default 0.75).
@@ -65,21 +64,19 @@ pub struct Glint {
     pub scale: f32,
 }
 impl Glint {
-    /// `TextureTransform.setupGlintTexturing(scale)`: translation(-o0, o1) *
-    /// rotateZ(PI/18) * scale, wrapped and mapped into the glint sprite.
-    pub fn atlas_uv(&self, model: [f32; 2]) -> [f32; 2] {
+    /// `TextureTransform.setupGlintTexturing(scale)` applied to the model UV:
+    /// translation(-o0, o1) * rotateZ(PI/18) * scale. The result repeats:
+    /// the shader samples the dedicated glint texture with vanilla's
+    /// repeating `GlintSampler`, so the UVs stay unwrapped.
+    pub fn uv(&self, model: [f32; 2]) -> [f32; 2] {
         let millis = (f64::from(self.millis) * f64::from(self.speed) * 8.0) as i64;
         let offset0 = (millis % 110000) as f32 / 110000.0;
         let offset1 = (millis % 30000) as f32 / 30000.0;
         let angle = std::f32::consts::PI / 18.0;
         let (sin, cos) = angle.sin_cos();
-        let x = model[0] * self.scale * cos - model[1] * self.scale * sin - offset0;
-        let y = model[0] * self.scale * sin + model[1] * self.scale * cos + offset1;
-        let u = (x - x.floor()).clamp(0.5 / self.rect.w as f32, 1.0 - 0.5 / self.rect.w as f32);
-        let v = (y - y.floor()).clamp(0.5 / self.rect.h as f32, 1.0 - 0.5 / self.rect.h as f32);
         [
-            self.rect.u0 + u * (self.rect.u1 - self.rect.u0),
-            self.rect.v0 + v * (self.rect.v1 - self.rect.v0),
+            model[0] * self.scale * cos - model[1] * self.scale * sin - offset0,
+            model[0] * self.scale * sin + model[1] * self.scale * cos + offset1,
         ]
     }
 }
@@ -739,7 +736,7 @@ impl ItemSink for WorldSink<'_> {
         };
         let overlay = if glint.is_some() { 7 } else { 0 };
         for (i, (p, uv)) in q.pos.iter().zip(q.uv).enumerate() {
-            let glint_uv = glint.map_or([0.0, 0.0], |glint| glint.atlas_uv(q.foil_uv[i]));
+            let glint_uv = glint.map_or([0.0, 0.0], |glint| glint.uv(q.foil_uv[i]));
             self.out.push(Vertex {
                 normal: [0; 4],
                 pos: p.to_array(),
diff --git a/crates/horizon-client/src/item_render/gui.rs b/crates/horizon-client/src/item_render/gui.rs
index 87dfb354e..7c65ea86d 100644
--- a/crates/horizon-client/src/item_render/gui.rs
+++ b/crates/horizon-client/src/item_render/gui.rs
@@ -111,7 +111,7 @@ fn emit(batch: &mut HudBatch, fan: &[Point], color: impl Fn(Vec2) -> u32, glint:
             batch.quad_glint(
                 corners.map(|v| v.p.to_array()),
                 corners.map(|v| [v.uv[0] + 2.0, v.uv[1]]),
-                corners.map(|v| glint.atlas_uv(v.glint_uv)),
+                corners.map(|v| glint.uv(v.glint_uv)),
                 u32::MAX,
             );
             batch.blend_since(start, crate::hud::Blend::Additive);
@@ -157,7 +157,18 @@ pub fn draw(
         return;
     }
     let start = batch.vertices.len();
-    draw_now(state, renderer, sprites, host, batch, x, y, time);
+    draw_now(
+        state,
+        renderer,
+        sprites,
+        host,
+        batch,
+        x,
+        y,
+        time,
+        glint_speed,
+        glint_alpha,
+    );
     if let Some(key) = key
         && let Ok(mut drawn) = renderer.gui_drawn.lock()
     {
@@ -231,6 +242,8 @@ fn draw_now(
     x: f32,
     y: f32,
     time: f32,
+    glint_speed: f32,
+    glint_alpha: f32,
 ) {
     let pose = Mat4::from_translation(Vec3::new(x + 8.0, y + 8.0, 0.0))
         * Mat4::from_scale(Vec3::new(16.0, -16.0, 16.0));
@@ -252,10 +265,8 @@ fn draw_now(
         [x, y, x + 16.0, y + 16.0]
     };
     let glint = sprites
-        .get("misc/enchanted_glint_item")
-        .copied()
-        .map(|rect| Glint {
-            rect,
+        .contains_key("misc/enchanted_glint_item")
+        .then_some(Glint {
             speed: glint_speed,
             alpha: glint_alpha,
             millis: time * 1000.0,

From 303281ed09e4236062459aca955c3416a1224dca Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:12:28 +0100
Subject: [PATCH 228/475] Puff a poof where a dead mob's body goes

A mob removes its body twenty ticks after dying and tells everyone with
entity event 60, which draws twenty poofs about it. Horizon removed dead
mobs silently.
---
 crates/horizon-client/src/game/creatures.rs | 29 +++++++++++++++++++++
 crates/horizon-client/src/game/lan.rs       | 10 +++++++
 crates/horizon-client/src/game/remote.rs    |  7 +++++
 3 files changed, 46 insertions(+)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 145717cb3..9f44a4e0b 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -525,6 +525,8 @@ impl Game<'_> {
             _ => Vec::new(),
         };
         let mut guest_events = Vec::new();
+        // The mobs whose bodies go this tick: (id, feet, width, height).
+        let mut gone = Vec::new();
         let level_random;
         {
             // The level random, lent to the mobs (brain behaviours draw from
@@ -597,6 +599,11 @@ impl Game<'_> {
                 let from = events.len();
                 let kept = m.tick(&w, &mut scratch, &mut events);
                 horizon_client::mobs::take_mob_pushes(&mut events, from, &mut pushes);
+                // LivingEntity.tickDeath: after twenty ticks the body is removed.
+                if !kept && !m.removed && !m.alive() && m.death_time >= 20 {
+                    let (width, height) = (f64::from(m.width()), f64::from(m.height()));
+                    gone.push((m.id, m.position, width, height));
+                }
                 if let Some(conn) = seen_guest {
                     // ShulkerBullet.finalTarget is the guest's entity: the
                     // bullet homes on it while the projectiles tick, where
@@ -655,6 +662,12 @@ impl Game<'_> {
         }
         self.mobs.append(&mut mobs);
         self.died = died;
+        // ... and entity event 60 goes out as it is: the poof.
+        for (id, at, width, height) in gone {
+            let at = [at.x, at.y, at.z];
+            self.lan_entity_event(id as i32, 60, at);
+            self.death_poof(at, width, height);
+        }
         self.sync_riders();
         self.tick_skeleton_traps();
         self.tick_apparition();
@@ -681,6 +694,22 @@ impl Game<'_> {
         self.handle_mob_events(queued)?;
         Ok(())
     }
+    /// `LivingEntity.makePoofParticles` (entity event 60) about a mob's box.
+    pub(super) fn death_poof(&mut self, at: [f64; 3], width: f64, height: f64) {
+        let options = horizon_client::particles::ParticleOptions::simple(
+            horizon_client::particles::ParticleType::Poof,
+        );
+        for _ in 0..20 {
+            let r = self.particles.level_random();
+            let xa = r.next_gaussian() * 0.02;
+            let ya = r.next_gaussian() * 0.02;
+            let za = r.next_gaussian() * 0.02;
+            let x = at[0] + width * (2.0 * r.next_double() - 1.0) - xa * 10.0;
+            let y = at[1] + height * r.next_double() - ya * 10.0;
+            let z = at[2] + width * (2.0 * r.next_double() - 1.0) - za * 10.0;
+            self.particles.add(&options, [x, y, z], [xa, ya, za]);
+        }
+    }
     /// LivingEntity.die / dropAllDeathLoot.
     fn mob_died(&mut self, m: &Mob) {
         let killer = self.last_hurt_by_player.remove(&m.id);
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..3478ed6ef 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -952,6 +952,16 @@ impl Game<'_> {
                 host.hub.block_event(pos, b0, b1, state);
             }
             let entities = states.as_slice();
+            // An entity that left the level since the last tick (a snowball
+            // that hit) is dropped by the tracker below: its event goes out
+            // first, as `Level.broadcastEntityEvent` precedes the discard.
+            let (gone, later): (Vec<_>, Vec<_>) = std::mem::take(&mut self.lan_entity_events)
+                .into_iter()
+                .partition(|(id, ..)| !entities.iter().any(|e| e.id == *id));
+            self.lan_entity_events = later;
+            for (id, event, at) in gone {
+                host.hub.entity_event(id, event, at);
+            }
             let spawn = self.spawn.map_or([0.5, 80.0, 0.5], |s| [s.x, s.y, s.z]);
             let events = {
                 let clock_rate = self.network_clock_rate();
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3cfbd15e3..64320bd37 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -2130,6 +2130,13 @@ impl Game<'_> {
                 {
                     m.health = 0.0;
                 }
+                // LivingEntity.handleEntityEvent 60: the poof as the dead body goes.
+                if p.event == 60
+                    && let Some(m) = self.mobs.iter().find(|m| m.id == p.id as u32)
+                {
+                    let (at, w, h) = (m.position, f64::from(m.width()), f64::from(m.height()));
+                    self.death_poof([at.x, at.y, at.z], w, h);
+                }
                 if p.event == super::totem::TOTEM_EVENT {
                     self.remote_totem(p.id);
                 }

From d78238f7651843e1f056a0ecdcfdf4a09adcf8fd Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:14:32 +0100
Subject: [PATCH 229/475] Show the enchanted hit when a melee weapon's
 enchantments add damage

Player.attack shows magic crit particles whenever the enchantments added
damage. Horizon showed only the critical hit, for the window's player and
for a guest's attack.
---
 crates/horizon-client/src/game.rs           | 23 ++++++++++++++-----
 crates/horizon-client/src/game/lan.rs       | 25 ++++++++++++---------
 crates/horizon-client/src/game/lan_pvp.rs   | 17 +++++++++-----
 crates/horizon-client/src/game/levels.rs    |  2 +-
 crates/horizon-client/src/lan/containers.rs |  9 ++++----
 5 files changed, 50 insertions(+), 26 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 30e832eb0..e9add4a82 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -1658,7 +1658,7 @@ struct Game<'a> {
     lan_block_events: Vec<([i32; 3], i32, i32, u32)>,
     lan_entity_events: Vec<(i32, i8, [f64; 3])>,
     /// Successful crits (attacking guest, hit entity), queued while the hub is taken.
-    lan_critical_hits: Vec<(Option<u32>, i32)>,
+    lan_critical_hits: Vec<(Option<u32>, i32, bool)>,
     /// Global level events for every guest (`ServerLevel.globalLevelEvent`).
     lan_global_events: Vec<(i32, [i32; 3], i32)>,
     /// `ContainerOpenersCounter`: how many players (the host and the guests)
@@ -7602,7 +7602,7 @@ impl Game<'_> {
     /// strength and whether it is a critical hit): the weapon and effects
     /// scaled by the attack strength, a mace's smash, the critical hit, then
     /// enchantments.
-    pub(super) fn melee_damage(&mut self, target_kind: &str) -> (f32, f32, bool) {
+    pub(super) fn melee_damage(&mut self, target_kind: &str) -> (f32, f32, bool, bool) {
         let hand_damage = 1.0 + self.attack_item_info().map_or(0.0, |i| i.attack_damage);
         // Riptide's spin replaces the attack damage attribute.
         let spin = self.player.as_ref().map_or(0.0, |p| p.auto_spin_attack_dmg);
@@ -7630,8 +7630,9 @@ impl Game<'_> {
             amount *= 1.5;
         }
         // Enchantment damage (sharpness, smite, bane) scaled by the attack strength.
-        amount += self.enchant_damage_bonus(target_kind) * scale;
-        (amount, scale, crit)
+        let magic_boost = self.enchant_damage_bonus(target_kind) * scale;
+        amount += magic_boost;
+        (amount, scale, crit, magic_boost > 0.0)
     }
     /// `Player.getAttackStrengthScale(0.5)`.
     fn attack_strength_scale(&self) -> f32 {
@@ -7818,7 +7819,7 @@ impl Game<'_> {
     pub(super) fn attack_mob(&mut self, index: usize) {
         let target_kind = self.mobs[index].kind.id.clone();
         let target_kind = format!("minecraft:{}", target_kind.trim_start_matches("minecraft:"));
-        let (amount, scale, crit) = self.melee_damage(&target_kind);
+        let (amount, scale, crit, magic) = self.melee_damage(&target_kind);
         let sweep = self.sweep_attack_position(scale, crit);
         let (knockback, knockback_attack) = self.extra_knockback(&target_kind, scale);
         self.attack_ticks = 0;
@@ -7881,6 +7882,18 @@ impl Game<'_> {
                     feet,
                     width,
                     height,
+                    false,
+                );
+            }
+            // Player.attackVisualEffects: magicCrit when the enchantments added damage.
+            if magic {
+                self.critical_hit(
+                    self.lan_acting,
+                    self.mobs[index].id as i32,
+                    feet,
+                    width,
+                    height,
+                    true,
                 );
             }
             if actual > 2.0 {
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..f1b14940a 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -1224,8 +1224,9 @@ impl Game<'_> {
             self.lan_entity_events.push((id, event, at));
         }
     }
-    /// `ServerPlayer.crit`: this window's emitter, and an animation for the
-    /// attacker's client and observers once the hub is back in place.
+    /// `ServerPlayer.crit` (or `magicCrit` when `magic`): this window's
+    /// emitter, and an animation for the attacker's client and observers once
+    /// the hub is back in place.
     pub(super) fn critical_hit(
         &mut self,
         attacker: Option<u32>,
@@ -1233,16 +1234,18 @@ impl Game<'_> {
         feet: [f64; 3],
         width: f64,
         height: f64,
+        magic: bool,
     ) {
         use horizon_client::particles::{ParticleOptions, ParticleType};
-        self.particles.tracking_emitter(
-            ParticleOptions::simple(ParticleType::Crit),
-            feet,
-            width,
-            height,
-        );
+        let particle = if magic {
+            ParticleType::EnchantedHit
+        } else {
+            ParticleType::Crit
+        };
+        self.particles
+            .tracking_emitter(ParticleOptions::simple(particle), feet, width, height);
         if self.audio.capture.is_some() {
-            self.lan_critical_hits.push((attacker, id));
+            self.lan_critical_hits.push((attacker, id, magic));
         }
     }
     /// Send the tick's level events, sounds and mob animations.
@@ -1320,13 +1323,13 @@ impl Game<'_> {
             seen.insert(m.id, (m.hurt_time, dead, swing));
         }
         host.mob_state.insert(self.dim, seen);
-        for (attacker, target) in critical_hits {
+        for (attacker, target, magic) in critical_hits {
             let Some(attacker) = attacker.map_or(Some(host.host_entity), |conn| {
                 host.hub.guest(conn).map(|g| g.entity_id)
             }) else {
                 continue;
             };
-            host.hub.critical_hit(attacker, target);
+            host.hub.critical_hit(attacker, target, magic);
         }
     }
 
diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs
index 8e756b7be..65520221a 100644
--- a/crates/horizon-client/src/game/lan_pvp.rs
+++ b/crates/horizon-client/src/game/lan_pvp.rs
@@ -37,6 +37,8 @@ pub(super) struct Strike {
     amount: f32,
     scale: f32,
     crit: bool,
+    /// `Player.attack`'s `magicBoost > 0`: the enchantments added damage.
+    magic: bool,
     from: [f64; 3],
     sweep: Option<[f64; 3]>,
     /// `causeExtraKnockback`: its strength and direction (the attacker's
@@ -109,7 +111,7 @@ impl Game<'_> {
     pub(super) fn pvp_strike(&mut self) -> Option<Strike> {
         let p = self.player.as_ref()?;
         let from = [p.position.x, p.position.y, p.position.z];
-        let (amount, scale, crit) = self.melee_damage("minecraft:player");
+        let (amount, scale, crit, magic) = self.melee_damage("minecraft:player");
         let sweep = self.sweep_attack_position(scale, crit);
         let (strength, knockback_attack) = self.extra_knockback("minecraft:player", scale);
         let (xd, zd) = self.extra_knockback_direction();
@@ -125,6 +127,7 @@ impl Game<'_> {
             amount,
             scale,
             crit,
+            magic,
             from,
             sweep,
             knockback: (strength, xd, zd),
@@ -257,7 +260,7 @@ impl Game<'_> {
         } else {
             Default::default()
         };
-        if hurt && s.crit {
+        if hurt && (s.crit || s.magic) {
             let target = match victim {
                 Victim::Host => self.player.as_ref().map(|p| (host.host_entity, p)),
                 Victim::Guest(conn) => host
@@ -267,13 +270,17 @@ impl Game<'_> {
             };
             if let Some((id, p)) = target {
                 let d = p.dimensions;
-                self.critical_hit(
-                    s.attacker,
-                    id,
+                let (feet, width, height) = (
                     [p.position.x, p.position.y, p.position.z],
                     f64::from(d.width),
                     f64::from(d.height),
                 );
+                if s.crit {
+                    self.critical_hit(s.attacker, id, feet, width, height, false);
+                }
+                if s.magic {
+                    self.critical_hit(s.attacker, id, feet, width, height, true);
+                }
             }
         }
         // `Enchantment.doPostAttack`: thorns hurt the attacking player.
diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs
index 8d2e0a4a2..12a2184a4 100644
--- a/crates/horizon-client/src/game/levels.rs
+++ b/crates/horizon-client/src/game/levels.rs
@@ -75,7 +75,7 @@ pub(super) struct Parked {
     lan_events: Vec<(i32, [i32; 3], i32, Option<u32>)>,
     lan_block_events: Vec<([i32; 3], i32, i32, u32)>,
     lan_entity_events: Vec<(i32, i8, [f64; 3])>,
-    lan_critical_hits: Vec<(Option<u32>, i32)>,
+    lan_critical_hits: Vec<(Option<u32>, i32, bool)>,
     /// Only the per-level parts of these are used (`swap_level`).
     anims: BlockEntityAnims,
     raiding: Raiding,
diff --git a/crates/horizon-client/src/lan/containers.rs b/crates/horizon-client/src/lan/containers.rs
index 002f95cbb..d0f8126b0 100644
--- a/crates/horizon-client/src/lan/containers.rs
+++ b/crates/horizon-client/src/lan/containers.rs
@@ -120,12 +120,13 @@ impl Hub {
         );
     }
 
-    /// `ServerPlayer.crit`: send the victim's animation to the players tracking
-    /// the attacker and the attacker themselves (`sendToTrackingPlayersAndSelf`).
-    pub fn critical_hit(&self, attacker: i32, target: i32) {
+    /// `ServerPlayer.crit` (`magicCrit` when `magic`): send the victim's
+    /// animation to the players tracking the attacker and the attacker
+    /// themselves (`sendToTrackingPlayersAndSelf`).
+    pub fn critical_hit(&self, attacker: i32, target: i32, magic: bool) {
         let body = C::Animate(play::Animate {
             id: target,
-            action: 1,
+            action: if magic { 2 } else { 1 },
         })
         .encode();
         for g in self.guests.iter().filter(|g| {

From 591b7b74daab63df7e042a7d270c2490960f39a9 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:15:10 +0100
Subject: [PATCH 230/475] Predict the sort and tweak clicks on a server like an
 ordinary click

---
 crates/horizon-client/src/game/remote.rs | 20 --------------------
 crates/horizon-client/src/game/tweaks.rs |  3 +--
 2 files changed, 1 insertion(+), 22 deletions(-)

diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3cfbd15e3..3c333c904 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -4791,26 +4791,6 @@ impl Game<'_> {
             }));
         }
     }
-    /// A `ContainerClick` on game slot `internal` of the server's open menu
-    /// (`input` is the ContainerInput ordinal). False when the menu has no
-    /// such slot.
-    pub(super) fn remote_slot_click(&mut self, internal: usize, button: i8, input: i32) -> bool {
-        let (container, menu) = self.remote_menu();
-        let slot = Self::menu_slot_index(&menu, internal);
-        let Some(slot) = slot else { return false };
-        let carried = self.to_network(&self.carried).map(|s| Hashed::of(&s));
-        let state = self.remote.as_ref().map_or(0, |r| r.state_id);
-        self.send(S::ContainerClick(play::ContainerClick {
-            container,
-            state,
-            slot: slot as i16,
-            button,
-            input,
-            changed: Vec::new(),
-            carried,
-        }));
-        true
-    }
     /// The server's open menu is the inventory or a chest-like container
     /// (chests, barrels, ender chests: `generic_9xN`; shulker boxes).
     pub(super) fn remote_storage_open(&self) -> bool {
diff --git a/crates/horizon-client/src/game/tweaks.rs b/crates/horizon-client/src/game/tweaks.rs
index cec83e248..648073874 100644
--- a/crates/horizon-client/src/game/tweaks.rs
+++ b/crates/horizon-client/src/game/tweaks.rs
@@ -70,8 +70,7 @@ impl Game<'_> {
     /// One ordinary click on a game slot. False when nothing took it.
     pub(super) fn tweak_click(&mut self, slot: usize, button: i32, input: Input) -> bool {
         if self.remote.is_some() {
-            let ordinal = super::remote::input_ordinal(input);
-            return self.remote_slot_click(slot, button as i8, ordinal);
+            return self.remote_menu_ops(&[(Some(slot), button, input)]);
         }
         if !self.menu_click(Some(slot), button, input) {
             return false;

From df045f1e9a417b72543e4288e4deabf932473164 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 20:22:13 +0100
Subject: [PATCH 231/475] CI parity: test the head merged into main

A head tested alone keeps failing harnesses that main already fixed. Since 10-25 evening, 9 of 21 failed PR
parity jobs failed only on such fixes: server_knockback (heads without #2114, 7 times), mob_ai's oracle heap
(without #2270), save_roundtrip (without #2212). #2160 needed 4 parity runs this way.

The job now merges main's current tip into the head and selects harnesses against that main commit, so only
the pull request's own changes count. A branch that doesn't change the runner scripts or the selection gets
main's, which replaces the two steps that copied main's vanilla-data.sh and parity.py in by hand. A head that
conflicts with main is tested alone, with a warning. The job summary names the main commit, and the check is
still `parity / parity` on the head.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/parity.yml | 88 ++++++++++++------------------------
 docs/release-flow.md         |  9 ++--
 2 files changed, 36 insertions(+), 61 deletions(-)

diff --git a/.github/workflows/parity.yml b/.github/workflows/parity.yml
index 1fc31d8cb..9f678b43b 100644
--- a/.github/workflows/parity.yml
+++ b/.github/workflows/parity.yml
@@ -26,35 +26,46 @@ jobs:
     steps:
       - uses: actions/checkout@v4
         with:
-          # The commit the event names: a fork's later pushes need another run-parity label.
+          # The commit the event names: a fork's later pushes need another run-parity label. The next step merges
+          # main into it.
           ref: ${{ inputs.head }}
           fetch-depth: 0
           persist-credentials: false
           # Keeps .local/ (parity state, probe builds, oracle results) and target/ between runs.
           clean: false
+      - name: The head merged into main (what merging it would land)
+        id: merge
+        env:
+          BASE_SHA: ${{ inputs.base }}
+          HEAD_SHA: ${{ inputs.head }}
+        run: |
+          # Harness fixes and game fixes that reached main since the branch was made then apply here too: a head
+          # tested alone failed harnesses already fixed on main (server_knockback before #2114, mob_ai's heap before
+          # #2270, save_roundtrip before #2212). Selection then compares with this main, so it sees only the pull
+          # request's own changes. A head that conflicts with main is tested alone.
+          set -euo pipefail
+          git merge --abort 2>/dev/null || true
+          git fetch -q --no-tags origin +refs/heads/main:refs/remotes/origin/main
+          main=$(git rev-parse origin/main)
+          if git -c user.name=parity -c user.email=parity@localhost merge -q --no-edit --no-ff "$main" >/dev/null 2>&1; then
+            echo "base=$main" >> "$GITHUB_OUTPUT"
+            echo "Tested: head ${HEAD_SHA:0:9} merged into main ${main:0:9}" | tee -a "$GITHUB_STEP_SUMMARY"
+          else
+            git merge --abort
+            echo "base=$BASE_SHA" >> "$GITHUB_OUTPUT"
+            echo "::warning::head ${HEAD_SHA:0:9} conflicts with main ${main:0:9}: tested alone, without main's fixes"
+            echo "Tested: head ${HEAD_SHA:0:9} alone (it conflicts with main ${main:0:9})" | tee -a "$GITHUB_STEP_SUMMARY"
+          fi
       - uses: dtolnay/rust-toolchain@stable
       - name: Tools from the runner
         run: bash tools/ci/runner-env.sh
       - name: Vanilla data, and resources prepared by this preparer
-        env:
-          BASE_SHA: ${{ inputs.base }}
-        run: |
-          # main's script: one written before a fix to it left a real .local/horizon-client without sounds.json on
-          # the runner, and every later job there failed `subtitle`. A branch that changes the script runs its own.
-          set -euo pipefail
-          if git rev-parse --verify -q origin/main >/dev/null \
-            && git diff --quiet "$(git merge-base "$BASE_SHA" HEAD)" HEAD -- tools/ci/vanilla-data.sh; then
-            git show origin/main:tools/ci/vanilla-data.sh > "$RUNNER_TEMP/vanilla-data.sh"
-            bash "$RUNNER_TEMP/vanilla-data.sh"
-          else
-            bash tools/ci/vanilla-data.sh
-          fi
+        run: bash tools/ci/vanilla-data.sh
       - name: The prepared output is the one the preparer's OUTPUT_VERSION says
         env:
-          BASE_SHA: ${{ inputs.base }}
+          BASE_SHA: ${{ steps.merge.outputs.base }}
         run: |
-          # The job runs main's workflow on the head's files: a head made before OUTPUT_VERSION (#1947) has neither
-          # the tool nor the number, so there is nothing to check.
+          # A head made before OUTPUT_VERSION (#1947) that conflicts with main has neither the tool nor the number.
           if [ ! -f tools/prepare_output.py ] || ! grep -q OUTPUT_VERSION crates/horizon-prepare/src/lib.rs; then
             echo "This head's preparer has no OUTPUT_VERSION: nothing to check"
             exit 0
@@ -65,47 +76,8 @@ jobs:
       - name: The harnesses this change can affect
         env:
           PARITY_HOSTS: ''
-          BASE_SHA: ${{ inputs.base }}
-        run: |
-          # main's selection (tools/parity.py --changed --list with main's parity.py and parity_reach.py), so a
-          # branch made before a better selection landed gets it too; the head's own runner then runs those
-          # harnesses. A branch that changes the selection itself selects with its own code.
-          set -euo pipefail
-          own() { python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400; }  # world_spawn takes ~1480 s on a busy runner
-          fork_point=$(git merge-base "$BASE_SHA" HEAD)
-          if ! git rev-parse --verify -q origin/main >/dev/null || ! git diff --quiet "$fork_point" HEAD -- tools/parity.py tools/parity_reach.py; then
-            own
-            exit
-          fi
-          had_reach=$(git ls-files tools/parity_reach.py)
-          git show origin/main:tools/parity.py > tools/parity.py
-          git show origin/main:tools/parity_reach.py > tools/parity_reach.py
-          status=0
-          python3 tools/parity.py --changed "$BASE_SHA" --list > .local/parity-selection.txt || status=$?
-          git checkout -- tools/parity.py
-          if [ -n "$had_reach" ]; then git checkout -- tools/parity_reach.py; else rm -f tools/parity_reach.py; fi
-          cat .local/parity-selection.txt
-          if [ "$status" != 0 ]; then
-            echo "main's selection failed: the head's own selection runs"
-            own
-            exit
-          fi
-          names=$(sed '$d' .local/parity-selection.txt | grep -E '^[A-Za-z0-9_#]+$' || true)
-          # The summary line says how many would run: a count that doesn't match the names read (a format change)
-          # must not let the job pass untested.
-          expected=$(tail -1 .local/parity-selection.txt | sed -nE 's/^([0-9]+) of [0-9]+ harnesses would run$/\1/p')
-          count=$(printf '%s' "$names" | grep -c . || true)
-          if [ -z "$expected" ] || [ "$expected" != "$count" ]; then
-            echo "main's selection listed $count names, its summary says '${expected:-?}': the head's own selection runs"
-            own
-            exit
-          fi
-          if [ "$count" = 0 ]; then
-            echo "Nothing to run."
-            exit 0
-          fi
-          # shellcheck disable=SC2086
-          python3 tools/parity.py $names --timeout 2400
+          BASE_SHA: ${{ steps.merge.outputs.base }}
+        run: python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400  # world_spawn takes ~1480 s on a busy runner
       - name: Logs of the failed harnesses
         if: failure()
         uses: actions/upload-artifact@v4
diff --git a/docs/release-flow.md b/docs/release-flow.md
index ce7934824..b0d435c29 100644
--- a/docs/release-flow.md
+++ b/docs/release-flow.md
@@ -32,6 +32,12 @@ copy is: the Mac mini, his Linux desktop and playhorizon (below). Their runners
 between runs (`clean: false`), so the probes build incrementally into `.local/parity-target` and earlier passes
 stand.
 
+The job tests the pull request's head merged into main's current tip, which is what merging it would land: harness
+and game fixes that reached main after the branch was made apply to it too, and an old branch runs main's runner
+scripts and selection unless it changes them. The base for the selection is that main commit, so only the pull
+request's own changes count. The job summary names the main commit. A head that conflicts with main is tested
+alone, with a warning. The check is still reported on the head.
+
 1. `tools/ci/runner-env.sh` puts the machine's Python 3.13 and the JDK `research-lock.json` pins on the PATH
    (Homebrew and `java_home` on the Mac; on Linux what `linux-runner.sh` pinned, else nixpkgs), and sccache when
    the machine has it.
@@ -50,9 +56,6 @@ stand.
    modules, Java oracles and every Rust source their probes compile) changed since the merge base, plus any
    harness nothing is recorded about yet, and runs those that have no pass for their current inputs. A change to
    `Cargo.lock` or `research-lock.json` affects every harness. Each harness has 25 minutes, the job 45.
-   The selection runs with main's `tools/parity.py` and `tools/parity_reach.py` (`--changed <base> --list`), so a
-   branch made before a better selection landed gets it too, and the head's own `parity.py` then runs the named
-   harnesses. A branch that changes either file selects with its own code.
 
 Failed harnesses' logs are uploaded as the `parity-logs` artifact.
 

From 91f1f839ab9e5d637a15204bfc629a47d266bdeb Mon Sep 17 00:00:00 2001
From: kohad1ck <163426863+kohad1ck@users.noreply.github.com>
Date: Mon, 26 Oct 2026 18:28:19 +0800
Subject: [PATCH 232/475] Superflat: the Customize screen edits layers and
 presets

Create New World greyed out Customize for a Superflat world because Horizon
had no preset editor. Bring vanilla's CreateFlatWorldScreen and
PresetFlatWorldScreen:

- the layer list (top first), Remove Layer and the layer heights;
- the preset chooser with the nine visible flat_world_preset entries, their
  display items and names;
- the share box and Select, parsing layers;biome and validating block and
  biome ids against the prepared registries;
- Done keeps the layers in WorldOptions, Cancel and Escape discard them.

world_loading writes them with write_world_gen_settings_with, so a new
world's world_gen_settings keeps the custom generator; Re-Create reads them
back for the editor.

Co-Authored-By: ZCode Agent <noreply@zcode.ai>
---
 crates/horizon-client/src/game/agent.rs       |  16 +
 .../horizon-client/src/game/world_loading.rs  |   7 +-
 crates/horizon-client/src/title.rs            | 125 +++
 .../horizon-client/src/title/create_world.rs  |  25 +-
 crates/horizon-client/src/title/flat.rs       | 882 ++++++++++++++++++
 5 files changed, 1051 insertions(+), 4 deletions(-)
 create mode 100644 crates/horizon-client/src/title/flat.rs

diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs
index fa9dbf3c6..a069330f5 100644
--- a/crates/horizon-client/src/game/agent.rs
+++ b/crates/horizon-client/src/game/agent.rs
@@ -565,6 +565,22 @@ impl Game<'_> {
                 "generate_structures": options.structures,
                 "bonus_chest": options.bonus_chest(),
             }),
+            Mode::CreateFlat {
+                name,
+                seed,
+                options,
+                flat,
+                ..
+            } => json!({
+                "mode": "customize-flat",
+                "fields": { "name": name, "seed": seed },
+                "superflat": options.flat,
+                "biome": flat.settings().biome,
+                "layers": flat.settings().layers.iter().map(|layer| json!({
+                    "block": layer.block,
+                    "height": layer.height,
+                })).collect::<Vec<_>>(),
+            }),
             Mode::Edit {
                 world,
                 name,
diff --git a/crates/horizon-client/src/game/world_loading.rs b/crates/horizon-client/src/game/world_loading.rs
index ef47cc9c0..168a3eaf8 100644
--- a/crates/horizon-client/src/game/world_loading.rs
+++ b/crates/horizon-client/src/game/world_loading.rs
@@ -89,7 +89,12 @@ impl WorldRequest {
             level.hardcore = o.hardcore;
             level.difficulty = horizon_client::title::DIFFICULTIES[o.difficulty()].into();
             level.allow_commands = Some(o.commands(creative));
-            horizon_client::save::write_world_gen_settings(&save_root, level.seed, o.world_gen())?;
+            horizon_client::save::write_world_gen_settings_with(
+                &save_root,
+                level.seed,
+                o.world_gen(),
+                o.flat_settings(),
+            )?;
         }
         // Worlds made without the Create New World screen (--world, the
         // control socket) take its default: commands on for Creative only.
diff --git a/crates/horizon-client/src/title.rs b/crates/horizon-client/src/title.rs
index 87bd05fd0..e603fcf94 100644
--- a/crates/horizon-client/src/title.rs
+++ b/crates/horizon-client/src/title.rs
@@ -13,10 +13,12 @@ use std::{
 };
 
 mod create_world;
+mod flat;
 #[cfg(test)]
 mod tests;
 pub mod world_management;
 pub use create_world::{DIFFICULTIES, WorldOptions};
+pub use flat::{FlatLayer, FlatSettings, State as FlatEditor};
 
 /// SelectWorldScreen's `HeaderAndFooterLayout(8 + 9 + 8 + 20 + 4, 60)`.
 const LIST_TOP: f32 = 49.0;
@@ -101,6 +103,16 @@ pub enum Mode {
         return_to: Box<Mode>,
     },
     Multiplayer(crate::multiplayer::Screen),
+    /// CreateFlatWorldScreen over Create New World: the fields that screen
+    /// keeps and the superflat editor on top of them.
+    CreateFlat {
+        name: String,
+        seed: String,
+        creative: bool,
+        focus: u8,
+        options: WorldOptions,
+        flat: flat::State,
+    },
 }
 #[derive(Clone, Debug, PartialEq)]
 pub enum Action {
@@ -128,6 +140,8 @@ pub struct Title {
     /// Direct Connection's address, synchronized with `options.txt`'s `lastServer`.
     pub last_server: String,
     pub saves: PathBuf,
+    /// The prepared resource root: the flat preset list and block registry.
+    resources: PathBuf,
     pub started: std::time::Instant,
     search: String,
     search_focused: bool,
@@ -231,6 +245,7 @@ impl Title {
             mode,
             last_server: String::new(),
             saves,
+            resources: resources.to_owned(),
             started: now,
             search: String::new(),
             search_focused: false,
@@ -316,6 +331,64 @@ impl Title {
             self.return_to_list(None);
         }
     }
+    /// A press on the superflat screens: their list, share box or buttons.
+    fn flat_click(&mut self, x: f32, y: f32, size: (f32, f32), hit: Option<u8>) {
+        match hit {
+            Some(70) => {
+                if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+                    flat.remove_selected();
+                }
+            }
+            Some(71) => {
+                if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+                    flat.open_presets();
+                }
+            }
+            Some(72) => self.close_flat(true),
+            Some(73) => self.close_flat(false),
+            Some(74) => {
+                if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+                    flat.apply_share();
+                }
+            }
+            Some(75) => {
+                if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+                    flat.back_to_layers();
+                }
+            }
+            None => {
+                if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+                    flat::click(flat, (x, y), size);
+                }
+            }
+            _ => {}
+        }
+    }
+    /// Return to Create New World, keeping (`apply`) or dropping the layers.
+    fn close_flat(&mut self, apply: bool) {
+        let mode = std::mem::replace(&mut self.mode, Mode::Main);
+        if let Mode::CreateFlat {
+            name,
+            seed,
+            creative,
+            focus,
+            mut options,
+            flat,
+        } = mode
+        {
+            if apply {
+                options.flat = true;
+                options.flat_settings = Some(flat.settings);
+            }
+            self.mode = Mode::Create {
+                name,
+                seed,
+                creative,
+                focus,
+                options,
+            };
+        }
+    }
     fn matches_search(&self, world: &WorldEntry) -> bool {
         let filter = self.search.to_lowercase();
         world.name.to_lowercase().contains(&filter) || world.folder.to_lowercase().contains(&filter)
@@ -363,6 +436,10 @@ impl Title {
         if let Mode::Multiplayer(screen) = &mut self.mode {
             return screen.drag(cursor.1, size);
         }
+        if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+            flat::drag(flat, cursor, size);
+            return;
+        }
         if let Mode::Select { worlds, .. } = &self.mode {
             let (top, bottom, _, content) = self.world_list(worlds, size);
             let mut scroll = self.scroll.get();
@@ -375,6 +452,9 @@ impl Title {
         if let Mode::Multiplayer(screen) = &mut self.mode {
             screen.release();
         }
+        if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+            flat::release(flat);
+        }
         self.scroll.get_mut().release();
     }
     /// Mouse wheel over the classic world and server lists.
@@ -383,6 +463,10 @@ impl Title {
             screen.wheel(delta, cursor, size);
             return;
         }
+        if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+            flat::wheel(flat, delta, cursor, size);
+            return;
+        }
         let Mode::Select { worlds, .. } = &self.mode else {
             return;
         };
@@ -703,6 +787,7 @@ impl Title {
             Mode::Create {
                 creative, options, ..
             } => create_world::buttons(w, h, *creative, options),
+            Mode::CreateFlat { flat, .. } => flat::buttons(w, h, flat),
             Mode::Edit { world, name, .. } => {
                 let x = (w / 2.0).floor() - 100.0;
                 let top = edit_top(h);
@@ -1022,6 +1107,7 @@ impl Title {
                 options,
                 ..
             } => self.draw_create(atlas, batch, cursor, name, seed, *focus, options),
+            Mode::CreateFlat { flat, .. } => flat::draw(self, atlas, batch, cursor, flat),
             Mode::Edit { name, focused, .. } => {
                 crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false);
                 centered(
@@ -1224,6 +1310,10 @@ impl Title {
             .into_iter()
             .find(|b| b.enabled && x >= b.x && x < b.x + b.w && y >= b.y && y < b.y + 20.0)
             .map(|b| b.id);
+        if matches!(self.mode, Mode::CreateFlat { .. }) {
+            self.flat_click(x, y, (w, h), hit);
+            return (Action::None, hit.is_some());
+        }
         let action = self.click_action(x, y, (w, h), hit);
         // World list selection is silent; launching its selected entry sounds.
         let sound = hit.is_some() || matches!(action, Action::Play { .. });
@@ -1387,6 +1477,27 @@ impl Title {
                 self.mode = *return_to.clone();
                 Action::None
             }
+            (
+                Mode::Create {
+                    name,
+                    seed,
+                    creative,
+                    focus,
+                    options,
+                },
+                Some(26),
+            ) => {
+                let flat = flat::State::new(&self.resources, options.flat_settings.clone());
+                self.mode = Mode::CreateFlat {
+                    name: name.clone(),
+                    seed: seed.clone(),
+                    creative: *creative,
+                    focus: *focus,
+                    options: options.clone(),
+                    flat,
+                };
+                Action::None
+            }
             (
                 Mode::Create {
                     creative, options, ..
@@ -1590,6 +1701,16 @@ impl Title {
                 self.return_to_list(Some(&folder));
             }
             Mode::Error { return_to, .. } => self.mode = *return_to.clone(),
+            Mode::CreateFlat { .. } => {
+                if matches!(&self.mode, Mode::CreateFlat { flat, .. } if flat.page == flat::Page::Presets)
+                {
+                    if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+                        flat.back_to_layers();
+                    }
+                } else {
+                    self.close_flat(false);
+                }
+            }
             Mode::Create { .. } => self.cancel_create(),
             _ => self.mode = Mode::Main,
         }
@@ -1618,6 +1739,7 @@ const SEARCH: crate::clipboard::FieldId = ("world.search", 0);
 const EDIT_NAME: crate::clipboard::FieldId = ("world.edit-name", 0);
 const WORLD_NAME: crate::clipboard::FieldId = ("world.name", 0);
 const WORLD_SEED: crate::clipboard::FieldId = ("world.seed", 0);
+const FLAT_SHARE: crate::clipboard::FieldId = ("world.flat-share", 0);
 /// The focused field of the world screens and the server screens: the list's
 /// search, a world name or seed, or Add Server, Direct Connection and Join a
 /// Friend.
@@ -1641,6 +1763,9 @@ fn caret_field<'a>(
             _ => None,
         },
         Mode::Multiplayer(screen) => screen.focused_text(),
+        Mode::CreateFlat { flat, .. } if flat.page == flat::Page::Presets && flat.share_focused => {
+            Some((FLAT_SHARE, &mut flat.share, 1230))
+        }
         _ => None,
     }
 }
diff --git a/crates/horizon-client/src/title/create_world.rs b/crates/horizon-client/src/title/create_world.rs
index a2fa6b8ce..04b92ebb2 100644
--- a/crates/horizon-client/src/title/create_world.rs
+++ b/crates/horizon-client/src/title/create_world.rs
@@ -32,6 +32,8 @@ pub struct WorldOptions {
     pub commands: Option<bool>,
     /// The Superflat world preset instead of Default.
     pub flat: bool,
+    /// CreateFlatWorldScreen's layers and biome, kept with the world type.
+    pub flat_settings: Option<super::flat::FlatSettings>,
     pub structures: bool,
     pub bonus_chest: bool,
 }
@@ -43,6 +45,7 @@ impl Default for WorldOptions {
             difficulty: 2,
             commands: None,
             flat: false,
+            flat_settings: None,
             structures: true,
             bonus_chest: false,
         }
@@ -64,6 +67,10 @@ impl WorldOptions {
                 .unwrap_or(2),
             commands: Some(commands),
             flat: generation.flat,
+            flat_settings: generation
+                .flat
+                .then(|| super::flat::FlatSettings::from_world(dir))
+                .flatten(),
             structures: generation.structures,
             bonus_chest: generation.bonus_chest,
             ..Self::default()
@@ -88,6 +95,12 @@ impl WorldOptions {
             bonus_chest: self.bonus_chest(),
         }
     }
+    /// The custom layers, as `write_world_gen_settings_with` takes them.
+    pub fn flat_settings(&self) -> Option<horizon_world::nbt::Tag> {
+        self.flat_settings
+            .as_ref()
+            .map(super::flat::FlatSettings::to_tag)
+    }
     /// A press on one of the open tab's cycle buttons or switches.
     pub(super) fn press(&mut self, id: u8, creative: &mut bool) {
         match id {
@@ -101,7 +114,13 @@ impl WorldOptions {
             }
             23 => self.difficulty = (self.difficulty + 1) % DIFFICULTIES.len(),
             24 => self.commands = Some(!self.commands(*creative)),
-            25 => self.flat = !self.flat,
+            25 => {
+                self.flat = !self.flat;
+                if self.flat {
+                    // setWorldType starts the generator from the flat preset.
+                    self.flat_settings = Some(super::flat::FlatSettings::default());
+                }
+            }
             27 => self.structures = !self.structures,
             28 => self.bonus_chest = !self.bonus_chest,
             _ => {}
@@ -243,13 +262,13 @@ pub(super) fn buttons(w: f32, h: f32, creative: bool, o: &WorldOptions) -> Vec<B
                 true,
                 25,
             ),
-            // Horizon has no preset editor (CreateFlatWorldScreen) yet.
+            // CreateFlatWorldScreen: only a flat generator has a preset editor.
             b(
                 gx + 160.0,
                 gy,
                 150.0,
                 tr("selectWorld.customizeType"),
-                false,
+                o.flat,
                 26,
             ),
             // SwitchGrid: 44-wide value-only buttons at the grid's right.
diff --git a/crates/horizon-client/src/title/flat.rs b/crates/horizon-client/src/title/flat.rs
new file mode 100644
index 000000000..0840f8bf2
--- /dev/null
+++ b/crates/horizon-client/src/title/flat.rs
@@ -0,0 +1,882 @@
+//! CreateFlatWorldScreen and PresetFlatWorldScreen: the Superflat layer list,
+//! the preset chooser and the settings they hand back to Create New World.
+use super::{Button, Title};
+use crate::{
+    hud::{HudAtlas, HudBatch, rgba},
+    lang,
+    text::{Text, format_translation},
+    ui,
+};
+use horizon_world::nbt::Tag;
+use serde_json::Value;
+use std::{collections::BTreeSet, path::Path};
+
+/// DimensionType.Y_SIZE: the most blocks a flat generator takes.
+const Y_SIZE: i32 = 4064;
+/// The list's row width (ObjectSelectionList.getRowWidth).
+const ROW_WIDTH: f32 = 220.0;
+/// The header row above the layers.
+const HEADER: f32 = 14.0;
+/// A layer or preset row.
+const LAYER_ROW: f32 = 20.0;
+const PRESET_ROW: f32 = 24.0;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FlatLayer {
+    /// A block id such as `minecraft:dirt`.
+    pub block: String,
+    /// How many blocks tall this layer is (0..=4064).
+    pub height: i32,
+}
+
+/// FlatLevelGeneratorSettings: the layers (bottom to top), the biome and the
+/// decorations CreateFlatWorldScreen edits.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FlatSettings {
+    pub biome: String,
+    pub features: bool,
+    pub lakes: bool,
+    pub layers: Vec<FlatLayer>,
+    pub structure_overrides: Vec<String>,
+}
+impl Default for FlatSettings {
+    fn default() -> Self {
+        // worldgen/world_preset/flat.json's overworld.
+        Self {
+            biome: "minecraft:plains".into(),
+            features: false,
+            lakes: false,
+            layers: vec![
+                FlatLayer {
+                    block: "minecraft:bedrock".into(),
+                    height: 1,
+                },
+                FlatLayer {
+                    block: "minecraft:dirt".into(),
+                    height: 2,
+                },
+                FlatLayer {
+                    block: "minecraft:grass_block".into(),
+                    height: 1,
+                },
+            ],
+            structure_overrides: vec!["minecraft:strongholds".into(), "minecraft:villages".into()],
+        }
+    }
+}
+impl FlatSettings {
+    /// A saved world's flat generator settings, for Re-Create.
+    pub fn from_world(dir: &Path) -> Option<Self> {
+        let settings = crate::save::world_gen_settings(dir)?;
+        let generator = settings
+            .get("dimensions")?
+            .get("minecraft:overworld")?
+            .get("generator")?;
+        if crate::save::text(generator.get("type"))?.trim_start_matches("minecraft:") != "flat" {
+            return None;
+        }
+        Self::from_tag(generator.get("settings")?)
+    }
+    pub fn from_tag(tag: &Tag) -> Option<Self> {
+        let Some(Tag::List(list)) = tag.get("layers") else {
+            return None;
+        };
+        let layers: Vec<FlatLayer> = list
+            .iter()
+            .filter_map(|layer| {
+                Some(FlatLayer {
+                    block: crate::save::text(layer.get("block"))?,
+                    height: crate::save::number(layer.get("height"))?.clamp(0, Y_SIZE as i64)
+                        as i32,
+                })
+            })
+            .collect();
+        if layers.is_empty() {
+            return None;
+        }
+        let flag = |key: &str, default: bool| {
+            crate::save::number(tag.get(key)).map_or(default, |value| value != 0)
+        };
+        let structure_overrides = match tag.get("structure_overrides") {
+            Some(Tag::String(text)) => vec![text.to_string_lossy()],
+            Some(Tag::List(list)) => list
+                .iter()
+                .filter_map(|value| crate::save::text(Some(value)))
+                .collect(),
+            _ => Vec::new(),
+        };
+        Some(Self {
+            biome: crate::save::text(tag.get("biome")).unwrap_or_else(|| "minecraft:plains".into()),
+            features: flag("features", false),
+            lakes: flag("lakes", false),
+            layers,
+            structure_overrides,
+        })
+    }
+    /// FlatLevelGeneratorSettings.CODEC, as world_gen_settings stores it.
+    pub fn to_tag(&self) -> Tag {
+        let string = |text: &str| Tag::String(text.into());
+        Tag::compound([
+            ("biome", string(&self.biome)),
+            ("features", Tag::Byte(i8::from(self.features))),
+            ("lakes", Tag::Byte(i8::from(self.lakes))),
+            (
+                "layers",
+                Tag::List(
+                    self.layers
+                        .iter()
+                        .map(|layer| {
+                            Tag::compound([
+                                ("block", string(&layer.block)),
+                                ("height", Tag::Int(layer.height)),
+                            ])
+                        })
+                        .collect(),
+                ),
+            ),
+            (
+                "structure_overrides",
+                Tag::List(
+                    self.structure_overrides
+                        .iter()
+                        .map(|id| string(id))
+                        .collect(),
+                ),
+            ),
+        ])
+    }
+    /// `CreateFlatWorldScreen.save`: the text the preset screen shows.
+    pub fn to_share(&self) -> String {
+        let layers = self
+            .layers
+            .iter()
+            .map(|layer| {
+                if layer.height == 1 {
+                    layer.block.clone()
+                } else {
+                    format!("{}*{}", layer.height, layer.block)
+                }
+            })
+            .collect::<Vec<_>>()
+            .join(",");
+        format!("{layers};{}", self.biome)
+    }
+    /// `PresetFlatWorldScreen.fromString`: `layers;biome`, keeping the
+    /// decorations the screen was opened with. `None` for a malformed list,
+    /// as vanilla falls back to the preset's own settings.
+    pub fn parse(
+        text: &str,
+        blocks: &BTreeSet<String>,
+        biomes: &BTreeSet<String>,
+        base: &Self,
+    ) -> Option<Self> {
+        let (layer_text, biome_text) = text.split_once(';').unwrap_or((text, ""));
+        let mut layers = Vec::new();
+        let mut total = 0;
+        for part in layer_text.split(',') {
+            let part = part.trim();
+            if part.is_empty() {
+                continue;
+            }
+            let (height, block) = match part.split_once('*') {
+                Some((height, block)) => (height.trim().parse::<i32>().ok()?, block.trim()),
+                None => (1, part),
+            };
+            let block = namespaced(block);
+            if !blocks.is_empty() && !blocks.contains(&block) {
+                return None;
+            }
+            let height = height.max(0).min(Y_SIZE - total);
+            if height == 0 {
+                continue;
+            }
+            total += height;
+            layers.push(FlatLayer { block, height });
+        }
+        if layers.is_empty() {
+            return None;
+        }
+        let mut biome = namespaced(biome_text.trim());
+        if biome == "minecraft:" || biome.is_empty() {
+            biome = "minecraft:plains".into();
+        }
+        if !biomes.is_empty() && !biomes.contains(&biome) {
+            biome = "minecraft:plains".into();
+        }
+        Some(Self {
+            biome,
+            layers,
+            ..base.clone()
+        })
+    }
+}
+/// `Identifier.parse`: bare names get the default namespace.
+fn namespaced(id: &str) -> String {
+    if id.is_empty() || id.contains(':') {
+        id.to_owned()
+    } else {
+        format!("minecraft:{id}")
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) enum Page {
+    Layers,
+    Presets,
+}
+
+#[derive(Clone, Debug)]
+pub struct State {
+    pub(super) page: Page,
+    pub(super) settings: FlatSettings,
+    /// The preset screen's share box (`createWorld.customize.presets.share`).
+    pub(super) share: String,
+    pub(super) share_focused: bool,
+    /// The selected layer, in the list's top-first order.
+    pub(super) selected: Option<usize>,
+    pub(super) scroll: ui::Scroll,
+    preset_selected: Option<usize>,
+    preset_scroll: ui::Scroll,
+    presets: Vec<Preset>,
+    blocks: BTreeSet<String>,
+    biomes: BTreeSet<String>,
+}
+#[derive(Clone, Debug)]
+struct Preset {
+    id: String,
+    display: String,
+    settings: FlatSettings,
+}
+impl State {
+    /// The layers the editor holds, for the control socket's state.
+    pub fn settings(&self) -> &FlatSettings {
+        &self.settings
+    }
+    pub(super) fn new(root: &Path, current: Option<FlatSettings>) -> Self {
+        let settings = current.unwrap_or_default();
+        let (presets, blocks, biomes) = load(root);
+        Self {
+            page: Page::Layers,
+            share: settings.to_share(),
+            settings,
+            share_focused: false,
+            selected: None,
+            scroll: ui::Scroll::default(),
+            preset_selected: None,
+            preset_scroll: ui::Scroll::default(),
+            presets,
+            blocks,
+            biomes,
+        }
+    }
+    pub(super) fn open_presets(&mut self) {
+        self.page = Page::Presets;
+        self.preset_selected = None;
+        self.preset_scroll = ui::Scroll::default();
+        self.share = self.settings.to_share();
+        self.share_focused = false;
+    }
+    pub(super) fn back_to_layers(&mut self) {
+        self.page = Page::Layers;
+        self.share_focused = false;
+    }
+    pub(super) fn remove_selected(&mut self) {
+        let Some(row) = self.selected else {
+            return;
+        };
+        let index = self.settings.layers.len().wrapping_sub(1 + row);
+        if index < self.settings.layers.len() {
+            self.settings.layers.remove(index);
+        }
+        self.selected = None;
+    }
+    /// PresetFlatWorldScreen's Select: parse the share text into the settings
+    /// the Create New World screen keeps.
+    pub(super) fn apply_share(&mut self) {
+        // PresetFlatWorldScreen keeps the selected preset's decorations while
+        // the share text supplies its layers and biome.
+        let base = self
+            .preset_selected
+            .and_then(|index| self.presets.get(index))
+            .map(|preset| preset.settings.clone())
+            .unwrap_or_else(|| self.settings.clone());
+        // A malformed list falls back to FlatLevelGeneratorSettings.getDefault.
+        let settings =
+            FlatSettings::parse(&self.share, &self.blocks, &self.biomes, &base).unwrap_or_default();
+        self.settings = settings;
+        self.share = self.settings.to_share();
+        self.page = Page::Layers;
+        self.share_focused = false;
+        self.selected = None;
+    }
+    fn select_preset(&mut self, index: usize) {
+        let Some(preset) = self.presets.get(index) else {
+            return;
+        };
+        self.preset_selected = Some(index);
+        self.share = preset.settings.to_share();
+        self.share_focused = false;
+    }
+    fn selecting(&self) -> Option<usize> {
+        self.preset_selected
+    }
+}
+
+/// `<root>/data/<namespace>/worldgen/flat_level_generator_preset/<path>.json`,
+/// in the order of the `visible` tag, plus the block and biome ids the share
+/// text is checked against.
+fn load(root: &Path) -> (Vec<Preset>, BTreeSet<String>, BTreeSet<String>) {
+    let mut presets = Vec::new();
+    let tag_path =
+        root.join("data/minecraft/tags/worldgen/flat_level_generator_preset/visible.json");
+    if let Ok(text) = std::fs::read_to_string(tag_path)
+        && let Ok(Value::Object(tag)) = serde_json::from_str(&text)
+        && let Some(Value::Array(ids)) = tag.get("values")
+    {
+        for id in ids.iter().filter_map(Value::as_str) {
+            let Some((namespace, path)) = id.split_once(':') else {
+                continue;
+            };
+            let path = root.join(format!(
+                "data/{namespace}/worldgen/flat_level_generator_preset/{path}.json"
+            ));
+            let Ok(text) = std::fs::read_to_string(path) else {
+                continue;
+            };
+            let Ok(value) = serde_json::from_str::<Value>(&text) else {
+                continue;
+            };
+            let Some(settings) = preset_settings(&value) else {
+                continue;
+            };
+            presets.push(Preset {
+                id: id.to_owned(),
+                display: value["display"]
+                    .as_str()
+                    .unwrap_or("minecraft:grass_block")
+                    .to_owned(),
+                settings,
+            });
+        }
+    }
+    let blocks = registry_ids(root, "minecraft:block");
+    let biomes = json_keys(&root.join("worldgen/biomes.json"));
+    (presets, blocks, biomes)
+}
+fn preset_settings(value: &Value) -> Option<FlatSettings> {
+    let settings = value.get("settings")?;
+    let layers = settings
+        .get("layers")?
+        .as_array()?
+        .iter()
+        .filter_map(|layer| {
+            Some(FlatLayer {
+                block: layer.get("block")?.as_str()?.to_owned(),
+                height: layer.get("height")?.as_i64()? as i32,
+            })
+        })
+        .collect::<Vec<_>>();
+    if layers.is_empty() {
+        return None;
+    }
+    let structure_overrides = match settings.get("structure_overrides") {
+        Some(Value::String(id)) => vec![id.clone()],
+        Some(Value::Array(ids)) => ids
+            .iter()
+            .filter_map(Value::as_str)
+            .map(str::to_owned)
+            .collect(),
+        _ => Vec::new(),
+    };
+    Some(FlatSettings {
+        biome: settings
+            .get("biome")
+            .and_then(Value::as_str)
+            .unwrap_or("minecraft:plains")
+            .to_owned(),
+        features: settings
+            .get("features")
+            .and_then(Value::as_bool)
+            .unwrap_or(false),
+        lakes: settings
+            .get("lakes")
+            .and_then(Value::as_bool)
+            .unwrap_or(false),
+        layers,
+        structure_overrides,
+    })
+}
+/// The ids of a registry in the prepared `registries.json`.
+fn registry_ids(root: &Path, registry: &str) -> BTreeSet<String> {
+    let Ok(text) = std::fs::read_to_string(root.join("registries.json")) else {
+        return BTreeSet::new();
+    };
+    let Ok(value) = serde_json::from_str::<Value>(&text) else {
+        return BTreeSet::new();
+    };
+    value
+        .get(registry)
+        .and_then(|registry| registry.get("entries"))
+        .and_then(Value::as_object)
+        .map(|entries| entries.keys().cloned().collect())
+        .unwrap_or_default()
+}
+fn json_keys(path: &Path) -> BTreeSet<String> {
+    let Ok(text) = std::fs::read_to_string(path) else {
+        return BTreeSet::new();
+    };
+    let Ok(value) = serde_json::from_str::<Value>(&text) else {
+        return BTreeSet::new();
+    };
+    value
+        .as_object()
+        .map(|entries| entries.keys().cloned().collect())
+        .unwrap_or_default()
+}
+
+/// CreateFlatWorldScreen's list and the preset screen's list.
+fn list_area(state: &State, size: (f32, f32)) -> (f32, f32, f32, f32) {
+    let (w, h) = (size.0.ceil(), size.1.ceil());
+    let (top, bottom) = match state.page {
+        Page::Layers => (43.0, h - 60.0),
+        Page::Presets => (80.0, h - 37.0),
+    };
+    let left = ((w - ROW_WIDTH) * 0.5).floor();
+    let rows = match state.page {
+        Page::Layers => HEADER + state.settings.layers.len() as f32 * LAYER_ROW + 4.0,
+        Page::Presets => state.presets.len() as f32 * PRESET_ROW + 4.0,
+    };
+    (top, bottom, left, rows)
+}
+
+pub(super) fn buttons(w: f32, h: f32, state: &State) -> Vec<Button> {
+    let b = |x: f32, y: f32, w: f32, key: &str, fallback: &str, enabled: bool, id: u8| Button {
+        x,
+        y,
+        w,
+        label: lang::get_or(key, fallback),
+        enabled,
+        id,
+        icon: None,
+    };
+    match state.page {
+        Page::Layers => {
+            let x = ((w - 308.0) * 0.5).trunc();
+            vec![
+                b(
+                    x,
+                    h - 52.0,
+                    150.0,
+                    "createWorld.customize.flat.removeLayer",
+                    "Remove Layer",
+                    state.selected.is_some(),
+                    70,
+                ),
+                b(
+                    x + 158.0,
+                    h - 52.0,
+                    150.0,
+                    "createWorld.customize.presets",
+                    "Presets",
+                    true,
+                    71,
+                ),
+                b(x, h - 28.0, 150.0, "gui.done", "Done", true, 72),
+                b(x + 158.0, h - 28.0, 150.0, "gui.cancel", "Cancel", true, 73),
+            ]
+        }
+        Page::Presets => vec![
+            b(
+                w / 2.0 - 155.0,
+                h - 28.0,
+                150.0,
+                "createWorld.customize.presets.select",
+                "Select",
+                state.selecting().is_some() || state.share.len() > 1,
+                74,
+            ),
+            b(
+                w / 2.0 + 5.0,
+                h - 28.0,
+                150.0,
+                "gui.cancel",
+                "Cancel",
+                true,
+                75,
+            ),
+        ],
+    }
+}
+
+/// The layer under the pointer (top-first), and whether the pointer is on the
+/// list at all.
+fn layer_row(state: &State, cursor: (f32, f32), size: (f32, f32)) -> Option<usize> {
+    let (top, bottom, _, _) = list_area(state, size);
+    if cursor.1 < top || cursor.1 >= bottom {
+        return None;
+    }
+    let y = cursor.1 - top - 2.0 + state.scroll.amount;
+    if y < HEADER {
+        return None;
+    }
+    let row = ((y - HEADER) / LAYER_ROW).floor() as usize;
+    (row < state.settings.layers.len()).then_some(row)
+}
+fn preset_row(state: &State, cursor: (f32, f32), size: (f32, f32)) -> Option<usize> {
+    let (top, bottom, _, _) = list_area(state, size);
+    if cursor.1 < top || cursor.1 >= bottom {
+        return None;
+    }
+    let row = ((cursor.1 - top - 2.0 + state.preset_scroll.amount) / PRESET_ROW).floor() as usize;
+    (row < state.presets.len()).then_some(row)
+}
+
+/// A press on the list, the share box or its scrollbar.
+pub(super) fn click(state: &mut State, cursor: (f32, f32), size: (f32, f32)) {
+    let (top, bottom, left, content) = list_area(state, size);
+    let bar = left + ROW_WIDTH + 6.0;
+    match state.page {
+        Page::Layers => {
+            if state.scroll.press(cursor, bar, top, bottom, content) {
+                return;
+            }
+            state.selected = layer_row(state, cursor, size);
+        }
+        Page::Presets => {
+            let field = share_field(size);
+            state.share_focused = ui::hovered(cursor, field[0], field[1], field[2], field[3]);
+            if state.preset_scroll.press(cursor, bar, top, bottom, content) {
+                return;
+            }
+            if let Some(row) = preset_row(state, cursor, size) {
+                state.select_preset(row);
+            }
+        }
+    }
+}
+fn share_field(size: (f32, f32)) -> [f32; 4] {
+    [50.0, 40.0, (size.0.ceil() - 100.0).max(1.0), 20.0]
+}
+
+pub(super) fn wheel(state: &mut State, delta: f32, cursor: (f32, f32), size: (f32, f32)) {
+    let (top, bottom, _, content) = list_area(state, size);
+    if cursor.1 < top || cursor.1 >= bottom {
+        return;
+    }
+    match state.page {
+        Page::Layers => state.scroll.wheel(delta, LAYER_ROW, top, bottom, content),
+        Page::Presets => state
+            .preset_scroll
+            .wheel(delta, PRESET_ROW, top, bottom, content),
+    }
+}
+pub(super) fn drag(state: &mut State, cursor: (f32, f32), size: (f32, f32)) {
+    let (top, bottom, _, content) = list_area(state, size);
+    match state.page {
+        Page::Layers => state.scroll.drag(cursor.1, top, bottom, content),
+        Page::Presets => state.preset_scroll.drag(cursor.1, top, bottom, content),
+    }
+}
+pub(super) fn release(state: &mut State) {
+    state.scroll.release();
+    state.preset_scroll.release();
+}
+
+pub(super) fn draw(
+    title: &Title,
+    atlas: &HudAtlas,
+    batch: &mut HudBatch,
+    cursor: (f32, f32),
+    state: &State,
+) {
+    let (w, h) = (batch.width.ceil(), batch.height.ceil());
+    ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false);
+    match state.page {
+        Page::Layers => draw_layers(title, atlas, batch, cursor, state, (w, h)),
+        Page::Presets => draw_presets(title, atlas, batch, cursor, state, (w, h)),
+    }
+}
+
+fn draw_layers(
+    _title: &Title,
+    atlas: &HudAtlas,
+    batch: &mut HudBatch,
+    cursor: (f32, f32),
+    state: &State,
+    (w, h): (f32, f32),
+) {
+    super::centered(
+        atlas,
+        batch,
+        &lang::get_or(
+            "createWorld.customize.flat.title",
+            "Superflat Customization",
+        ),
+        8.0,
+        u32::MAX,
+    );
+    let (top, bottom, left, content) = list_area(state, (w, h));
+    ui::list_background(batch, atlas, top, bottom, false);
+    crate::ui::separators(batch, atlas, top, bottom, false);
+    let first = batch.vertices.len();
+    let right = left + ROW_WIDTH;
+    batch.text_styled(
+        atlas,
+        &Text::translate("createWorld.customize.flat.tile", &[]).underlined(),
+        left + 2.0,
+        top + 3.0,
+        u32::MAX,
+        true,
+    );
+    let height_header = Text::translate("createWorld.customize.flat.height", &[]).underlined();
+    let hw = HudBatch::text_width(atlas, &height_header.plain());
+    batch.text_styled(
+        atlas,
+        &height_header,
+        right - hw - 2.0,
+        top + 3.0,
+        u32::MAX,
+        true,
+    );
+    let offset = state.scroll.amount.trunc();
+    let selected = state.selected;
+    for (row, layer) in state.settings.layers.iter().rev().enumerate() {
+        let y = top + 2.0 + HEADER + row as f32 * LAYER_ROW - offset;
+        let target = [left - 2.0, y - 1.0, ROW_WIDTH + 4.0, LAYER_ROW];
+        let hovered = ui::hovered(cursor, target[0], target[1], target[2], target[3]);
+        if selected == Some(row) {
+            batch.fill(
+                atlas,
+                target[0],
+                target[1],
+                target[2],
+                target[3],
+                rgba(255, 255, 255, 70),
+            );
+        } else if hovered {
+            batch.fill(
+                atlas,
+                target[0],
+                target[1],
+                target[2],
+                target[3],
+                rgba(255, 255, 255, 25),
+            );
+        }
+        slot(
+            atlas,
+            batch,
+            layer_icon(atlas, &layer.block),
+            left + 2.0,
+            y + 1.0,
+        );
+        batch.text(
+            atlas,
+            &item_name(&layer.block),
+            left + 2.0 + 18.0 + 5.0,
+            y + 5.0,
+            u32::MAX,
+            true,
+        );
+        let (key, fallback) = if row == 0 {
+            ("createWorld.customize.flat.layer.top", "Top - %s")
+        } else if row + 1 == state.settings.layers.len() {
+            ("createWorld.customize.flat.layer.bottom", "Bottom - %s")
+        } else {
+            ("createWorld.customize.flat.layer", "%s")
+        };
+        let label = format_translation(
+            &lang::get_or(key, fallback),
+            &[Text::literal(layer.height.to_string())],
+        )
+        .plain();
+        let text_width = HudBatch::text_width(atlas, &label);
+        batch.text(
+            atlas,
+            &label,
+            right - text_width - 2.0,
+            y + 5.0,
+            u32::MAX,
+            true,
+        );
+    }
+    batch.clip_since(first, 0.0, top, w, bottom);
+    ui::scrollbar(
+        batch,
+        atlas,
+        left + ROW_WIDTH + 6.0,
+        top,
+        bottom,
+        content,
+        state.scroll.amount,
+    );
+}
+
+fn draw_presets(
+    title: &Title,
+    atlas: &HudAtlas,
+    batch: &mut HudBatch,
+    cursor: (f32, f32),
+    state: &State,
+    (w, h): (f32, f32),
+) {
+    super::centered(
+        atlas,
+        batch,
+        &lang::get_or("createWorld.customize.presets.title", "Select a Preset"),
+        8.0,
+        u32::MAX,
+    );
+    batch.text(
+        atlas,
+        &lang::get_or(
+            "createWorld.customize.presets.share",
+            "Want to share your preset with someone? Use the box below!",
+        ),
+        51.0,
+        30.0,
+        rgba(160, 160, 160, 255),
+        true,
+    );
+    // The share box: EditBox at 50,40, width - 100 by 20.
+    let field = share_field((w, h));
+    title.caret.borrow_mut().draw(
+        batch,
+        atlas,
+        (super::FLAT_SHARE, &state.share, 1230),
+        field,
+        state.share_focused,
+        title.started,
+    );
+    batch.text(
+        atlas,
+        &lang::get_or(
+            "createWorld.customize.presets.list",
+            "Alternatively, here are some we made earlier!",
+        ),
+        51.0,
+        68.0,
+        rgba(160, 160, 160, 255),
+        true,
+    );
+    let (top, bottom, left, content) = list_area(state, (w, h));
+    ui::list_background(batch, atlas, top, bottom, false);
+    crate::ui::separators(batch, atlas, top, bottom, false);
+    let first = batch.vertices.len();
+    let offset = state.preset_scroll.amount.trunc();
+    for (row, preset) in state.presets.iter().enumerate() {
+        let y = top + 2.0 + row as f32 * PRESET_ROW - offset;
+        let target = [left - 2.0, y - 1.0, ROW_WIDTH + 4.0, PRESET_ROW];
+        let hovered = ui::hovered(cursor, target[0], target[1], target[2], target[3]);
+        if state.preset_selected == Some(row) {
+            batch.fill(
+                atlas,
+                target[0],
+                target[1],
+                target[2],
+                target[3],
+                rgba(255, 255, 255, 70),
+            );
+        } else if hovered {
+            batch.fill(
+                atlas,
+                target[0],
+                target[1],
+                target[2],
+                target[3],
+                rgba(255, 255, 255, 25),
+            );
+        }
+        slot(
+            atlas,
+            batch,
+            layer_icon(atlas, &preset.display),
+            left + 2.0,
+            y + 2.0,
+        );
+        batch.text(
+            atlas,
+            &preset_name(&preset.id),
+            left + 2.0 + 18.0 + 5.0,
+            y + 7.0,
+            u32::MAX,
+            true,
+        );
+    }
+    batch.clip_since(first, 0.0, top, w, bottom);
+    ui::scrollbar(
+        batch,
+        atlas,
+        left + ROW_WIDTH + 6.0,
+        top,
+        bottom,
+        content,
+        state.preset_scroll.amount,
+    );
+}
+
+/// The 18x18 slot behind a layer's item icon (`container/slot`).
+fn slot(atlas: &HudAtlas, batch: &mut HudBatch, icon: Option<String>, x: f32, y: f32) {
+    if let Some(rect) = atlas.sprites.get("gui/sprites/container/slot").copied() {
+        batch.rect_uv(x, y, 18.0, 18.0, rect, u32::MAX);
+    } else {
+        batch.fill(atlas, x, y, 18.0, 18.0, rgba(139, 139, 139, 255));
+        batch.fill(atlas, x + 1.0, y + 1.0, 16.0, 16.0, rgba(55, 55, 55, 255));
+    }
+    if let Some(icon) = icon {
+        batch.sprite_scaled(atlas, &icon, x + 1.0, y + 1.0, 16.0, 16.0, u32::MAX);
+    }
+}
+fn layer_icon(atlas: &HudAtlas, id: &str) -> Option<String> {
+    let name = id.strip_prefix("minecraft:").unwrap_or(id);
+    let candidates: Vec<String> = if name == "water" {
+        vec!["item/water_bucket".into()]
+    } else if name == "lava" {
+        vec!["item/lava_bucket".into()]
+    } else {
+        vec![
+            format!("item/{name}"),
+            format!("block/{name}"),
+            format!("block/{name}_side"),
+            format!("block/{name}_top"),
+        ]
+    };
+    candidates
+        .into_iter()
+        .find(|sprite| atlas.sprites.contains_key(sprite))
+}
+fn item_name(id: &str) -> String {
+    let name = id.strip_prefix("minecraft:").unwrap_or(id);
+    if name == "water" {
+        return lang::get_or("item.minecraft.water_bucket", "Water Bucket");
+    }
+    if name == "lava" {
+        return lang::get_or("item.minecraft.lava_bucket", "Lava Bucket");
+    }
+    for key in [
+        format!("block.minecraft.{name}"),
+        format!("item.minecraft.{name}"),
+    ] {
+        if lang::has(&key) {
+            return lang::get(&key);
+        }
+    }
+    pretty(name)
+}
+fn preset_name(id: &str) -> String {
+    let key = format!("flat_world_preset.{}", id.replace(':', "."));
+    lang::get_or(&key, &pretty(id.strip_prefix("minecraft:").unwrap_or(id)))
+}
+fn pretty(name: &str) -> String {
+    name.split('_')
+        .filter(|word| !word.is_empty())
+        .map(|word| {
+            let mut chars = word.chars();
+            match chars.next() {
+                Some(first) => first.to_uppercase().chain(chars).collect::<String>(),
+                None => String::new(),
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(" ")
+}

From 317f30427efaf0faa44fb0a4554d4652187dbf82 Mon Sep 17 00:00:00 2001
From: masa-masa-0314 <348336850+masa-masa-0314@users.noreply.github.com>
Date: Mon, 26 Oct 2026 22:33:08 +0800
Subject: [PATCH 233/475] Superflat: keep an empty layer list on Re-Create

FlatSettings::from_tag rejected layers: [], so a world with every layer removed fell back to the classic bedrock/dirt/grass settings when re-created. An empty saved list is a valid void flat generator; a non-empty list whose entries all fail to parse is still rejected.

Co-Authored-By: ZCode Agent <noreply@zcode.ai>
---
 crates/horizon-client/src/title/flat.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/title/flat.rs b/crates/horizon-client/src/title/flat.rs
index 0840f8bf2..506064344 100644
--- a/crates/horizon-client/src/title/flat.rs
+++ b/crates/horizon-client/src/title/flat.rs
@@ -91,7 +91,9 @@ impl FlatSettings {
                 })
             })
             .collect();
-        if layers.is_empty() {
+        // `layers: []` is a valid void flat world; a list whose entries all
+        // fail to parse is not.
+        if layers.is_empty() && !list.is_empty() {
             return None;
         }
         let flag = |key: &str, default: bool| {

From e82fa3d957b70971510ea267375e9160859ede51 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 20:27:34 +0100
Subject: [PATCH 234/475] parity: retry a known flaky harness once, and say so

tools/parity_hosts.json's new `known_flaky` lists the harnesses that still flake for a cause not fixed yet,
each with its reason: dedicated_server (its Java client's 1.5 s step timer), remote_fireball (wall-clock
sampling) and world_reopen. One of them that fails runs once more from scratch, and a pass then counts.

Every retry prints a RETRIED line at the end of the run and in the CI job's summary, so a harness that
passes only on its retry stays visible on PR parity and parity-main alike. The existing fresh rerun of a
failure that reused oracle results is reported the same way. A known flaky harness skips that rerun and keeps
reusing oracle results, because flaking doesn't mean its cached oracle runs were wrong. Repeated runs
(--repeat, --flake-check) are never retried.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/parity-workflow.md     |  7 ++++
 tests/test_parity_runner.py | 84 +++++++++++++++++++++++++++++++++++--
 tools/parity.py             | 74 +++++++++++++++++++++++++++++---
 tools/parity_hosts.json     |  5 +++
 4 files changed, 161 insertions(+), 9 deletions(-)

diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md
index 27505d9de..c0cf3aec5 100644
--- a/docs/parity-workflow.md
+++ b/docs/parity-workflow.md
@@ -133,6 +133,13 @@ when named and in the nightly audit (`--all`). LAN writes `results.json`
 with the host mode and each result beside its screenshots and logs. A skipped
 case is recorded explicitly and does not count as passing coverage.
 
+`known_flaky` in `tools/parity_hosts.json` lists harnesses that fail now and then for a
+cause not fixed yet, each with its reason. One that fails runs once more from
+scratch, and a pass then counts. `parity.py` prints a `RETRIED` line for it
+in its summary and in the CI job's summary (PR parity and parity-main), so the
+flake stays visible. No other harness gets this retry. Fix the cause, then take
+the harness off the list.
+
 The game-binary fixture audit keeps these complementary direct rule tests:
 
 - `command_harness.rs`: command feedback, styled spans and result callbacks,
diff --git a/tests/test_parity_runner.py b/tests/test_parity_runner.py
index 518f23ba4..49a88f0b1 100644
--- a/tests/test_parity_runner.py
+++ b/tests/test_parity_runner.py
@@ -290,9 +290,6 @@ class OracleReuseTests(unittest.TestCase):
         self.assertEqual(self.output.read_text(), "b")
 
 
-if __name__ == "__main__":
-    unittest.main()
-
 
 class LargeOutputTests(unittest.TestCase):
     def test_a_pass_clears_only_its_own_directory(self):
@@ -323,3 +320,84 @@ class LargeOutputTests(unittest.TestCase):
                 listing.write_text(f"{own / 'server.txt'}\n{own / 'client.txt'}\n")
                 parity.clear_large_outputs("state_provider#2", trace)
             self.assertEqual(sorted(path.name for path in own.iterdir()), ["report.json", "server.txt"])
+
+
+class FakeExecutor:
+    """Runs nothing: each start of a harness takes the next status from its script, a list."""
+    name, dead, max_peak = "fake", False, None
+
+    def __init__(self):
+        self.started, self.finished = [], []
+
+    def free(self):
+        return 1
+
+    def accepts(self, name):
+        return True
+
+    def fits(self, expected, only_here=True):
+        return True
+
+    def start(self, label, script, reuse, expected, shard=None):
+        self.started.append((label, reuse))
+        self.finished.append((label, {"status": script.pop(0), "seconds": 1.0, "dependencies": []}))
+        return True
+
+    def poll(self):
+        finished, self.finished = self.finished, []
+        return finished
+
+
+class KnownFlakyTests(unittest.TestCase):
+    def run_harnesses(self, scripts, flaky, rounds=None):
+        executor = FakeExecutor()
+        state = {"harnesses": {name: {"status": "pass", "oracle_reuse": True} for name in scripts}}
+        with tempfile.TemporaryDirectory() as tmp, mock.patch.multiple(parity, STATE_DIR=Path(tmp), SHARED=Path(tmp)), \
+                mock.patch.object(parity, "save_state"), mock.patch.object(parity, "time") as clock:
+            clock.monotonic.return_value = 0.0
+            results, _ = parity.run(scripts, state, None, "env", [executor], True, rounds, flaky)
+        return results, executor.started
+
+    def test_a_known_flaky_failure_runs_once_more_from_scratch_and_says_so(self):
+        results, started = self.run_harnesses({"dedicated_server": ["fail", "pass"]}, {"dedicated_server": "timer"})
+        self.assertEqual(results["dedicated_server"]["status"], "pass")
+        self.assertEqual(results["dedicated_server"]["retried"], "known flaky")
+        # The first run reused oracle results; a known flaky harness doesn't lose that by flaking.
+        self.assertTrue(results["dedicated_server"]["oracle_reuse"])
+        self.assertEqual(started, [("dedicated_server", True), ("dedicated_server", False)])
+
+    def test_only_once(self):
+        results, started = self.run_harnesses({"dedicated_server": ["fail", "fail"]}, {"dedicated_server": "timer"})
+        self.assertEqual(results["dedicated_server"]["status"], "fail")
+        self.assertEqual(len(started), 2)
+
+    def test_other_harnesses_keep_only_the_reused_oracle_retry(self):
+        results, started = self.run_harnesses({"food": ["fail", "pass"]}, {"dedicated_server": "timer"})
+        self.assertEqual((results["food"]["status"], results["food"]["retried"]), ("pass", "reused oracle results"))
+        self.assertEqual(started, [("food", True), ("food", False)])
+        self.assertFalse(results["food"]["oracle_reuse"])
+
+    def test_repeated_runs_get_no_retry(self):
+        results, started = self.run_harnesses({"dedicated_server": ["pass", "fail"]}, {"dedicated_server": "timer"},
+                                              rounds={"dedicated_server": 2})
+        self.assertEqual((results["dedicated_server"]["status"], len(started)), ("fail", 2))
+
+    def test_retries_reach_the_job_summary(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            summary = Path(tmp) / "summary.md"
+            with mock.patch.dict(os.environ, {"GITHUB_STEP_SUMMARY": str(summary)}), \
+                    mock.patch("builtins.print"):
+                parity.report_retries({"dedicated_server": {"status": "pass", "retried": "known flaky"},
+                                       "food": {"status": "pass"}}, {"dedicated_server": "timer"})
+            text = summary.read_text()
+        self.assertIn("RETRIED dedicated_server: failed, then passed on its one retry (known flaky: timer", text)
+        self.assertNotIn("food", text)
+
+    def test_the_known_flaky_list_has_a_reason_per_harness(self):
+        flaky = parity.known_flaky(parity.host_config())
+        self.assertTrue(all(isinstance(reason, str) and len(reason) > 20 for reason in flaky.values()))
+        self.assertTrue(set(flaky) <= {parity.base_name(name) for name in parity.harnesses()})
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/parity.py b/tools/parity.py
index dbff8c146..a5f7f2db1 100644
--- a/tools/parity.py
+++ b/tools/parity.py
@@ -26,6 +26,11 @@ change costs only the Rust side. A harness that fails while reusing oracle
 results is rerun fresh, and stops reusing them if it then passes. --all and
 --fresh never reuse them.
 
+A harness listed in parity_hosts.json's "known_flaky" (each with its reason)
+that fails runs once more from scratch instead, and a pass then counts. Every
+retry is printed as a RETRIED line in the summary and in the CI job's summary.
+Fix the cause, then take the harness off the list: nothing else gets this retry.
+
 Harness probes build into .local/parity-target with release optimisations but
 without LTO and with 16 codegen units (`PROFILE` below), which builds in
 seconds instead of minutes. Rust does not let those settings change results:
@@ -1014,11 +1019,26 @@ def harness_of(label):
     return label.split("~")[0]
 
 
-def run(selected, state, hasher, environment_digest, executors, reuse_oracles, rounds=None):
+def keep_first_log(label):
+    """Move a harness's log aside before its retry writes a new one; returns where it went."""
+    log = STATE_DIR / "logs" / f"{label}.log"
+    kept = log.with_name(f"{label}.first-run.log")
+    try:
+        log.replace(kept)
+    except OSError:
+        return log  # a remote host's run: its log stays on that machine
+    return kept
+
+
+def run(selected, state, hasher, environment_digest, executors, reuse_oracles, rounds=None, known_flaky=None):
     """Run the selected harnesses on the executors. rounds: how many times each must run (default once); its runs
-    must agree, and a harness that both passes and fails is reported as flaky and recorded as failing."""
+    must agree, and a harness that both passes and fails is reported as flaky and recorded as failing.
+    known_flaky ({name: reason}, tools/parity_hosts.json): a harness listed there that fails its single round runs
+    once more, from scratch; its record keeps `retried` (the first run's log is kept beside its own)."""
     records = state["harnesses"]
     rounds = rounds or {}
+    known_flaky = known_flaky or {}
+    second_chance = set()  # known flaky harnesses that already failed once in this run
     # Longest first, so the slow harnesses don't start last; a harness's later rounds after its first.
     queue = sorted((name if index == 1 else f"{name}~{index}" for name in selected for index in range(1, rounds.get(name, 1) + 1)),
                    key=lambda label: (-records.get(harness_of(label), {}).get("seconds", 1e9), label))
@@ -1041,7 +1061,9 @@ def run(selected, state, hasher, environment_digest, executors, reuse_oracles, r
                 if pick is None:
                     break
                 name = harness_of(pick)
-                reuse = reuse_oracles and records.get(name, {}).get("oracle_reuse", True) and pick not in retried
+                # A retry runs the oracle again too: it may be the side that failed (mob_ai's heap).
+                reuse = reuse_oracles and records.get(name, {}).get("oracle_reuse", True) and pick not in retried \
+                    and name not in second_chance
                 if not executor.start(pick, selected[name], reuse, records.get(name, {}).get("peak_bytes", DEFAULT_MEMORY),
                                       SHARDS.get(name)):
                     break
@@ -1066,9 +1088,12 @@ def run(selected, state, hasher, environment_digest, executors, reuse_oracles, r
                 queue.insert(0, label)
                 continue
             passed = record["status"] == "pass"
-            if not passed and reused and label == name and records.get(name, {}).get("status") != "fail":
+            flaky_retry = rounds.get(name, 1) == 1 and base_name(name) in known_flaky
+            if not passed and reused and label == name and records.get(name, {}).get("status") != "fail" \
+                    and not flaky_retry:
                 # A new failure might come from a reused oracle result: run it again from scratch. Later rounds reuse
-                # what the first just validated, so their failures count (a flaky harness).
+                # what the first just validated, so their failures count (a flaky harness). A known flaky harness
+                # gets its own retry below instead, which keeps reusing oracle results afterwards.
                 retried.add(label)
                 queue.insert(0, label)
                 print(f"retry {label} without reused oracle results", flush=True)
@@ -1086,8 +1111,19 @@ def run(selected, state, hasher, environment_digest, executors, reuse_oracles, r
             if len(done[name]) < rounds.get(name, 1):
                 continue
             runs = done.pop(name)
+            if runs[0]["status"] != "pass" and flaky_retry and name not in second_chance:
+                second_chance.add(name)
+                first_log = keep_first_log(label)
+                print(f"RETRIED {name}: failed, and it is a known flaky harness ({known_flaky[base_name(name)]}): "
+                      f"running it once more (first run's log: {first_log})", flush=True)
+                queue.insert(0, label)
+                continue
             record = dict(runs[0], status="pass" if all(run["status"] == "pass" for run in runs) else "fail",
                           rounds=len(runs))
+            if name in second_chance:
+                record["retried"] = "known flaky"
+            elif label in retried:
+                record["retried"] = "reused oracle results"
             if len({run["status"] for run in runs}) > 1:
                 record["flaky"] = [run["status"] for run in runs]
                 print(f"FLAKY {name}: {', '.join(record['flaky'])} in {len(runs)} runs", flush=True)
@@ -1309,12 +1345,36 @@ def platform_skips(config):
     return dict(config.get("linux_only", {}))
 
 
+def known_flaky(config):
+    """Harnesses tools/parity_hosts.json lists as failing now and then for a cause not fixed yet: one that fails runs
+    once more, and passing then counts, reported as RETRIED. {name: reason}"""
+    return dict(config.get("known_flaky", {}))
+
+
 def named_only(config):
     """Harnesses tools/parity_hosts.json keeps out of every automatic selection (--changed, --failed, the default,
     --flake-check): they run only when named or with --all, the nightly audit. {name: reason}"""
     return dict(config.get("named_only", {}))
 
 
+def report_retries(results, flaky):
+    """Say loudly which harnesses needed their one retry (a known flaky one, or one that failed with reused oracle
+    results), here and in the CI job's summary: a pass on the retry counts, so this is where flakes stay visible."""
+    def why(name, record):
+        if record["retried"] == "known flaky":
+            return (f"known flaky: {flaky.get(base_name(name), '?')}; first run's log: "
+                    f"{STATE_DIR / 'logs' / (name + '.first-run.log')}")
+        return "its first run reused oracle results; it no longer reuses them" if record["status"] == "pass" else \
+            "its first run reused oracle results"
+    lines = [f"RETRIED {name}: failed, then {'passed' if record['status'] == 'pass' else 'failed again'} on its one "
+             f"retry ({why(name, record)})" for name, record in sorted(results.items()) if record.get("retried")]
+    for line in lines:
+        print(line, flush=True)
+    if lines and os.environ.get("GITHUB_STEP_SUMMARY"):
+        with open(os.environ["GITHUB_STEP_SUMMARY"], "a", encoding="utf-8") as summary:
+            summary.write("### Harnesses that failed once, then ran again\n" + "".join(f"- {line}\n" for line in lines))
+
+
 def finished_run(failed):
     """Record that this run completed, for tools/gate.py: a crashed runner never writes it."""
     STATE_DIR.mkdir(parents=True, exist_ok=True)
@@ -1463,7 +1523,8 @@ def main():
         reuse_oracles = not (args.fresh or args.all)
         executors = [*remotes, LocalExecutor(jobs, int(memory_available() * 0.75), args.timeout,
                                              REMOTE_LOCAL_PEAK if remotes and args.jobs is None else None)]
-        results, elapsed = run(selected, state, hasher, environment_key(hasher), executors, reuse_oracles, rounds)
+        results, elapsed = run(selected, state, hasher, environment_key(hasher), executors, reuse_oracles, rounds,
+                               known_flaky(config))
     finally:
         for executor in remotes:
             executor.stop()
@@ -1471,6 +1532,7 @@ def main():
     failed = sorted(name for name, record in results.items() if record["status"] != "pass")
     finished_run(failed)
     print(f"\n{len(results) - len(failed)} passed, {len(failed)} failed in {elapsed / 60:.1f} min.")
+    report_retries(results, known_flaky(config))
     for index, name in enumerate(failed):
         log = STATE_DIR / 'logs' / (name + '.log')
         print(f"  {name}: {log}")
diff --git a/tools/parity_hosts.json b/tools/parity_hosts.json
index b56106e4d..42b9a46fd 100644
--- a/tools/parity_hosts.json
+++ b/tools/parity_hosts.json
@@ -42,5 +42,10 @@
  "linux_only": {},
  "named_only": {
   "lan_integration": "the whole lan_e2e suite: ~40 min a run on a loaded runner, and single checks flake under load; run it by name, or tools/lan_e2e.py"
+ },
+ "known_flaky": {
+  "dedicated_server": "its Java client moves to the next step on a 1.5 s timer, not on the server's reply: under load a respawn's add_entity/update_attributes or entity_event 19 lands in the wrong step (failed, then passed at the same head, 10-26)",
+  "remote_fireball": "samples the fireball on the wall clock, so a slow host sees it in too few samples (desktop runner, 3 times on 10-26)",
+  "world_reopen": "counted 4 minecarts instead of 3 once on a loaded Mac mini runner, then passed at the same head (10-26)"
  }
 }

From f312aae7dbf6358093ce27906311c4416446c2e1 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:29:22 +0100
Subject: [PATCH 235/475] Name the potion, cloud or thrower in magic death
 messages

---
 crates/horizon-client/src/game/combat.rs      | 47 ++++++++++++-
 .../src/game/commands/world_cmds.rs           |  9 +++
 crates/horizon-client/src/game/creatures.rs   | 67 ++++++++++++++-----
 crates/horizon-client/src/game/dispenser.rs   |  2 +-
 crates/horizon-client/src/game/dragon.rs      |  5 +-
 crates/horizon-client/src/game/fangs.rs       | 13 +++-
 crates/horizon-client/src/game/potions.rs     | 48 +++++++++++--
 7 files changed, 164 insertions(+), 27 deletions(-)

diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs
index 6e1d5d82b..22d5c7d8f 100644
--- a/crates/horizon-client/src/game/combat.rs
+++ b/crates/horizon-client/src/game/combat.rs
@@ -1,7 +1,7 @@
 //! The player's `CombatTracker`: the damage taken lately, who dealt it and
 //! where the player fell from, turned into the vanilla death message.
 use super::{Game, chat::PLAYER_NAME};
-use horizon_client::{health::HealthEvent, motion::MotionEvent, text::Text};
+use horizon_client::{health::HealthEvent, lang, motion::MotionEvent, text::Text};
 
 struct Entry {
     damage_type: String,
@@ -10,6 +10,9 @@ struct Entry {
     fall_distance: f32,
     /// The causing entity: its id (for comparisons) and display name.
     attacker: Option<(u32, Text)>,
+    /// The direct entity's display name when no entity caused the damage
+    /// (`DamageSource.directEntity`: a potion with no thrower, a cloud).
+    direct: Option<Text>,
 }
 #[derive(Default)]
 pub(super) struct CombatTracker {
@@ -19,6 +22,8 @@ pub(super) struct CombatTracker {
     /// Attackers of damage dealt this tick, claimed by the matching
     /// `RecordedDamage` event.
     pending: Vec<(String, (u32, Text))>,
+    /// `pending` for a direct entity with no causing entity: only its name.
+    pending_direct: Vec<(String, Text)>,
     /// `LivingEntity.lastHurtByMob` and its timestamp (the kill credit).
     last_hurt_by: Option<((u32, Text), i64)>,
     /// The mob the player last hurt (`getLastHurtMob`) and when.
@@ -66,6 +71,14 @@ impl Game<'_> {
             .pending
             .push((damage_type.to_owned(), (id, name)));
     }
+    /// The `DamageSource.directEntity` of the next `damage_type` damage when
+    /// nothing caused it (a splash potion nobody threw): the death message
+    /// names it instead (`getLocalizedDeathMessage`). It is no kill credit.
+    pub(super) fn note_direct_entity(&mut self, damage_type: &str, name: Text) {
+        self.combat
+            .pending_direct
+            .push((damage_type.to_owned(), name));
+    }
     /// `LivingEntity.handleDamageEvent` for the player: the hurt sound of the
     /// source's `DamageEffects` (`Player.getHurtSound`).
     pub(super) fn player_hurt_sound(&mut self, sound: &str, at: [f64; 3]) {
@@ -94,6 +107,15 @@ impl Game<'_> {
                 .iter()
                 .position(|(t, _)| *t == name)
                 .map(|i| self.combat.pending.remove(i).1);
+            let direct = match attacker {
+                Some(_) => None,
+                None => self
+                    .combat
+                    .pending_direct
+                    .iter()
+                    .position(|(t, _)| *t == name)
+                    .map(|i| self.combat.pending_direct.remove(i).1),
+            };
             let (fall_location, fall_distance) = self.fall_location();
             let now = self.world.game_time;
             if let Some(a) = &attacker {
@@ -111,10 +133,12 @@ impl Game<'_> {
                 fall_location,
                 fall_distance,
                 attacker,
+                direct,
             });
             self.combat.last_damage = now;
         }
         self.combat.pending.clear();
+        self.combat.pending_direct.clear();
         self.combat.fall_before = self.player.as_ref().map_or(0.0, |p| p.fall_distance);
     }
     /// `FallLocation.getCurrentFallLocation` and the fall distance so far.
@@ -224,6 +248,7 @@ impl Game<'_> {
         let entries = std::mem::take(&mut self.combat.entries);
         let killing = entries.last().expect("checked above");
         let killer = killing.attacker.clone();
+        let direct = killing.direct.clone();
         if def.1 == "fall_variants"
             && let Some(knock) = knock.and_then(|i| entries.get(i))
         {
@@ -248,15 +273,33 @@ impl Game<'_> {
                 .append(Text::literal("]"));
             return Text::translate(&format!("{key}.message"), &[me, link]);
         }
+        // `getLocalizedDeathMessage`: the causing entity's name, or the
+        // direct entity's when nothing caused the damage.
         if let Some((_, name)) = killer {
             return Text::translate(&key, &[me, name]);
         }
+        if let Some(name) = direct {
+            return Text::translate(&key, &[me, name]);
+        }
         // getKillCredit: the last mob that hurt the player in the past 100 ticks.
         if let Some(((_, name), at)) = &self.combat.last_hurt_by
             && self.world.game_time - at <= 100
         {
             return Text::translate(&format!("{key}.player"), &[me, name.clone()]);
         }
-        Text::translate(&key, &[me])
+        killerless_message(&key, me)
     }
 }
+/// A death message with no entity behind it. One that names a second actor
+/// (`%2$s`) has nobody to name here, so it falls back to its plain sibling
+/// (`indirectMagic` to `magic`, anything else to `generic`) instead of
+/// showing the raw template.
+fn killerless_message(key: &str, me: Text) -> Text {
+    if key == "death.attack.indirectMagic" {
+        return Text::translate("death.attack.magic", &[me]);
+    }
+    if lang::get(key).contains("%2$s") {
+        return Text::translate("death.attack.generic", &[me]);
+    }
+    Text::translate(key, &[me])
+}
diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs
index 687eb3f88..15fbbe017 100644
--- a/crates/horizon-client/src/game/commands/world_cmds.rs
+++ b/crates/horizon-client/src/game/commands/world_cmds.rs
@@ -146,6 +146,15 @@ impl Game<'_> {
         };
         let hurt = match target {
             Target::Player => {
+                // `DamageSource(type, by)`: the death message names `by`.
+                match by {
+                    Some(Target::Mob(i)) => self.note_attacker(&ty, i),
+                    Some(t @ (Target::Player | Target::Guest(_))) => {
+                        let name = self.target_name(t);
+                        self.note_direct_entity(&ty, name);
+                    }
+                    _ => {}
+                }
                 if self.creative || self.spectator() {
                     false
                 } else if let Some(player) = self.player.as_mut() {
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index be8480c27..e5d7660da 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -18,6 +18,7 @@ use horizon_client::{
         spawning::{self, BiomeFacts},
     },
     projectiles::{Hit, Projectile, ProjectileKind, ProjectileWorld},
+    text::Text,
 };
 use horizon_core::{
     geometry::{Aabb, Vec3, traverse_blocks},
@@ -1546,11 +1547,33 @@ impl Game<'_> {
     pub(super) fn mob_hits_player_kind(&mut self, amount: f32, from: [f64; 3], kind: &str) {
         self.mob_hits_player(amount, from, kind);
     }
+    /// Damage whose causing mob is known (`cause`, or none): not guessed
+    /// from the mob nearest to `from`.
+    pub(super) fn mob_hits_player_caused(
+        &mut self,
+        amount: f32,
+        from: [f64; 3],
+        kind: &str,
+        cause: Option<u32>,
+    ) {
+        self.hit_player(amount, from, kind, Some(cause));
+    }
     pub(super) fn mob_hits_player(
         &mut self,
         amount: f32,
         from: [f64; 3],
         damage_type: &str,
+    ) -> bool {
+        self.hit_player(amount, from, damage_type, None)
+    }
+    /// `known_cause` is the source's causing mob when the caller knows it
+    /// (`Some(None)`: none); `None` takes the mob nearest to `from`.
+    fn hit_player(
+        &mut self,
+        amount: f32,
+        from: [f64; 3],
+        damage_type: &str,
+        known_cause: Option<Option<u32>>,
     ) -> bool {
         // ServerPlayer.canHarmPlayer refused another player's projectile.
         if self.creative || self.combat.refuse_player_hit {
@@ -1566,20 +1589,22 @@ impl Game<'_> {
         let blocking = self.player_blocking(Some(from), damage_type, false);
         let raised = blocking.is_some();
         // Melee: the attacker stands at `from` (another player's hit has no mob behind it).
-        let attacker = (!projectile && damage_type != "minecraft:player_attack")
-            .then(|| {
-                self.mobs
-                    .iter()
-                    .filter(|m| m.alive())
-                    .min_by(|a, b| {
-                        let d = |m: &horizon_client::mobs::Mob| {
-                            (m.position.x - from[0]).powi(2) + (m.position.z - from[2]).powi(2)
-                        };
-                        d(a).total_cmp(&d(b))
-                    })
-                    .map(|m| m.id)
-            })
-            .flatten();
+        let attacker = known_cause.unwrap_or_else(|| {
+            (!projectile && damage_type != "minecraft:player_attack")
+                .then(|| {
+                    self.mobs
+                        .iter()
+                        .filter(|m| m.alive())
+                        .min_by(|a, b| {
+                            let d = |m: &horizon_client::mobs::Mob| {
+                                (m.position.x - from[0]).powi(2) + (m.position.z - from[2]).powi(2)
+                            };
+                            d(a).total_cmp(&d(b))
+                        })
+                        .map(|m| m.id)
+                })
+                .flatten()
+        });
         // The causing entity for the death message.
         let owner = self.combat.projectile_owner.take();
         if let Some(a) = attacker.or(owner) {
@@ -2402,8 +2427,18 @@ impl Game<'_> {
                     if d2 < 16.0 && !self.creative {
                         let scale = 1.0 - d2.sqrt() / 4.0;
                         let t = (f64::from(*ticks) * scale + 0.5) as i32;
-                        if let Some(owner) = self.combat.projectile_owner {
-                            self.note_attacker("minecraft:indirect_magic", owner);
+                        // indirectMagic(potion, owner): the thrower, or the
+                        // potion itself when it has none.
+                        let owner = self
+                            .combat
+                            .projectile_owner
+                            .filter(|id| self.mob_display_name(*id).is_some());
+                        match owner {
+                            Some(owner) => self.note_attacker("minecraft:indirect_magic", owner),
+                            None => self.note_direct_entity(
+                                "minecraft:indirect_magic",
+                                Text::translate("entity.minecraft.splash_potion", &[]),
+                            ),
                         }
                         match *effect {
                             "minecraft:instant_damage" => self.hurt_player_by(
diff --git a/crates/horizon-client/src/game/dispenser.rs b/crates/horizon-client/src/game/dispenser.rs
index 61725c6ab..f902f1c05 100644
--- a/crates/horizon-client/src/game/dispenser.rs
+++ b/crates/horizon-client/src/game/dispenser.rs
@@ -982,7 +982,7 @@ impl Game<'_> {
             | "minecraft:lingering_potion" => {
                 let mut shot = Projectile::new(ProjectileKind::Snowball, at, None);
                 shot.shoot(&mut own, dir, power, uncertainty);
-                self.launch_thrown(one, at, shot.velocity);
+                self.launch_thrown(one, at, shot.velocity, None);
             }
             "minecraft:firework_rocket" => {
                 let mut shot = Projectile::new(ProjectileKind::Snowball, at, None);
diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index fff03ef1c..2338c14f8 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -2157,11 +2157,14 @@ impl Game<'_> {
     }
     /// Damage from the dragon, which is its causing entity
     /// (`DamageSources.mobAttack(dragon)`, `indirectMagic(cloud, dragon)`): the
-    /// death message names it.
+    /// death message names it, or the cloud once the dragon is gone.
     fn dragon_hurts_player(&mut self, damage_type: &str, amount: f32) {
         if let Some(id) = self.dragon.as_ref().map(|d| d.id) {
             let name = Text::translate("entity.minecraft.ender_dragon", &[]);
             self.note_named_attacker(damage_type, id, name);
+        } else if damage_type == "minecraft:indirect_magic" {
+            let name = Text::translate("entity.minecraft.area_effect_cloud", &[]);
+            self.note_direct_entity(damage_type, name);
         }
         self.hurt_player_by(damage_type, amount);
     }
diff --git a/crates/horizon-client/src/game/fangs.rs b/crates/horizon-client/src/game/fangs.rs
index aed692649..2f7abdfd4 100644
--- a/crates/horizon-client/src/game/fangs.rs
+++ b/crates/horizon-client/src/game/fangs.rs
@@ -71,12 +71,23 @@ impl Game<'_> {
         let b = horizon_core::geometry::Aabb::new(lo, hi);
         // Every player in the box, the server's players too.
         let pos = f.pos;
+        // `EvokerFangs.dealDamageTo`: indirectMagic(fangs, owner) while the
+        // owner lives, plain magic (nobody to name) once it is gone.
+        let owner = self
+            .mobs
+            .iter()
+            .any(|m| m.id == f.owner && m.alive())
+            .then_some(f.owner);
         let bite = move |g: &mut Self| {
             if let Some(p) = g.player_view()
                 && p.alive
                 && p.bounds.intersects(b)
             {
-                g.mob_hits_player_kind(6.0, pos, "minecraft:indirect_magic");
+                let kind = match owner {
+                    Some(_) => "minecraft:indirect_magic",
+                    None => "minecraft:magic",
+                };
+                g.mob_hits_player_caused(6.0, pos, kind, owner);
             }
         };
         bite(self);
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index 2ccfd4116..a91c550ad 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -12,6 +12,7 @@ use horizon_client::{
     hud_layout, hud_overlays, inventory_effects,
     items::ItemStack,
     mesher::Vertex,
+    text::Text,
 };
 use horizon_core::{geometry::Vec3, random::RandomSource};
 
@@ -26,6 +27,9 @@ pub(super) struct ThrownPotion {
     position: Vec3,
     velocity: Vec3,
     age: u32,
+    /// `Projectile.getOwner`'s display name: the player who threw it (none
+    /// for a dispenser's).
+    owner: Option<Text>,
 }
 /// A mob's effect ids carry the `minecraft:` namespace.
 fn mob_effect_id(id: &str) -> Option<&'static str> {
@@ -47,7 +51,13 @@ fn mob_effect_id(id: &str) -> Option<&'static str> {
 impl Game<'_> {
     /// A splash potion, lingering potion or experience bottle in flight (the
     /// player's throws and dispensers both end up here).
-    pub(super) fn launch_thrown(&mut self, stack: ItemStack, position: Vec3, velocity: Vec3) {
+    pub(super) fn launch_thrown(
+        &mut self,
+        stack: ItemStack,
+        position: Vec3,
+        velocity: Vec3,
+        owner: Option<Text>,
+    ) {
         self.potions.thrown.push(ThrownPotion {
             id: 0,
             stack,
@@ -55,6 +65,7 @@ impl Game<'_> {
             position,
             velocity,
             age: 0,
+            owner,
         });
     }
 }
@@ -135,6 +146,7 @@ impl PotionState {
             position: at,
             velocity,
             age: 0,
+            owner: None,
         });
     }
     /// ThrowableItemProjectile.DATA_ITEM_STACK: the potion it shows.
@@ -237,6 +249,7 @@ impl Game<'_> {
                     },
                     Vec3::new(eye[0], eye[1] - 0.1, eye[2]),
                     v,
+                    Some(self.player_display_text()),
                 );
                 self.swing_arm();
                 self.consume_held();
@@ -548,15 +561,15 @@ impl Game<'_> {
                 }
             }
             if let Some(p) = hit {
-                landed.push((t.stack.clone(), p));
+                landed.push((t.stack.clone(), p, t.owner.clone()));
                 return false;
             }
             t.position = next;
             t.age < 1200 && t.position.y > -128.0
         });
         self.potions.thrown = thrown;
-        for (stack, at) in landed {
-            self.splash(&stack, at);
+        for (stack, at, owner) in landed {
+            self.splash(&stack, at, owner);
         }
     }
     /// `ThrowableProjectile.tick`'s `applyGravity` and `applyInertia`, which
@@ -664,6 +677,7 @@ impl Game<'_> {
         effects: &'static [(&'static str, i32, i32)],
         at: Vec3,
         scale: f64,
+        source: &Text,
     ) {
         if let Some(p) = self.player.as_ref() {
             let center = Vec3::new(
@@ -679,6 +693,18 @@ impl Game<'_> {
                     let instant = brewing::effect(id).is_some_and(|e| e.instant);
                     if instant {
                         if let Some(a) = horizon_client::effects::instant(id, *amp, intensity) {
+                            // HealOrHarmMobEffect.applyInstantaneousEffect with
+                            // a source: indirectMagic, not plain magic.
+                            let a = match a {
+                                EffectAction::Hurt("minecraft:magic", amount) => {
+                                    self.note_direct_entity(
+                                        "minecraft:indirect_magic",
+                                        source.clone(),
+                                    );
+                                    EffectAction::Hurt("minecraft:indirect_magic", amount)
+                                }
+                                a => a,
+                            };
                             self.apply_effect_action(a);
                         }
                     } else {
@@ -694,7 +720,7 @@ impl Game<'_> {
         }
     }
     /// `ThrownSplashPotion.onHitAsPotion` (lingering clouds apply as a weaker splash).
-    fn splash(&mut self, stack: &ItemStack, at: Vec3) {
+    fn splash(&mut self, stack: &ItemStack, at: Vec3, owner: Option<Text>) {
         if &*stack.item == "minecraft:experience_bottle" {
             // ThrownExperienceBottle.onHit: the water-coloured splash (level
             // event 2002) and 3 to 11 experience.
@@ -755,7 +781,17 @@ impl Game<'_> {
         };
         // Every player in range (`ThrownSplashPotion.applySplash` over
         // `LivingEntity`s, the players among them).
-        self.for_each_player(|g| g.splash_on_player(def.effects, at, scale));
+        // Instant damage is indirectMagic(potion or cloud, owner), which the
+        // death message names by the owner, else by the potion or cloud.
+        let source = owner.unwrap_or_else(|| {
+            let entity = if lingering {
+                "entity.minecraft.area_effect_cloud"
+            } else {
+                "entity.minecraft.splash_potion"
+            };
+            Text::translate(entity, &[])
+        });
+        self.for_each_player(|g| g.splash_on_player(def.effects, at, scale, &source));
         // Mobs take the instant effects (undead invert healing and harming).
         let undead = &self.res.stations().enchantments.entity_tags;
         let mut hits = Vec::new();

From 08cd05ed6eae200558f6f3fac3a24f2e6d0be181 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:30:05 +0100
Subject: [PATCH 236/475] Make the Entity Shadows option turn shadows off

---
 crates/horizon-client/src/game.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 671ba6cc9..5f25e215c 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -7212,7 +7212,12 @@ impl Game<'_> {
         self.see_through_vertices = see_through;
         // Entity shadows (EntityRenderer.extractShadow).
         self.mark_translucent_entity(out.len(), "minecraft:entity_shadow");
-        if let Some(sprite) = self.gui.atlas.sprites.get("misc/shadow").copied() {
+        let shadow_sprite = self
+            .settings
+            .entity_shadows
+            .then(|| self.gui.atlas.sprites.get("misc/shadow").copied())
+            .flatten();
+        if let Some(sprite) = shadow_sprite {
             let ambient = if self.dim == Dim::Nether { 0.1 } else { 0.0 };
             let darken = self.sky_darken();
             let a = alpha;

From f9b8b40a7dfd59ed5877c2333d8e43afcf8a6484 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:30:13 +0100
Subject: [PATCH 237/475] Show score components in /tellraw and /title

---
 .../src/game/commands/text_commands.rs        | 57 ++++++++++++++++++-
 1 file changed, 55 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/commands/text_commands.rs b/crates/horizon-client/src/game/commands/text_commands.rs
index dead07d71..a1ea4d673 100644
--- a/crates/horizon-client/src/game/commands/text_commands.rs
+++ b/crates/horizon-client/src/game/commands/text_commands.rs
@@ -14,10 +14,11 @@ impl Game<'_> {
             serde_json::from_str(json).map_err(|e| err("argument.component.invalid", &[&e]))?;
         // NbtContents.resolve: the path's values in the entity, block or
         // storage data, rich-styled (or plain, or interpreted), ", "-joined.
+        // ScoreContents.resolve: the holder's score in the objective.
         let nbt_values = std::cell::RefCell::new(Vec::new());
         {
             let mut collect = |o: &serde_json::Map<String, serde_json::Value>| {
-                if o.contains_key("nbt") {
+                if o.contains_key("nbt") || o.contains_key("score") {
                     nbt_values.borrow_mut().push(o.clone());
                 }
             };
@@ -40,7 +41,11 @@ impl Game<'_> {
         }
         let mut resolved: Vec<(serde_json::Map<String, serde_json::Value>, Text)> = Vec::new();
         for o in nbt_values.into_inner() {
-            let t = self.resolve_nbt_component(&o);
+            let t = if o.contains_key("score") {
+                self.resolve_score_component(&o)?
+            } else {
+                self.resolve_nbt_component(&o)
+            };
             resolved.push((o, t));
         }
         let mut resolve = |raw: &str| -> Text {
@@ -73,6 +78,54 @@ impl Game<'_> {
             },
         ))
     }
+    /// The text of a `score` component (ScoreContents.resolve): the named
+    /// holder's score, `*` being the player the command runs for.
+    fn resolve_score_component(
+        &mut self,
+        o: &serde_json::Map<String, serde_json::Value>,
+    ) -> R<Text> {
+        let score = o.get("score");
+        let field = |k: &str| score.and_then(|s| s.get(k)).and_then(|v| v.as_str());
+        let (name, objective) = (
+            field("name").unwrap_or(""),
+            field("objective").unwrap_or(""),
+        );
+        // findTargetName: a selector that matches one entity is that entity,
+        // one that matches none is just the name.
+        let mut reader = horizon_client::command::Reader::new(name);
+        let ty = horizon_client::command::args::ArgType::Entity {
+            single: false,
+            players: false,
+        };
+        let mut holder = name.to_owned();
+        if let Ok(Arg::Entity(sel)) = ty.parse(&mut reader, &self.ui.registries)
+            && !reader.can_read()
+        {
+            let found = self.select(&sel);
+            if found.len() > 1 {
+                return Err(err("argument.entity.toomany", &[]));
+            }
+            if let Some(t) = found.first().and_then(|t| self.holder_name(*t)) {
+                holder = t;
+            }
+        }
+        if holder == "*" {
+            holder = self.acting_player_name().to_owned();
+        }
+        let board = &self.score.board;
+        let (Some(objective), Some(score)) =
+            (board.objective(objective), board.score(&holder, objective))
+        else {
+            return Ok(Text::empty());
+        };
+        // numberFormatOrDefault(StyledFormat.NO_STYLE).
+        let format = (score.number_format.clone())
+            .or_else(|| objective.number_format.clone())
+            .unwrap_or(horizon_client::scoreboard::NumberFormat::Styled(
+                serde_json::json!({}),
+            ));
+        Ok(format.format(score.value))
+    }
     /// The text of an `nbt` component.
     fn resolve_nbt_component(&mut self, o: &serde_json::Map<String, serde_json::Value>) -> Text {
         use horizon_world::nbt::Tag;

From 82d2b61a4a5a1eb01030a0e8516eddb39d0587da Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:30:33 +0100
Subject: [PATCH 238/475] Swing a horse's tail now and then

---
 crates/horizon-client/src/game/remote.rs | 10 +++++++++
 crates/horizon-client/src/mobs/ai.rs     |  2 +-
 crates/horizon-client/src/mobs/equine.rs | 26 +++++++++++++++++++++++-
 3 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..5432713dc 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3507,6 +3507,16 @@ impl Game<'_> {
             if m.species() == horizon_client::mobs::Species::Rabbit {
                 horizon_client::mobs::rabbit::base_tick(m);
             }
+            if matches!(
+                m.species(),
+                horizon_client::mobs::Species::Horse
+                    | horizon_client::mobs::Species::Donkey
+                    | horizon_client::mobs::Species::Mule
+                    | horizon_client::mobs::Species::SkeletonHorse
+                    | horizon_client::mobs::Species::ZombieHorse
+            ) {
+                horizon_client::mobs::equine::tail_tick(m);
+            }
             if m.species() == horizon_client::mobs::Species::Creeper {
                 horizon_client::mobs::hostile::creeper_client_tick(m);
             }
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index f82117aee..10535971e 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -641,7 +641,7 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &
     }
     // AbstractHorse.aiStep: the tail swishes now and then (moveTail).
     if super::equine::is_equine(m.species()) {
-        let _ = m.random.next_int_bound(200);
+        super::equine::tail_tick(m);
     }
     // Monster.aiStep: updateNoActionTime (Raider: always +2).
     if is_monster(m.species())
diff --git a/crates/horizon-client/src/mobs/equine.rs b/crates/horizon-client/src/mobs/equine.rs
index 5bb5faf53..1155388fd 100644
--- a/crates/horizon-client/src/mobs/equine.rs
+++ b/crates/horizon-client/src/mobs/equine.rs
@@ -28,6 +28,8 @@ pub const MARKINGS: [&str; 5] = ["", "white", "whitefield", "whitedots", "blackd
 pub const EAT: usize = 0;
 pub const STAND: usize = 1;
 pub const MOUTH: usize = 2;
+/// `AbstractHorse.tailCounter`: client-side, it only drives the model.
+pub const TAIL: usize = 3;
 
 /// What a rider asks of its mount this tick.
 #[derive(Clone, Copy, Debug, Default)]
@@ -418,6 +420,20 @@ pub fn ridden_step(m: &mut Mob) {
         }
     }
 }
+/// `AbstractHorse.aiStep`'s `moveTail` (one in 200 ticks) and the counter's
+/// step in `tick` (it runs to 8, then stops). A client runs it on its own
+/// random, as vanilla's client-side `aiStep` does.
+pub fn tail_tick(m: &mut Mob) {
+    if m.random.next_int_bound(200).unwrap_or(1) == 0 {
+        m.anim.v[TAIL] = 1.0;
+    }
+    if m.anim.v[TAIL] > 0.0 {
+        m.anim.v[TAIL] += 1.0;
+        if m.anim.v[TAIL] > 8.0 {
+            m.anim.v[TAIL] = 0.0;
+        }
+    }
+}
 /// `AbstractHorse.aiStep` and `tick`: healing, grazing, the rear and the
 /// eating/standing/mouth animations.
 pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
@@ -603,7 +619,15 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
         t[1] += speed * age;
         t[2] += speed * 2.0 * age;
     }
-    p.yrot("tail", 0.0);
+    // animateTail: the tail swings while the counter runs.
+    p.yrot(
+        "tail",
+        if m.anim.v[TAIL] > 0.0 {
+            (s.age * 0.7).mcos()
+        } else {
+            0.0
+        },
+    );
     if baby && donkey {
         // BabyDonkeyModel overrides the state's pitch with -30 degrees and
         // sets the head parts again.

From 41ca489d4e066b9c0a82ff6df1e08b10b27f321b Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:31:14 +0100
Subject: [PATCH 239/475] Move /particle count 0 particles at speed times delta

---
 crates/horizon-client/src/game/commands/world_cmds.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs
index 687eb3f88..d58b477b0 100644
--- a/crates/horizon-client/src/game/commands/world_cmds.rs
+++ b/crates/horizon-client/src/game/commands/world_cmds.rs
@@ -605,8 +605,11 @@ impl Game<'_> {
         let reached = reached.len() as i32;
         if !local {
         } else if count <= 0 {
-            // No count: one particle with the delta as velocity.
-            self.particles.create(&options, pos, delta);
+            // handleParticleEvent, count 0: one particle, the speed times
+            // the delta as velocity (both sent as floats).
+            let speed = f64::from(speed);
+            self.particles
+                .create(&options, pos, delta.map(|d| speed * f64::from(d as f32)));
         } else {
             for _ in 0..count {
                 let r = self.particles.random();

From 041ecb7b7ab6cfef260341f73a95dc1ae720b5f5 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:31:16 +0100
Subject: [PATCH 240/475] Structures: load the template's block entity NBT into
 every container and sign

---
 crates/horizon-client/src/structure_blocks.rs | 34 +++++++++++--------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/crates/horizon-client/src/structure_blocks.rs b/crates/horizon-client/src/structure_blocks.rs
index 604cf7925..0c15bd1ad 100644
--- a/crates/horizon-client/src/structure_blocks.rs
+++ b/crates/horizon-client/src/structure_blocks.rs
@@ -185,23 +185,27 @@ fn text(nbt: &Compound, key: &str) -> Option<String> {
 
 /// The client block entity for one of a chunk's generated block entities,
 /// before a container's loot is unpacked: `StructureTemplate.placeInWorld`
-/// hands the template's block entity NBT to the level's block entity.
+/// hands the template's block entity NBT to `loadWithComponents`, which is
+/// what a chunk load does with a saved one.
 fn generated_block_entity(block: &str, nbt: &Compound) -> Option<BlockEntity> {
-    let mut entity = BlockEntity::for_block(block)?;
-    match &mut entity {
-        // MonsterRoomFeature and the structures' setEntityId.
-        BlockEntity::Spawner(s) => {
-            **s = crate::mobs::spawner::Spawner::load(&Tag::Compound(nbt.clone()));
-        }
-        BlockEntity::TrialSpawner(s) => {
-            **s = crate::mobs::trial_spawner::TrialSpawner::load(&Tag::Compound(nbt.clone()));
-        }
-        BlockEntity::Vault(v) => **v = crate::vault::Vault::load(&Tag::Compound(nbt.clone())),
-        // BannerBlockEntity.loadAdditional: the End cities' black triangles.
-        BlockEntity::Banner(b) => *b = crate::save::decode_banner(&Tag::Compound(nbt.clone())),
-        _ => {}
+    let fallback = BlockEntity::for_block(block)?;
+    let mut tag = nbt.clone();
+    // RandomizableContainer.tryLoadLootTable: with a table the items are not read.
+    if text(&tag, "LootTable").is_some() {
+        tag.remove(&JavaString::from("Items"));
     }
-    Some(entity)
+    // Programmatic block entities (and a template that saved none) carry no id.
+    if !tag.contains_key(&JavaString::from("id")) {
+        tag.insert("id".into(), Tag::String(fallback.id().into()));
+    }
+    for axis in ["x", "y", "z"] {
+        tag.insert(axis.into(), Tag::Int(0));
+    }
+    // A saved kind the client cannot decode keeps the block's own entity.
+    Some(
+        crate::save::decode_block_entity(&Tag::Compound(tag))
+            .map_or(fallback, |(_, entity)| entity),
+    )
 }
 
 /// Client block entities for the generated block entities of a chunk, and the

From 0e658e3e6249e132db5f2dc2add61593a7205480 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:31:21 +0100
Subject: [PATCH 241/475] Make drowned throw real tridents instead of arrows

---
 .../examples/probe/arrow_probe.rs             |  2 +
 crates/horizon-client/src/arrows.rs           | 51 ++++++++++-
 crates/horizon-client/src/game/commands.rs    |  3 +-
 crates/horizon-client/src/game/creatures.rs   | 89 +++++++++++++++++--
 .../horizon-client/src/game/lan_entities.rs   | 14 +++
 crates/horizon-client/src/mobs/undead.rs      | 27 +++---
 crates/horizon-client/src/projectiles.rs      | 16 ++--
 7 files changed, 171 insertions(+), 31 deletions(-)

diff --git a/crates/horizon-client/examples/probe/arrow_probe.rs b/crates/horizon-client/examples/probe/arrow_probe.rs
index f72e6276e..411561c4e 100644
--- a/crates/horizon-client/examples/probe/arrow_probe.rs
+++ b/crates/horizon-client/examples/probe/arrow_probe.rs
@@ -163,6 +163,8 @@ pub fn main() -> Result<()> {
                                     ArrowSound::HitGround => "hit",
                                     ArrowSound::Splash => "splash",
                                     ArrowSound::Extinguish => "extinguish",
+                                    ArrowSound::TridentHitGround => "trident_hit_ground",
+                                    ArrowSound::TridentHit => "trident_hit",
                                 },
                                 volume.to_bits(),
                                 pitch.to_bits()
diff --git a/crates/horizon-client/src/arrows.rs b/crates/horizon-client/src/arrows.rs
index f3c9c63bd..6d8dc528b 100644
--- a/crates/horizon-client/src/arrows.rs
+++ b/crates/horizon-client/src/arrows.rs
@@ -9,7 +9,7 @@ use crate::{
     collisions::SceneCollisions,
     mobs::Who,
     motion::{FluidResources, LAVA, WATER},
-    projectiles::{Hit, Projectile},
+    projectiles::{Hit, Projectile, ProjectileKind},
     world::World,
 };
 use horizon_core::{
@@ -132,6 +132,10 @@ pub enum ArrowSound {
     HitGround,
     /// `entity.generic.extinguish_fire`.
     Extinguish,
+    /// A thrown trident's `getDefaultHitGroundSoundEvent` (`item.trident.hit_ground`).
+    TridentHitGround,
+    /// `ThrownTrident.onHitEntity`'s `item.trident.hit`.
+    TridentHit,
 }
 /// What a burning arrow does to the block it hits (`onProjectileHit`).
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -169,6 +173,9 @@ pub struct ArrowState {
     pub was_eye_in_water: bool,
     pub first_tick: bool,
     pub has_been_shot: bool,
+    /// `ThrownTrident.dealtDamage`: it has hit an entity (or sat in a block
+    /// for over 4 ticks) and hits no more.
+    pub dealt_damage: bool,
     pub removed: bool,
     /// The arrow's own random (`Entity.random`).
     pub random: LegacyRandom,
@@ -211,6 +218,7 @@ impl ArrowState {
             was_eye_in_water: false,
             first_tick: true,
             has_been_shot: false,
+            dealt_damage: false,
             removed: false,
             random,
             events: Vec::new(),
@@ -451,12 +459,14 @@ pub fn finish_entity_hit(p: &mut Projectile, scene: &ArrowScene, outcome: Entity
     let Some(mut st) = p.arrow.take() else {
         return false;
     };
+    let trident = matches!(p.kind, ProjectileKind::Trident);
     let mut ticker = Ticker {
         p,
         st: &mut st,
         scene,
     };
     match outcome {
+        EntityHit::Hurt | EntityHit::Refused if trident => ticker.trident_bounce(),
         EntityHit::Hurt => {
             ticker.hit_sound();
             // A piercing arrow flies on (`getPierceLevel() <= 0` discards).
@@ -501,7 +511,16 @@ impl Ticker<'_, '_, '_, '_> {
                 p.z,
             ))
     }
+    /// Whether this is a `ThrownTrident` (`AbstractArrow` with its own water
+    /// inertia, sounds and hit).
+    fn trident(&self) -> bool {
+        matches!(self.p.kind, ProjectileKind::Trident)
+    }
     fn tick(&mut self, targets: &[(Who, Aabb)]) -> Hit {
+        // ThrownTrident.tick.
+        if self.trident() && self.st.in_ground_time > 4 {
+            self.st.dealt_damage = true;
+        }
         let physics = !self.st.no_physics;
         let movement = self.p.velocity;
         let block_pos = self.block_position();
@@ -549,8 +568,9 @@ impl Ticker<'_, '_, '_, '_> {
         self.st.in_ground_time = 0;
         let original = self.position();
         if self.st.was_touching_water {
-            // getWaterInertia, then the bubbles behind it.
-            self.p.velocity = self.p.velocity.scale(f64::from(0.6f32));
+            // getWaterInertia (0.99 for a trident), then the bubbles behind it.
+            let inertia = if self.trident() { 0.99f32 } else { 0.6f32 };
+            self.p.velocity = self.p.velocity.scale(f64::from(inertia));
             let v = self.p.velocity;
             for _ in 0..4 {
                 self.st.events.push(ArrowEvent::Particle {
@@ -687,6 +707,8 @@ impl Ticker<'_, '_, '_, '_> {
             .expand_towards(self.p.velocity)
             .inflate(Vec3::new(1.0, 1.0, 1.0));
         let mut best: Option<(Who, Vec3, f64)> = None;
+        // ThrownTrident.findHitEntity: none once it has dealt damage.
+        let targets = if self.st.dealt_damage { &[] } else { targets };
         for (who, b) in targets {
             if Some(*who) == self.p.owner && !self.p.left_owner || !b.intersects(area) {
                 continue;
@@ -757,12 +779,33 @@ impl Ticker<'_, '_, '_, '_> {
     /// `playSound(soundEvent, 1, 1.2 / (random * 0.2 + 0.9))`.
     fn hit_sound(&mut self) {
         let pitch = 1.2 / (self.st.random.next_float() * 0.2 + 0.9);
+        let sound = if self.trident() {
+            ArrowSound::TridentHitGround
+        } else {
+            ArrowSound::HitGround
+        };
         self.st.events.push(ArrowEvent::Sound {
-            sound: ArrowSound::HitGround,
+            sound,
             volume: 1.0,
             pitch,
         });
     }
+    /// `ThrownTrident.onHitEntity` after the hurt, whether it landed or not:
+    /// the hit sound, then `deflect(REVERSE, ..., (0.02, 0.2, 0.02))`. The
+    /// trident keeps flying (it has dealt its damage) and falls.
+    fn trident_bounce(&mut self) {
+        self.st.dealt_damage = true;
+        self.st.events.push(ArrowEvent::Sound {
+            sound: ArrowSound::TridentHit,
+            volume: 1.0,
+            pitch: 1.0,
+        });
+        // ProjectileDeflection.REVERSE.
+        let rotation = 170.0 + self.st.random.next_float() * 20.0;
+        let v = self.p.velocity;
+        self.p.velocity = Vec3::new(v.x * (-0.02 * 0.5), v.y * (-0.2 * 0.5), v.z * (-0.02 * 0.5));
+        self.p.yaw += rotation;
+    }
     /// `onHitEntity` when the entity took no damage: `deflect(REVERSE, 0.2)`,
     /// a half turn give or take ten degrees at a tenth of the speed; one
     /// left almost still drops its pickup (ALLOWED) and is discarded.
diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs
index 22041c3b2..f308cfec6 100644
--- a/crates/horizon-client/src/game/commands.rs
+++ b/crates/horizon-client/src/game/commands.rs
@@ -541,8 +541,7 @@ impl Game<'_> {
                     .enumerate()
                     // The kinds /data can write (entity_nbt).
                     .filter(|(_, p)| {
-                        p.arrow.is_some()
-                            || matches!(p.kind, K::LargeFireball { .. } | K::SmallFireball)
+                        p.is_arrow() || matches!(p.kind, K::LargeFireball { .. } | K::SmallFireball)
                     })
                     .map(|(i, _)| Target::Projectile(i)),
             );
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 4c5726757..b3618af5c 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1946,6 +1946,23 @@ impl Game<'_> {
             None => self.projectile_hit(p, hit),
         }
     }
+    /// What an arrow or a thrown trident hits an entity for
+    /// (`AbstractArrow.onHitEntity`, `ThrownTrident.onHitEntity`): a trident's
+    /// 8, plus Impaling on aquatic `victim`s.
+    fn shot_damage(&mut self, shot: &mut Projectile, victim: Option<u32>) -> f32 {
+        if !matches!(shot.kind, ProjectileKind::Trident) {
+            return arrow_damage(shot, &mut self.world.random) + shot.bonus.damage;
+        }
+        let impaling = shot
+            .arrow
+            .as_ref()
+            .map_or(0, |a| a.pickup_item.enchantment_level("minecraft:impaling"))
+            as f32;
+        let aquatic = victim
+            .and_then(|id| self.mobs.iter().find(|m| m.id == id))
+            .is_some_and(|m| m.kind.flags.aquatic_swimmer || m.kind.flags.breathes_water);
+        8.0 + if aquatic { 2.5 * impaling } else { 0.0 }
+    }
     /// What an arrow's tick asked for: its particles and sounds.
     fn arrow_event(&mut self, at: Vec3, event: horizon_client::arrows::ArrowEvent) {
         use horizon_client::arrows::{ArrowEvent, ArrowParticle, ArrowSound, BlockReaction};
@@ -1974,6 +1991,8 @@ impl Game<'_> {
                     ArrowSound::Splash => "minecraft:entity.generic.splash",
                     ArrowSound::HitGround => "minecraft:entity.arrow.hit",
                     ArrowSound::Extinguish => "minecraft:entity.generic.extinguish_fire",
+                    ArrowSound::TridentHitGround => "minecraft:item.trident.hit_ground",
+                    ArrowSound::TridentHit => "minecraft:item.trident.hit",
                 };
                 self.audio
                     .play(name, Some([at.x, at.y, at.z]), volume, pitch);
@@ -2123,11 +2142,11 @@ impl Game<'_> {
             && id >= super::dragon::SPECIAL
         {
             let by_player = p.owner == Some(Who::Player);
-            if let ProjectileKind::Arrow { .. } = p.kind {
+            if p.arrow.is_some() {
                 // AbstractArrow.onHitEntity: spent if the part or crystal took
                 // it, else turned back (a perched dragon sets it alight first).
                 let mut arrow = p.clone();
-                let amount = arrow_damage(&mut arrow, &mut self.world.random) + p.bonus.damage;
+                let amount = self.shot_damage(&mut arrow, None);
                 let outcome = match self.hit_special(id, amount, by_player, true) {
                     super::dragon::Hurt::Landed { .. } => EntityHit::Hurt,
                     super::dragon::Hurt::Refused => EntityHit::Refused,
@@ -2148,17 +2167,15 @@ impl Game<'_> {
             self.hit_special(id, amount, by_player, false);
             return Ok(());
         }
-        if let (
-            ProjectileKind::Arrow { .. },
-            Hit::Entity {
+        if p.arrow.is_some()
+            && let Hit::Entity {
                 who: Who::Mob(id), ..
-            },
-        ) = (&p.kind, hit)
+            } = hit
             && let Some(i) = self.carts.iter().position(|c| c.id == id)
         {
             // AbstractArrow.onHitEntity on a minecart.
             let mut arrow = p.clone();
-            let amount = arrow_damage(&mut arrow, &mut self.world.random) + p.bonus.damage;
+            let amount = self.shot_damage(&mut arrow, None);
             let burning = p.arrow.as_ref().is_some_and(|a| a.on_fire());
             let creative = p.owner == Some(Who::Player) && self.creative;
             self.arrow_hits_cart(i, amount, p.velocity, burning, creative);
@@ -2169,7 +2186,7 @@ impl Game<'_> {
         // Projectile.onHit: the landing is heard.
         self.projectile_event("minecraft:projectile_land", p.owner, atp);
         let source_kind = match p.kind {
-            ProjectileKind::Arrow { .. } => DamageKind::Arrow,
+            ProjectileKind::Arrow { .. } | ProjectileKind::Trident => DamageKind::Arrow,
             ProjectileKind::SmallFireball | ProjectileKind::LargeFireball { .. } => {
                 DamageKind::Fireball
             }
@@ -2181,6 +2198,36 @@ impl Game<'_> {
             from: Some([p.previous.x, p.previous.y, p.previous.z]),
         };
         match (&p.kind, hit) {
+            // ThrownTrident.onHitEntity: 8 damage (Impaling on aquatic mobs),
+            // dealt whether or not the hurt lands, then it bounces off.
+            (ProjectileKind::Trident, Hit::Entity { who, .. }) => {
+                let mut trident = p.clone();
+                let victim = match who {
+                    Who::Mob(id) => Some(id),
+                    Who::Player => None,
+                };
+                let amount = self.shot_damage(&mut trident, victim);
+                let hurt = match who {
+                    Who::Player => self.mob_hits_player(
+                        amount,
+                        [p.previous.x, p.previous.y, p.previous.z],
+                        "minecraft:trident",
+                    ),
+                    Who::Mob(id) => self
+                        .mobs
+                        .iter_mut()
+                        .find(|m| m.id == id)
+                        .is_some_and(|m| m.damage(amount, source)),
+                };
+                let outcome = if hurt {
+                    EntityHit::Hurt
+                } else {
+                    EntityHit::Refused
+                };
+                self.finish_arrow_hit(trident, outcome);
+            }
+            // AbstractArrow.onHitBlock plays its sound itself (ArrowEvent).
+            (ProjectileKind::Trident, Hit::Block { .. }) => {}
             (ProjectileKind::Arrow { effect, .. }, Hit::Entity { who, .. }) => {
                 let mut arrow = p.clone();
                 let amount = arrow_damage(&mut arrow, &mut self.world.random) + p.bonus.damage;
@@ -3305,6 +3352,30 @@ impl Game<'_> {
                 }
                 continue;
             }
+            // ThrownTridentRenderer.
+            if matches!(a.kind, ProjectileKind::Trident) {
+                let Some(model) = self.trident_model.as_ref() else {
+                    continue;
+                };
+                let Some(r) = atlas.sprites.get("entity/trident/trident").copied() else {
+                    continue;
+                };
+                let m = glam::Mat4::from_translation(c)
+                    * glam::Mat4::from_rotation_y((a.yaw - 90.0).to_radians())
+                    * glam::Mat4::from_rotation_z((a.pitch + 90.0).to_radians());
+                let poses = horizon_client::mobs::anim::Poses::new(model);
+                horizon_client::mobs::render::draw(
+                    model,
+                    m,
+                    &poses,
+                    [r.u0, r.v0, r.u1, r.v1],
+                    0xFFFF_FFFF,
+                    packed,
+                    0,
+                    out,
+                );
+                continue;
+            }
             // WindChargeRenderer.
             if matches!(
                 a.kind,
diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs
index 529666590..b41dc5c23 100644
--- a/crates/horizon-client/src/game/lan_entities.rs
+++ b/crates/horizon-client/src/game/lan_entities.rs
@@ -354,6 +354,20 @@ impl Game<'_> {
                         a.is_some_and(|a| a.in_ground) || p.stuck,
                     ));
                 }
+                // ThrownTrident.ID_LOYALTY (none for a mob's) and ID_FOIL, on
+                // AbstractArrow's flags.
+                K::Trident => {
+                    let a = p.arrow.as_deref();
+                    e.meta.extend(arrow_meta(
+                        false,
+                        a.is_some_and(|a| a.no_physics),
+                        0,
+                        a.is_some_and(|a| a.in_ground) || p.stuck,
+                    ));
+                    if a.is_some_and(|a| a.pickup_item.has_any_enchantments()) {
+                        e.meta.push((12, serializer::BOOLEAN, Value::Bool(true)));
+                    }
+                }
                 // WitherSkull.DATA_DANGEROUS.
                 K::WitherSkull { dangerous: true } => {
                     e.meta.push((8, serializer::BOOLEAN, Value::Bool(true)));
diff --git a/crates/horizon-client/src/mobs/undead.rs b/crates/horizon-client/src/mobs/undead.rs
index bbc903288..3c3a48bd5 100644
--- a/crates/horizon-client/src/mobs/undead.rs
+++ b/crates/horizon-client/src/mobs/undead.rs
@@ -228,8 +228,10 @@ pub fn drowned_travel(
     m.velocity = Vec3::new(m.velocity.x * 0.9, m.velocity.y * 0.9, m.velocity.z * 0.9);
     true
 }
-/// The trident throw of `Drowned.performRangedAttack`, until thrown tridents
-/// exist: an arrow-like shot with the trident's damage.
+/// The trident throw of `Drowned.performRangedAttack`: a `ThrownTrident` of
+/// the held trident (a plain one when it holds none), owned by the drowned,
+/// which cannot be picked up and does not return (`AbstractArrow` constructor:
+/// only a player's projectile is `Pickup.ALLOWED`).
 fn drowned_throw(m: &mut Mob, who: Who, _power: f32, cx: &mut Cx) {
     let Some(t) = cx.w.target_info(who) else {
         return;
@@ -239,15 +241,18 @@ fn drowned_throw(m: &mut Mob, who: Who, _power: f32, cx: &mut Cx) {
     let yd = t.position.y + (t.bounds.max_position().y - t.bounds.min_position().y) / 3.0 - start.y;
     let zd = t.position.z - m.position.z;
     let dist = (xd * xd + zd * zd).sqrt();
-    let mut p = Projectile::new(
-        ProjectileKind::Arrow {
-            base_damage: 8.0,
-            critical: false,
-            effect: None,
-        },
-        start,
-        Some(Who::Mob(m.id)),
-    );
+    let mut trident = crate::items::ItemStack::new("minecraft:trident", 1);
+    if m.extra.main_hand.as_deref() == Some("minecraft:trident")
+        && let Some(g) = super::gear::gear(m)
+    {
+        for (e, l) in &g.slots[super::gear::MAIN] {
+            trident.enchant(e, *l);
+        }
+    }
+    let mut p = Projectile::new(ProjectileKind::Trident, start, Some(Who::Mob(m.id)));
+    if let Some(a) = p.arrow.as_mut() {
+        a.set_item(&trident);
+    }
     p.shoot(
         &mut crate::projectiles::own_random(m),
         [xd, yd + dist * f64::from(0.2_f32), zd],
diff --git a/crates/horizon-client/src/projectiles.rs b/crates/horizon-client/src/projectiles.rs
index 8a709067d..aae9b296b 100644
--- a/crates/horizon-client/src/projectiles.rs
+++ b/crates/horizon-client/src/projectiles.rs
@@ -28,6 +28,10 @@ pub enum ProjectileKind {
         critical: bool,
         effect: Option<(&'static str, i32)>,
     },
+    /// `ThrownTrident` of a mob (a drowned's): flies and sticks with
+    /// `AbstractArrow`'s tick; the trident itself is the arrow state's
+    /// `pickup_item`.
+    Trident,
     Snowball,
     Egg,
     EnderPearl,
@@ -66,6 +70,7 @@ impl ProjectileKind {
     pub fn id(&self) -> &'static str {
         match self {
             Self::Arrow { .. } => "minecraft:arrow",
+            Self::Trident => "minecraft:trident",
             Self::Snowball => "minecraft:snowball",
             Self::Egg => "minecraft:egg",
             Self::EnderPearl => "minecraft:ender_pearl",
@@ -152,7 +157,7 @@ fn axis_of(d: u8) -> u8 {
 }
 impl Projectile {
     pub fn new(kind: ProjectileKind, position: Vec3, owner: Option<Who>) -> Self {
-        let kind_is_arrow = matches!(kind, ProjectileKind::Arrow { .. });
+        let kind_is_arrow = matches!(kind, ProjectileKind::Arrow { .. } | ProjectileKind::Trident);
         Self {
             id: 0,
             kind,
@@ -253,7 +258,7 @@ impl Projectile {
     }
     fn gravity(&self) -> f64 {
         match self.kind {
-            ProjectileKind::Arrow { .. } => 0.05,
+            ProjectileKind::Arrow { .. } | ProjectileKind::Trident => 0.05,
             ProjectileKind::SmallFireball
             | ProjectileKind::LargeFireball { .. }
             | ProjectileKind::WitherSkull { .. } => 0.0,
@@ -604,8 +609,8 @@ impl Projectile {
             | ProjectileKind::WitherSkull { .. } => {
                 self.apply_hurting_inertia(water);
             }
-            // Arrows tick with `arrows::tick`.
-            ProjectileKind::Arrow { .. } => {}
+            // Arrows and tridents tick with `arrows::tick`.
+            ProjectileKind::Arrow { .. } | ProjectileKind::Trident => {}
             ProjectileKind::WindCharge | ProjectileKind::BreezeWindCharge => {}
             // LlamaSpit.tick: gone in water; drag and gravity follow the move.
             ProjectileKind::LlamaSpit => {
@@ -746,7 +751,8 @@ impl Projectile {
             ProjectileKind::WindCharge | ProjectileKind::BreezeWindCharge => return None,
             ProjectileKind::WitherSkull { dangerous: false } => "entity/wither/wither",
             ProjectileKind::WitherSkull { dangerous: true } => "entity/wither/wither_invulnerable",
-            ProjectileKind::Arrow { .. } => return None,
+            // Drawn as their models by the game.
+            ProjectileKind::Arrow { .. } | ProjectileKind::Trident => return None,
         })
     }
     /// Render scale of the item billboard (fireball renderers).

From 41d8b9e48aa8c5604fb2674ad60c2726de3e6857 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:32:20 +0100
Subject: [PATCH 242/475] Jigsaw structures: default max distance vertical and
 padding top like vanilla

---
 .../src/worldgen/structure/start.rs             | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/crates/horizon-world/src/worldgen/structure/start.rs b/crates/horizon-world/src/worldgen/structure/start.rs
index 810332c61..f84a953a1 100644
--- a/crates/horizon-world/src/worldgen/structure/start.rs
+++ b/crates/horizon-world/src/worldgen/structure/start.rs
@@ -275,16 +275,15 @@ fn terrain(name: Option<&str>) -> TerrainAdjustment {
         _ => TerrainAdjustment::None,
     }
 }
-fn pair(value: Option<&Value>, a: &str, b: &str, default: i32) -> [i32; 2] {
+/// A jigsaw field given as one number or as an object of two. In the object a
+/// missing `a` is 0 and a missing `b` is `missing_b` (`JigsawStructure.MaxDistance`
+/// and `DimensionPadding` default their second value, not copy the first).
+fn pair(value: Option<&Value>, a: &str, b: &str, default: i32, missing_b: i32) -> [i32; 2] {
     match value {
         Some(Value::Number(n)) => [n.as_i64().unwrap_or(0) as i32; 2],
         Some(Value::Object(o)) => {
-            let get = |k: &str| o.get(k).and_then(Value::as_i64).unwrap_or(0) as i32;
-            let first = get(a);
-            [
-                first,
-                o.get(b).and_then(Value::as_i64).map_or(first, |v| v as i32),
-            ]
+            let get = |k: &str| o.get(k).and_then(Value::as_i64).map(|v| v as i32);
+            [get(a).unwrap_or(0), get(b).unwrap_or(missing_b)]
         }
         _ => [default; 2],
     }
@@ -326,9 +325,11 @@ impl StructureRegistry {
                         "horizontal",
                         "vertical",
                         80,
+                        // DimensionType.Y_SIZE.
+                        4064,
                     ),
                     aliases: v["pool_aliases"].as_array().cloned().unwrap_or_default(),
-                    padding: pair(v.get("dimension_padding"), "bottom", "top", 0),
+                    padding: pair(v.get("dimension_padding"), "bottom", "top", 0, 0),
                     waterlogging: v["liquid_settings"].as_str() != Some("ignore_waterlogging"),
                     checks: super::start_checks::StartChecks::decode(v.get("horizon:start_checks")),
                     piece_limited: v

From bf62ccdabc6edff2ece53f895f5a4fe9a2e5e65d Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:33:16 +0100
Subject: [PATCH 243/475] Place the bonus chest in new worlds

---
 crates/horizon-client/src/game.rs             |  6 ++
 .../horizon-client/src/game/initial_spawn.rs  | 77 +++++++++++++++++++
 2 files changed, 83 insertions(+)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 20f6e01bc..03fa05669 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4293,6 +4293,12 @@ impl Game<'_> {
                 // The world's spawn from the start, not only once saved: a bed set
                 // before the first save must not become it.
                 self.level.world_spawn.get_or_insert([x, y, z]);
+                // The "Bonus Chest" create-world option, placed once with the spawn.
+                if horizon_client::save::WorldGen::read(&self.world_root)
+                    .is_some_and(|g| g.bonus_chest)
+                {
+                    self.place_bonus_chest([x, y, z])?;
+                }
             }
             let s = self
                 .level
diff --git a/crates/horizon-client/src/game/initial_spawn.rs b/crates/horizon-client/src/game/initial_spawn.rs
index 3f7a071bb..bbd0a766c 100644
--- a/crates/horizon-client/src/game/initial_spawn.rs
+++ b/crates/horizon-client/src/game/initial_spawn.rs
@@ -121,6 +121,83 @@ impl Game<'_> {
         }
         Ok(Some([ox * 16 + 8, height, oz * 16 + 8]))
     }
+    /// MinecraftServer.setInitialSpawn's bonus chest: BonusChestFeature.place
+    /// in the spawn chunk, a chest with the spawn bonus loot and a torch on
+    /// each side that can hold one, on the first free column of a shuffled
+    /// walk over the chunk. Skipped while the chunk is not loaded.
+    pub(super) fn place_bonus_chest(&mut self, origin: [i32; 3]) -> Result<()> {
+        use horizon_client::containers::BlockEntity;
+        let (cx, cz) = (origin[0] >> 4, origin[2] >> 4);
+        let registry = &self.pack.assets.registry;
+        let (Some(chest), Some(torch)) = (
+            registry.default_state("minecraft:chest"),
+            registry.default_state("minecraft:torch"),
+        ) else {
+            return Ok(());
+        };
+        if !self.streaming.is_lit(cx, cz) {
+            return Ok(());
+        }
+        let mut random = entity_random();
+        // Util.toShuffledList of the chunk's x and z.
+        let mut shuffled = |min: i32| -> [i32; 16] {
+            let mut values: [i32; 16] = std::array::from_fn(|i| min + i as i32);
+            for end in (2..=16usize).rev() {
+                let other = random.next_int_bound(end as i32).unwrap_or(0) as usize;
+                values.swap(end - 1, other);
+            }
+            values
+        };
+        let (xs, zs) = (shuffled(cx * 16), shuffled(cz * 16));
+        for x in xs {
+            for z in zs {
+                let y = self
+                    .spawn_columns()
+                    .height(HeightmapType::MotionBlockingNoLeaves, x, z);
+                if self.world.block(x, y, z) != self.world.air && !self.collision_empty([x, y, z]) {
+                    continue;
+                }
+                self.level_set([x, y, z], chest)?;
+                let seed = random.next_long();
+                self.world
+                    .block_entities
+                    .insert((x, y, z), BlockEntity::Chest(Vec::new()));
+                self.load_block_entity_nbt(
+                    [x, y, z],
+                    &format!(
+                        "{{LootTable:\"minecraft:chests/spawn_bonus_chest\",LootTableSeed:{seed}L}}"
+                    ),
+                );
+                for [dx, dz] in [[0, -1], [1, 0], [0, 1], [-1, 0]] {
+                    let at = [x + dx, y, z + dz];
+                    let survives = self.with_level(|b, level, ticks| {
+                        b.can_survive(level, ticks, BlockPos::new(at[0], at[1], at[2]), torch)
+                    });
+                    if survives {
+                        self.level_set(at, torch)?;
+                    }
+                }
+                return Ok(());
+            }
+        }
+        Ok(())
+    }
+    /// The block at `pos` has no collision shape.
+    fn collision_empty(&self, pos: [i32; 3]) -> bool {
+        let mut scene = SceneCollisions {
+            world: &self.world,
+            binding: self.collision,
+            subject: None,
+        };
+        self.collision
+            .collision_shape_with_context(
+                &mut scene,
+                self.world.block(pos[0], pos[1], pos[2]),
+                BlockPos::new(pos[0], pos[1], pos[2]),
+                &CollisionContext::empty(false),
+            )
+            .is_ok_and(|shape| shape.is_empty())
+    }
     /// PlayerSpawnFinder.findSpawn around the world spawn: the feet of a
     /// player who has no position yet. None while a candidate's chunk loads.
     pub(super) fn find_player_spawn(&mut self, suggestion: [i32; 3]) -> Result<Option<Vec3>> {

From c417556834aee38cd1a8f4a2815e5f09a753fb6b Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:33:36 +0100
Subject: [PATCH 244/475] Send /tellraw, /title and /playsound to LAN guests

---
 .../src/game/commands/text_commands.rs        | 71 +++++++++++++------
 .../src/game/commands/world_cmds.rs           | 33 ++++++++-
 crates/horizon-client/src/lan/containers.rs   | 39 ++++++----
 3 files changed, 106 insertions(+), 37 deletions(-)

diff --git a/crates/horizon-client/src/game/commands/text_commands.rs b/crates/horizon-client/src/game/commands/text_commands.rs
index dead07d71..225028adc 100644
--- a/crates/horizon-client/src/game/commands/text_commands.rs
+++ b/crates/horizon-client/src/game/commands/text_commands.rs
@@ -136,28 +136,40 @@ impl Game<'_> {
         }
         out
     }
-    fn player_targets(&mut self, ctx: &Context) -> R<usize> {
-        // Only the local player can receive messages and titles.
+    /// The players the command reaches: the window's own and the LAN guests.
+    fn player_targets(&mut self, ctx: &Context) -> R<Vec<Target>> {
         let targets = self.entities(ctx, "targets", true)?;
-        Ok(targets.iter().filter(|t| **t == Target::Player).count())
+        Ok(targets
+            .into_iter()
+            .filter(|t| matches!(t, Target::Player | Target::Guest(_)))
+            .collect())
     }
     pub(super) fn cmd_tellraw(&mut self, ctx: &Context) -> R<i32> {
-        let n = self.player_targets(ctx)?;
+        let players = self.player_targets(ctx)?;
         let message = self.component_arg(ctx, "message")?;
-        if n > 0 {
-            self.system_message(message);
+        // Each player's chat (a guest's through the connection).
+        for &t in &players {
+            self.for_player(t, |g| g.system_message(message.clone()));
         }
-        Ok(n as i32)
+        Ok(players.len() as i32)
     }
     pub(super) fn cmd_title(&mut self, ctx: &Context) -> R<i32> {
-        let n = self.player_targets(ctx)?;
-        let name = self.target_name(Target::Player);
+        let players = self.player_targets(ctx)?;
+        let n = players.len();
+        let name = players
+            .first()
+            .map_or_else(Text::empty, |t| self.target_name(*t));
         let single = n == 1;
         let key = if ctx.has("clear") {
-            self.titles_or_packet(Titles::clear, C::ClearTitles(play::Bool1 { value: false }));
+            self.titles_or_packet(
+                &players,
+                Titles::clear,
+                C::ClearTitles(play::Bool1 { value: false }),
+            );
             "cleared"
         } else if ctx.has("reset") {
             self.titles_or_packet(
+                &players,
                 |t| {
                     t.clear();
                     t.reset_times();
@@ -172,6 +184,7 @@ impl Game<'_> {
             };
             let (fade_in, stay, fade_out) = (get("fadeIn"), get("stay"), get("fadeOut"));
             self.titles_or_packet(
+                &players,
                 |t| t.set_times(fade_in, stay, fade_out),
                 C::SetTitlesAnimation(play::TitlesAnimation {
                     fade_in,
@@ -186,13 +199,17 @@ impl Game<'_> {
                 text: component_nbt(&text.component()),
             };
             if ctx.has("subtitle") {
-                self.titles_or_packet(|t| t.set_subtitle(text), C::SetSubtitleText(sent));
+                self.titles_or_packet(&players, |t| t.set_subtitle(text), C::SetSubtitleText(sent));
                 "show.subtitle"
             } else if ctx.has("actionbar") {
-                self.titles_or_packet(|t| t.set_overlay(text, false), C::SetActionBarText(sent));
+                self.titles_or_packet(
+                    &players,
+                    |t| t.set_overlay(text, false),
+                    C::SetActionBarText(sent),
+                );
                 "show.actionbar"
             } else {
-                self.titles_or_packet(|t| t.set_title(text), C::SetTitleText(sent));
+                self.titles_or_packet(&players, |t| t.set_title(text), C::SetTitleText(sent));
                 "show.title"
             }
         };
@@ -207,13 +224,27 @@ impl Game<'_> {
         self.feedback(message);
         Ok(n as i32)
     }
-    /// The player the title is for: the guest acting now is sent the packet
-    /// (TitleCommand's `connection.send`), the window's own player shows it.
-    fn titles_or_packet(&mut self, local: impl FnOnce(&mut Titles), packet: C) {
-        if self.lan_acting.is_some() {
-            self.guest_packets.push(packet);
-        } else {
-            local(&mut self.titles);
+    /// TitleCommand's `connection.send` for each player: a guest is sent the
+    /// packet, the window's own player shows it.
+    fn titles_or_packet(&mut self, players: &[Target], local: impl FnOnce(&mut Titles), packet: C) {
+        let mut local = Some(local);
+        for &t in players {
+            match t {
+                Target::Player if self.lan_acting.is_some() => {
+                    self.guest_packets.push(packet.clone());
+                }
+                Target::Player => {
+                    if let Some(local) = local.take() {
+                        local(&mut self.titles);
+                    }
+                }
+                Target::Guest(conn) => {
+                    if let Some(host) = self.lan.as_ref() {
+                        host.hub.send_to(conn, &packet);
+                    }
+                }
+                _ => {}
+            }
         }
     }
 }
diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs
index 687eb3f88..2e328b922 100644
--- a/crates/horizon-client/src/game/commands/world_cmds.rs
+++ b/crates/horizon-client/src/game/commands/world_cmds.rs
@@ -301,9 +301,18 @@ impl Game<'_> {
             float("minVolume", 0.0),
         );
         let range = if volume > 1.0 { 16.0 * volume } else { 16.0 };
+        // PlaySoundCommand: one seed for every player.
+        let seed = self.world.random.next_long();
+        let here = self.dim.id();
         let mut tracker = Tracker::default();
         for t in targets {
-            if t != Target::Player {
+            if !matches!(t, Target::Player | Target::Guest(_)) {
+                continue;
+            }
+            // Only players in the source's level hear it.
+            if let Target::Guest(conn) = t
+                && self.command_guest(conn).is_none_or(|g| g.dimension != here)
+            {
                 continue;
             }
             let Some(p) = self.target_position(t) else {
@@ -327,8 +336,26 @@ impl Game<'_> {
             } else {
                 (pos, volume)
             };
-            self.audio.play_on(source, &sound, Some(at), v, pitch);
-            tracker.mark(&holder(Text::literal(self.acting_player_name())));
+            // The connection is sent the sound; the window's own player
+            // plays it.
+            let guest = match t {
+                Target::Guest(conn) => Some(conn),
+                _ => self.lan_acting,
+            };
+            match guest.and_then(|conn| Some((conn, self.lan.as_ref()?))) {
+                Some((conn, host)) => {
+                    let packet = host
+                        .hub
+                        .sound_packet(&sound, at, v, pitch, source as i32, seed);
+                    if t == Target::Player {
+                        self.guest_packets.push(packet);
+                    } else {
+                        host.hub.send_to(conn, &packet);
+                    }
+                }
+                None => self.audio.play_on(source, &sound, Some(at), v, pitch),
+            }
+            tracker.mark(&holder(self.target_name(t)));
         }
         let name = Text::literal(sound.clone());
         let (message, total) = tracker.message(
diff --git a/crates/horizon-client/src/lan/containers.rs b/crates/horizon-client/src/lan/containers.rs
index 002f95cbb..7ea8f0baf 100644
--- a/crates/horizon-client/src/lan/containers.rs
+++ b/crates/horizon-client/src/lan/containers.rs
@@ -36,6 +36,30 @@ impl Hub {
 
     /// ClientboundSoundPacket for a sound event name (an inline event when
     /// the registry does not know it).
+    pub fn sound_packet(
+        &self,
+        name: &str,
+        at: [f64; 3],
+        volume: f32,
+        pitch: f32,
+        source: i32,
+        seed: i64,
+    ) -> C {
+        let sound = match self.sync.id("minecraft:sound_event", name) {
+            Some(id) => (id, None),
+            None => (-1, Some((name.to_owned(), None))),
+        };
+        C::Sound(play::Sound {
+            sound,
+            source,
+            x: (at[0] * 8.0) as i32,
+            y: (at[1] * 8.0) as i32,
+            z: (at[2] * 8.0) as i32,
+            volume,
+            pitch,
+            seed,
+        })
+    }
     pub fn sound(
         &self,
         name: &str,
@@ -45,20 +69,7 @@ impl Hub {
         source: i32,
         except: Option<u32>,
     ) {
-        let sound = match self.sync.id("minecraft:sound_event", name) {
-            Some(id) => (id, None),
-            None => (-1, Some((name.to_owned(), None))),
-        };
-        let packet = C::Sound(play::Sound {
-            sound,
-            source,
-            x: (at[0] * 8.0) as i32,
-            y: (at[1] * 8.0) as i32,
-            z: (at[2] * 8.0) as i32,
-            volume,
-            pitch,
-            seed: self.ticks as i64,
-        });
+        let packet = self.sound_packet(name, at, volume, pitch, source, self.ticks as i64);
         self.broadcast_near(at, f64::from(volume.max(1.0)) * 16.0, &packet, except);
     }
 

From ae3737b1c279efb2acb3092f04d6711820c2de61 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:34:08 +0100
Subject: [PATCH 245/475] Mod API: render.set-far-terrain, and the official Far
 View mod

A mod can now turn on the game's distant terrain (LOD) with
render.set-far-terrain: a distance of 64 to 1024 chunks and Far Detail's
Reduced. The game builds and draws the tiles as it does for the LOD
Distance setting, which wins while it is on. One far terrain shows at a
time, the first loaded mod's. API level 4.

mods/official/far-view is the official mod on it: Distance (256 chunks by
default) and Far detail on its settings page, kept in its storage.
---
 Cargo.lock                                    |  7 ++
 Cargo.toml                                    |  2 +-
 crates/horizon-client/src/game.rs             | 34 +++++--
 crates/horizon-client/src/game/mod_input.rs   | 18 ++++
 crates/horizon-client/src/graphics.rs         | 16 ++--
 crates/horizon-mod-sdk/wit/horizon.wit        | 17 ++++
 crates/horizon-mods/src/api_level.rs          |  5 +-
 crates/horizon-mods/src/runtime.rs            | 25 +++++-
 crates/horizon-mods/tests/sandbox.rs          | 17 +++-
 crates/horizon-mods/tests/ui_guest/src/lib.rs | 10 +++
 docs/api/mods-reference.md                    |  8 ++
 docs/api/stability.md                         |  7 +-
 docs/graphics.md                              |  2 +-
 docs/mods.md                                  |  5 +-
 mods/official/far-view/Cargo.toml             | 16 ++++
 mods/official/far-view/horizon-mod.toml       |  9 ++
 mods/official/far-view/src/lib.rs             | 89 +++++++++++++++++++
 17 files changed, 261 insertions(+), 26 deletions(-)
 create mode 100644 mods/official/far-view/Cargo.toml
 create mode 100644 mods/official/far-view/horizon-mod.toml
 create mode 100644 mods/official/far-view/src/lib.rs

diff --git a/Cargo.lock b/Cargo.lock
index 809df3a5a..a17262571 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -923,6 +923,13 @@ version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7"
 
+[[package]]
+name = "far-view"
+version = "1.0.0"
+dependencies = [
+ "horizon-mod-sdk",
+]
+
 [[package]]
 name = "fdeflate"
 version = "0.3.7"
diff --git a/Cargo.toml b/Cargo.toml
index 59bfe5e33..a669fb489 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [workspace]
 exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"]
-members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-hdr", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/zoom", "xtask"]
+members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-hdr", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/far-view", "mods/official/minimap", "mods/official/zoom", "xtask"]
 resolver = "2"
 
 [workspace.package]
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index d00c7710c..1e4e93d3b 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -11208,11 +11208,28 @@ impl Game<'_> {
         }
         Ok(())
     }
-    /// LOD Distance as far terrain uses it (`Graphics::lod_distance_on`).
+    /// LOD Distance and Far Detail Reduced as chosen: the player's LOD
+    /// Distance when it is on, else a mod's far terrain
+    /// (`render.set-far-terrain`).
+    fn far_terrain_choice(&self) -> (u32, bool) {
+        let g = &self.settings.horizon;
+        let reduced = g.far_detail == horizon_client::graphics::FarDetail::Reduced;
+        if g.lod_distance > 0 {
+            return (g.lod_distance, reduced);
+        }
+        match self.mod_far_terrain() {
+            Some(f) => (f.distance, reduced || f.reduced),
+            None => (0, reduced),
+        }
+    }
+    /// LOD Distance as far terrain uses it (`graphics::lod_distance_capped`).
     fn lod_distance(&self) -> u32 {
+        let (distance, _) = self.far_terrain_choice();
         match &self.renderer {
-            Some(renderer) => self.settings.horizon.lod_distance_on(&renderer.info),
-            None => self.settings.horizon.lod_distance.min(1024),
+            Some(renderer) => {
+                horizon_client::graphics::lod_distance_capped(distance, &renderer.info)
+            }
+            None => distance.min(1024),
         }
     }
     /// Only enabled LOD worlds extend the renderer's range, never simulation.
@@ -11233,7 +11250,7 @@ impl Game<'_> {
         }
     }
     fn prepare_lod(&mut self) {
-        let enabled = self.settings.horizon.lod_distance > 0
+        let enabled = self.far_terrain_choice().0 > 0
             && self.renderer.is_some()
             && self.player.is_some()
             && self.title.is_none()
@@ -11330,6 +11347,7 @@ impl Game<'_> {
         {
             log::warn!("Horizon: failed to save unloaded chunks: {e}");
         }
+        let (far_distance, far_reduced) = self.far_terrain_choice();
         if let Some(renderer) = self.renderer.as_mut() {
             let g = &self.settings.horizon;
             let budgeted = g.chunk_updates > 0 || g.upload_budget_kib > 0;
@@ -11383,12 +11401,10 @@ impl Game<'_> {
             }
             renderer.remove_columns(unloaded.iter().map(|c| (c.x, c.z)));
             if let (Some(lod), Some(player)) = (&mut self.lod, &self.player) {
-                let lod_distance = self.settings.horizon.lod_distance_on(&renderer.info);
+                let lod_distance =
+                    horizon_client::graphics::lod_distance_capped(far_distance, &renderer.info);
                 lod.set_near_loading(self.streaming.busy());
-                lod.set_reduced_detail(
-                    self.settings.horizon.far_detail
-                        == horizon_client::graphics::FarDetail::Reduced,
-                );
+                lod.set_reduced_detail(far_reduced);
                 // The covered columns change only with the complete ones and
                 // the render area: rebuilt then, not every frame.
                 let at = (
diff --git a/crates/horizon-client/src/game/mod_input.rs b/crates/horizon-client/src/game/mod_input.rs
index 10faf6a81..467ea1cc0 100644
--- a/crates/horizon-client/src/game/mod_input.rs
+++ b/crates/horizon-client/src/game/mod_input.rs
@@ -31,6 +31,9 @@ impl Game<'_> {
     pub(super) fn mod_minimap(&self) -> Option<ModMinimap> {
         None
     }
+    pub(super) fn mod_far_terrain(&self) -> Option<ModFarTerrain> {
+        None
+    }
 }
 
 /// A mod's zoom (`render.set-zoom`), clamped by the runtime.
@@ -51,6 +54,13 @@ pub(super) struct ModMinimap {
     pub(super) round: bool,
 }
 
+/// A mod's far terrain (`render.set-far-terrain`), clamped by the runtime.
+#[derive(Clone, Copy)]
+pub(super) struct ModFarTerrain {
+    pub(super) distance: u32,
+    pub(super) reduced: bool,
+}
+
 #[cfg(feature = "mods")]
 impl Game<'_> {
     /// The main hand's stack as `input` shows it; none when it is empty.
@@ -178,4 +188,12 @@ impl Game<'_> {
             round: m.round,
         })
     }
+    /// The far terrain the first mod drawing one asks for.
+    pub(super) fn mod_far_terrain(&self) -> Option<ModFarTerrain> {
+        let f = self.mods.mods.far_terrain()?;
+        Some(ModFarTerrain {
+            distance: f.distance,
+            reduced: f.reduced,
+        })
+    }
 }
diff --git a/crates/horizon-client/src/graphics.rs b/crates/horizon-client/src/graphics.rs
index 4f6f04bc0..edef7c3bc 100644
--- a/crates/horizon-client/src/graphics.rs
+++ b/crates/horizon-client/src/graphics.rs
@@ -216,15 +216,19 @@ pub const INTEGRATED_LOD_DISTANCE: u32 = 128;
 pub fn lod_capped(info: &wgpu::AdapterInfo) -> bool {
     info.device_type == wgpu::DeviceType::IntegratedGpu && !info.name.starts_with("Apple")
 }
+/// A LOD distance as far terrain uses it on this adapter.
+pub fn lod_distance_capped(distance: u32, info: &wgpu::AdapterInfo) -> u32 {
+    let distance = distance.min(1024);
+    if lod_capped(info) {
+        distance.min(INTEGRATED_LOD_DISTANCE)
+    } else {
+        distance
+    }
+}
 impl Graphics {
     /// `lod_distance` as far terrain uses it on this adapter.
     pub fn lod_distance_on(&self, info: &wgpu::AdapterInfo) -> u32 {
-        let distance = self.lod_distance.min(1024);
-        if lod_capped(info) {
-            distance.min(INTEGRATED_LOD_DISTANCE)
-        } else {
-            distance
-        }
+        lod_distance_capped(self.lod_distance, info)
     }
 }
 #[derive(Clone, Debug, PartialEq)]
diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit
index d9bb9f5c2..9c9fc1574 100644
--- a/crates/horizon-mod-sdk/wit/horizon.wit
+++ b/crates/horizon-mod-sdk/wit/horizon.wit
@@ -412,6 +412,23 @@ interface render {
     /// own frame budget; hidden, they are dropped. One map shows at a time:
     /// the first loaded mod's.
     set-minimap: func(minimap: option<minimap>);
+    record far-terrain {
+        /// How far the distant terrain reaches, in chunks: 64 to 1024. On
+        /// integrated graphics other than Apple's the game caps it lower.
+        distance: u32,
+        /// Coarser far tiles, as the Far Detail setting's Reduced: 2 to 4 ms
+        /// less GPU time per frame on integrated graphics.
+        reduced: bool,
+    }
+    /// Draws the world beyond the render distance as distant terrain, out to
+    /// `distance` chunks, until the next call (none ends it). The game builds
+    /// it on its own workers, from the chunks already loaded or saved and,
+    /// where nobody has been, from the world's generator; the simulation
+    /// distance doesn't change. Only worlds whose generator the game has
+    /// (single player and a LAN world you host) show it. The player's own LOD
+    /// Distance setting, when on, wins. One far terrain shows at a time: the
+    /// first loaded mod's.
+    set-far-terrain: func(far-terrain: option<far-terrain>);
 }
 
 /// What the game calls. Only the hooks `init` asks for are ever called.
diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs
index bf87d0cfa..a20a413c5 100644
--- a/crates/horizon-mods/src/api_level.rs
+++ b/crates/horizon-mods/src/api_level.rs
@@ -7,13 +7,13 @@
 //! version's level so the launcher can tell before it installs.
 
 /// The newest level this Horizon serves.
-pub const LEVEL: u32 = 3;
+pub const LEVEL: u32 = 4;
 
 /// Every function the game offers mods, as `interface.function`, with its
 /// level. Level 0 is the contract of Horizon 0.2.67 to 0.2.69. A new
 /// function takes the next level and raises [`LEVEL`] (the `api_reference`
 /// test fails until it is listed here).
-pub const FUNCTIONS: [(&str, u32); 34] = [
+pub const FUNCTIONS: [(&str, u32); 35] = [
     ("log.write", 0),
     ("game.get-player", 0),
     ("game.get-clock", 0),
@@ -48,6 +48,7 @@ pub const FUNCTIONS: [(&str, u32); 34] = [
     ("players.broadcast", 1),
     ("game.raycast", 2),
     ("command.run-quiet", 3),
+    ("render.set-far-terrain", 4),
 ];
 
 /// What the game's program carries so the launcher can read its level
diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs
index ce48f2317..ead43a8f2 100644
--- a/crates/horizon-mods/src/runtime.rs
+++ b/crates/horizon-mods/src/runtime.rs
@@ -73,9 +73,9 @@ use render_bindings::horizon::mods::input;
 pub use render_bindings::horizon::mods::input::{Event as InputEvent, HeldItem, ItemUse};
 /// What capability `render` asks the game to draw (WIT `interface render`).
 pub use render_bindings::horizon::mods::render::{
-    Corner as RenderCorner, FillShape, FrameRate, ItemShape, Minimap as ModMinimap,
-    Point as RenderPoint, QuadShape, Rect as RenderRect, Shape, SpriteShape, TextShape,
-    Zoom as ModZoom,
+    Corner as RenderCorner, FarTerrain as ModFarTerrain, FillShape, FrameRate, ItemShape,
+    Minimap as ModMinimap, Point as RenderPoint, QuadShape, Rect as RenderRect, Shape, SpriteShape,
+    TextShape, Zoom as ModZoom,
 };
 use render_bindings::{RenderHost, horizon::mods::render};
 
@@ -297,6 +297,8 @@ struct State {
     zoom: Option<ModZoom>,
     /// Capability `render`'s minimap, when the mod shows one.
     minimap: Option<ModMinimap>,
+    /// Capability `render`'s far terrain, when the mod draws one.
+    far_terrain: Option<ModFarTerrain>,
     input: InputState,
     /// Capability `storage`'s folder; made on first `set`.
     data_dir: PathBuf,
@@ -460,6 +462,7 @@ impl Mods {
             corner: None,
             zoom: None,
             minimap: None,
+            far_terrain: None,
             input: InputState::default(),
             data_dir,
             storage_budget: STORAGE_WRITE_BUDGET,
@@ -924,6 +927,12 @@ impl Mods {
             .iter()
             .find_map(|e| e.run.as_ref()?.store.data().minimap)
     }
+    /// The far terrain the first running mod draws (capability `render`).
+    pub fn far_terrain(&self) -> Option<ModFarTerrain> {
+        self.entries
+            .iter()
+            .find_map(|e| e.run.as_ref()?.store.data().far_terrain)
+    }
     fn inputs(&self) -> impl Iterator<Item = &InputState> {
         self.entries
             .iter()
@@ -1292,6 +1301,8 @@ const TURN_MIN: f32 = 0.05;
 /// `set-minimap`'s side in GUI pixels and its blocks per map pixel.
 const MINIMAP_SIZE: (f32, f32) = (16.0, 256.0);
 const MINIMAP_SCALE: (f32, f32) = (0.5, 4.0);
+/// `set-far-terrain`'s distance in chunks, as the LOD Distance setting's.
+const FAR_TERRAIN_DISTANCE: (u32, u32) = (64, 1024);
 
 /// A mod's corner panel: shapes in a `width` × `height` box the game
 /// places in `corner`, stacked with the other overlays.
@@ -1381,6 +1392,14 @@ impl render::Host for State {
             ..m
         });
     }
+    fn set_far_terrain(&mut self, far_terrain: Option<ModFarTerrain>) {
+        self.far_terrain = far_terrain.map(|f| ModFarTerrain {
+            distance: f
+                .distance
+                .clamp(FAR_TERRAIN_DISTANCE.0, FAR_TERRAIN_DISTANCE.1),
+            ..f
+        });
+    }
     fn frame_stats(&mut self) -> FrameRate {
         let (fps, min, low) = self.snapshot.frame;
         FrameRate { fps, min, low }
diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs
index c6b835f10..701968781 100644
--- a/crates/horizon-mods/tests/sandbox.rs
+++ b/crates/horizon-mods/tests/sandbox.rs
@@ -252,7 +252,7 @@ experimental = ["ui", "render", "input"]
         needed(imports(&wasm).unwrap().iter().map(String::as_str)).0
     };
     assert_eq!(level("coords_hud.hmod"), 0);
-    // The UI guest shows a minimap (`render.set-minimap`).
+    // The UI guest draws far terrain (`render.set-far-terrain`).
     assert_eq!(level("horizon_mods_test_ui_guest.hmod"), LEVEL);
 }
 
@@ -722,6 +722,21 @@ fn render_minimap_is_clamped_and_hidden() {
     assert_eq!(map(&mut mods, "off"), None);
 }
 
+#[test]
+fn render_far_terrain_is_clamped_and_ended() {
+    let mut mods = load("horizon_mods_test_ui_guest.hmod");
+    let far = |mods: &mut Mods, args: &str| {
+        assert!(mods.command(&format!("far_terrain {args}")));
+        mods.far_terrain().map(|f| (f.distance, f.reduced))
+    };
+    assert!(mods.far_terrain().is_none());
+    assert_eq!(far(&mut mods, "256 1"), Some((256, true)));
+    // The distance is clamped to LOD Distance's 64 to 1024 chunks.
+    assert_eq!(far(&mut mods, "8 0"), Some((64, false)));
+    assert_eq!(far(&mut mods, "99999 0"), Some((1024, false)));
+    assert_eq!(far(&mut mods, "off"), None);
+}
+
 /// `game.raycast`: the view's hit the game worked out, up to the distance
 /// asked for; the game works it out only while a mod imports the call.
 #[test]
diff --git a/crates/horizon-mods/tests/ui_guest/src/lib.rs b/crates/horizon-mods/tests/ui_guest/src/lib.rs
index 74fb64350..f3ab0f6af 100644
--- a/crates/horizon-mods/tests/ui_guest/src/lib.rs
+++ b/crates/horizon-mods/tests/ui_guest/src/lib.rs
@@ -99,6 +99,7 @@ impl Mod for Guest {
             "input_wheel",
             "zoom",
             "minimap",
+            "far_terrain",
             "raycast",
             "quiet",
             "quiet_many",
@@ -222,6 +223,15 @@ impl Mod for Guest {
                 });
                 render::set_minimap(map);
             }
+            // `far_terrain off`, or `far_terrain DISTANCE REDUCED`.
+            "far_terrain" => {
+                let words: Vec<&str> = args.split(' ').collect();
+                let far = (args != "off").then(|| render::FarTerrain {
+                    distance: words.first().and_then(|w| w.parse().ok()).unwrap_or(0),
+                    reduced: words.get(1) == Some(&"1"),
+                });
+                render::set_far_terrain(far);
+            }
             "quiet" => command::run_quiet(&args.split(';').map(str::to_owned).collect::<Vec<_>>()),
             "quiet_many" => {
                 let n: usize = args.parse().unwrap_or(0);
diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md
index c44f27576..c9409b7e4 100644
--- a/docs/api/mods-reference.md
+++ b/docs/api/mods-reference.md
@@ -426,6 +426,13 @@ Any four-cornered shape (a wheel's segment, an arrow): the corners in order roun
 | `rotate` | `bool` | The map turns with the player, who faces up, and an N on its rim marks north. Otherwise north is up and the player's arrow turns. |
 | `round` | `bool` | Round, the corners left clear; otherwise square. |
 
+### record `far-terrain`
+
+| Field | Type | |
+| --- | --- | --- |
+| `distance` | `u32` | How far the distant terrain reaches, in chunks: 64 to 1024. On integrated graphics other than Apple's the game caps it lower. |
+| `reduced` | `bool` | Coarser far tiles, as the Far Detail setting's Reduced: 2 to 4 ms less GPU time per frame on integrated graphics. |
+
 | Function | Signature | What it does |
 | --- | --- | --- |
 | `set-hud` | `func(shapes: list<shape>)` | Replaces the mod's HUD shapes: up to 1024, drawn every frame in order over the HUD (after the hotbar, under chat and screens), hidden with the HUD (F1). An empty list removes them. |
@@ -437,6 +444,7 @@ Any four-cornered shape (a wheel's segment, an arrow): the corners in order roun
 | `frame-stats` | `func() -> frame-rate` | The game's frame counter, recomputed twice a second. |
 | `set-zoom` | `func(zoom: zoom)` | Zooms the camera until the next call (`factor` 1 ends it), only while playing: a screen opening or the spyglass's own view (which wins) leave the camera vanilla's. With several mods, the strongest zoom counts. |
 | `set-minimap` | `func(minimap: option<minimap>)` | Shows a map of the world around the player in `corner`, stacked with the game's overlays and the mods' panels, until the next call (none hides it). It looks like a map item: vanilla's map colours with their height shading and water depth, and the player's arrow. Underground, under a roof and in the Nether it maps the floor around the player's height. The game keeps the map's tiles and refreshes them within its own frame budget; hidden, they are dropped. One map shows at a time: the first loaded mod's. |
+| `set-far-terrain` | `func(far-terrain: option<far-terrain>)` | Draws the world beyond the render distance as distant terrain, out to `distance` chunks, until the next call (none ends it). The game builds it on its own workers, from the chunks already loaded or saved and, where nobody has been, from the world's generator; the simulation distance doesn't change. Only worlds whose generator the game has (single player and a LAN world you host) show it. The player's own LOD Distance setting, when on, wins. One far terrain shows at a time: the first loaded mod's. |
 
 ## `events`
 
diff --git a/docs/api/stability.md b/docs/api/stability.md
index df2c1aeb3..f65bafa55 100644
--- a/docs/api/stability.md
+++ b/docs/api/stability.md
@@ -38,7 +38,7 @@ don't import it); faster, or fixing behaviour to what the reference already says
 
 A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every
 function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`):
-level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`, level 3 `command.run-quiet`. A mod needs the level of
+level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`, level 3 `command.run-quiet`, level 4 `render.set-far-terrain`. A mod needs the level of
 the newest function it imports (a component imports only the functions it calls). The level is read from the file,
 never declared:
 
@@ -134,3 +134,8 @@ Deprecations and breaking changes are in bold. The release notes of the game rel
   for a map image costs too much through hook calls, so the game keeps the tiles (vanilla's map colours) and the mod
   picks the corner, side, scale and shape. One map shows at a time, the first loaded mod's. It is a new function and a
   new type, so mods built before it keep loading.
+- **`render.set-far-terrain`** turns on the game's own distant terrain, not one a mod builds: sampling the generator
+  and meshing thousands of far tiles runs on the game's workers within its frame and upload budgets, which no hook
+  call could match. The mod picks the distance (64 to 1024 chunks, capped lower on integrated graphics as LOD Distance
+  is) and Far Detail's Reduced. The player's own LOD Distance, when on, wins; one far terrain shows at a time, the
+  first loaded mod's.
diff --git a/docs/graphics.md b/docs/graphics.md
index dcba29773..bebd8a7f6 100644
--- a/docs/graphics.md
+++ b/docs/graphics.md
@@ -47,7 +47,7 @@ Coverage and detail improve progressively; a large selected radius does not mean
 
 Ordinary Overworld atmospheric fog extends with the selected LOD distance. Fog Off disables distance haze at large ranges too; fluid, darkness and boss fog retain their limits.
 
-The setting is stored as `lodDistance` in `horizon-graphics.txt`; `0` disables it. Existing `renderDistance` in `options.txt` keeps its normal meaning for full chunks.
+The setting is stored as `lodDistance` in `horizon-graphics.txt`; `0` disables it. The official Far View mod (`mods/official/far-view`, [mods.md](mods.md)) turns the same distant terrain on from the mod browser, with its own distance and detail; the setting, when on, wins. Existing `renderDistance` in `options.txt` keeps its normal meaning for full chunks.
 
 Not implemented: anisotropic filtering (wgpu needs linear magnification for it, which blurs close blocks), MSAA (FXAA instead) and exclusive fullscreen (fullscreen is borderless).
 
diff --git a/docs/mods.md b/docs/mods.md
index a68b6d123..3e4fcc53c 100644
--- a/docs/mods.md
+++ b/docs/mods.md
@@ -15,7 +15,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3.
 | The contract (WIT) | `crates/horizon-mod-sdk/wit/horizon.wit` | 0.1: log, game-read, chat, hud, storage, command, ui; tick, frame, chat and command hooks |
 | SDK for mod authors | `crates/horizon-mod-sdk` | 0.1 |
 | Example mods | `crates/horizon-mod-sdk/examples/coords-hud`, `examples/predator-missile` | coordinates, facing and time HUD, `/where`, `/coords`; `/missile`, a guided missile from vanilla commands |
-| Horizon's official mods | `mods/official/` | the extras moving to the registry: FPS Counter (`fps-overlay`), Keystrokes, Zoom, Minimap |
+| Horizon's official mods | `mods/official/` | the extras moving to the registry: FPS Counter (`fps-overlay`), Keystrokes, Zoom, Minimap; Far View (`far-view`), distant terrain |
 | Runtime | `crates/horizon-mods` | wasmtime 48 LTS, component model |
 | Authoring tool | `crates/cargo-horizon-mod` | `cargo horizon-mod new [--template code\|content] / build / run / test / check`, and the registry's CI (`registry build / review / list`) |
 | In the game | `crates/horizon-client/src/game/mods.rs`, Options > Mods | client mods |
@@ -89,7 +89,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3.
 | `storage` | `storage` | `get(key)`, `set(key, value)`, `delete(key)`: a per-mod folder of up to 64 files, 4 MiB total, at most 1 MiB written per call |
 | `command` | `command` | `run(line)`: a vanilla command run as the player, with the player's permissions, after the hook returns (8 per call); mods' own commands are not run. `run-quiet(lines)`: up to 256 a call, the same rights, nothing in the chat (single player and Horizon's servers run them 64 a tick and log one line a batch; elsewhere they go as chat commands and their feedback shows) |
 | `ui` | `ui` | `open-screen`, `close-screen`, `set-settings`: a screen the mod owns and a page in Options > Mods, of text, button, item and list widgets the game lays out and draws with its own menus' code. **Experimental:** the manifest needs `experimental = ["ui"]` |
-| `render` | `render` | `set-hud(shapes)`: up to 1024 fills, four-cornered shapes, GUI sprites, items and text, kept on the HUD (over the hotbar, under chat and screens, hidden with F1) until replaced; `set-corner(corner, w, h, shapes)`: a box the game places in a corner, stacked with its overlays and other panels, as `hud`'s panels are; `text-width(text)`; `frame-stats()`: the game's FPS, min and 1% low; `gui-size()`; `shake(strength, seconds)`: the view turns, the player doesn't, scaled by Distortion Effects; `set-zoom(zoom)`: the field of view divided by up to 10, eased or at once, with slower turning, while playing and not through a spyglass (the strongest of several mods' zooms counts); `set-minimap(minimap)`: a map of the world around the player in a corner, as a map item colours it (the floor underground and under roofs), square or round, turning with the player or north up, with the player's arrow; the game keeps its tiles within its own frame budget (one map at a time, the first loaded mod's). The game's own HUD renderer draws them: a mod never supplies shader code. **Experimental:** `experimental = ["render"]` |
+| `render` | `render` | `set-hud(shapes)`: up to 1024 fills, four-cornered shapes, GUI sprites, items and text, kept on the HUD (over the hotbar, under chat and screens, hidden with F1) until replaced; `set-corner(corner, w, h, shapes)`: a box the game places in a corner, stacked with its overlays and other panels, as `hud`'s panels are; `text-width(text)`; `frame-stats()`: the game's FPS, min and 1% low; `gui-size()`; `shake(strength, seconds)`: the view turns, the player doesn't, scaled by Distortion Effects; `set-zoom(zoom)`: the field of view divided by up to 10, eased or at once, with slower turning, while playing and not through a spyglass (the strongest of several mods' zooms counts); `set-minimap(minimap)`: a map of the world around the player in a corner, as a map item colours it (the floor underground and under roofs), square or round, turning with the player or north up, with the player's arrow; the game keeps its tiles within its own frame budget (one map at a time, the first loaded mod's); `set-far-terrain(far-terrain)`: the world past the render distance as distant terrain, out to 64 to 1024 chunks, built by the game's own workers (the player's LOD Distance, when on, wins; the first loaded mod's). The game's own HUD renderer draws them: a mod never supplies shader code. **Experimental:** `experimental = ["render"]` |
 | `input` | `input` | `claim-items(ids)`: the use button on those items is the mod's (`use-start`, `use-stop` with the ticks held; the game doesn't place, eat or swing); `register-key(name, label, key)`: up to 16 keys (`key.keyboard.r`), heard while playing as `key-down` / `key-up` (the game's own mapping on that key still runs; a screen opening lets held keys up), mouse buttons as `key.mouse.4`. The player rebinds them on the mod's page in Options > Mods, where the game lists them first as Key Binds rows (click, then press a key or mouse button; Esc binds none), even for a mod without `ui`; the choice is kept in `horizon-mods.txt` (`key.<mod>.<name>:key.keyboard.z`) and wins over `register-key`'s default; `claim-wheel(on)`: the wheel's steps become `wheel` events and the hotbar doesn't move (the one input a mod takes from the game; a mod's keys never do); `held()`; `mapping(name)`: a movement or click mapping's key label and whether it is held; `clicks-per-second()`; `poll()` returns the events, at most 256 kept. **Experimental:** `experimental = ["input"]` |
 
 | Hook (export) | When |
@@ -569,6 +569,7 @@ so the same rustc and `Cargo.lock` give the same file.
 | Keystrokes | `keystrokes` | Extras > Keystrokes | `corner`: as above, default `top_left`; `cps`: `true` (default), `false` |
 | Zoom | `zoom` | Extras > Zoom | `level`: `2`, `3`, `4` (default), `6`, `8`, `10`; `smooth`: `true` (default), `false`; `sensitivity` (slower turning): `true` (default), `false`. The key is the game's: `key.zoom.zoom` in `horizon-mods.txt`, default `key.keyboard.z` |
 | Minimap | `minimap` | Extras > Minimap | `corner`: as above, default `top_right`; `size`: `64`, `96` (default), `128`; `shape`: `square` (default), `round`; `zoom` (blocks per pixel): `0.5`, `1` (default), `2`, `4`; `rotate`: `false` (default), `true`. The game draws the map (`render.set-minimap`) |
+| Far View | `far_view` | Graphics > LOD Distance and Far Detail | `distance` (chunks): `64`, `128`, `256` (default), `512`, `1024`; `detail`: `full` (default), `reduced`. The game builds and draws the distant terrain (`render.set-far-terrain`); the player's LOD Distance, when on, wins |
 
 ## Versions and compatibility
 
diff --git a/mods/official/far-view/Cargo.toml b/mods/official/far-view/Cargo.toml
new file mode 100644
index 000000000..965ee0bb4
--- /dev/null
+++ b/mods/official/far-view/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "far-view"
+version = "1.0.0"
+edition.workspace = true
+license.workspace = true
+publish = false
+description = "Horizon's official far view: distant terrain past the render distance."
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+horizon-mod-sdk = { path = "../../../crates/horizon-mod-sdk" }
+
+[lints]
+workspace = true
diff --git a/mods/official/far-view/horizon-mod.toml b/mods/official/far-view/horizon-mod.toml
new file mode 100644
index 000000000..5070f897c
--- /dev/null
+++ b/mods/official/far-view/horizon-mod.toml
@@ -0,0 +1,9 @@
+id = "far_view"
+name = "Far View"
+version = "1.0.0"
+description = "See much farther: the world past your render distance drawn as simplified distant terrain, out to 1024 chunks, without loading or simulating more chunks."
+authors = ["Horizon"]
+api = "0.1"
+side = "client"
+capabilities = ["render", "ui", "storage"]
+experimental = ["render", "ui"]
diff --git a/mods/official/far-view/src/lib.rs b/mods/official/far-view/src/lib.rs
new file mode 100644
index 000000000..e5b92e590
--- /dev/null
+++ b/mods/official/far-view/src/lib.rs
@@ -0,0 +1,89 @@
+//! Horizon's official far view: the world past the render distance drawn as
+//! distant terrain (`render.set-far-terrain`; the game builds the tiles on
+//! its own workers). Its settings page picks how far it reaches and the far
+//! tiles' detail, kept in the mod's storage (`distance`, `detail`). The
+//! player's own LOD Distance setting, when on, wins over the mod.
+use horizon_mod_sdk::{
+    Mod, Registration,
+    render::{self, FarTerrain},
+    storage,
+    ui::{self, ButtonWidget, Widget},
+};
+
+/// Distances in chunks, as LOD Distance offers them.
+const DISTANCES: [u32; 5] = [64, 128, 256, 512, 1024];
+/// Settings page buttons.
+const DISTANCE_BUTTON: u32 = 1;
+const DETAIL_BUTTON: u32 = 2;
+
+/// An index into [`DISTANCES`] and Far Detail's Reduced.
+struct FarView {
+    distance: usize,
+    reduced: bool,
+}
+
+impl FarView {
+    fn show(&self) {
+        render::set_far_terrain(Some(FarTerrain {
+            distance: DISTANCES[self.distance],
+            reduced: self.reduced,
+        }));
+    }
+    fn page(&self) {
+        let button = |id, label: String| Widget::Button(ButtonWidget { id, label });
+        ui::set_settings(&[
+            button(
+                DISTANCE_BUTTON,
+                format!("Distance: {} chunks", DISTANCES[self.distance]),
+            ),
+            button(
+                DETAIL_BUTTON,
+                format!(
+                    "Far detail: {}",
+                    if self.reduced { "Reduced" } else { "Full" }
+                ),
+            ),
+        ]);
+    }
+    fn save(&self) {
+        let _ = storage::set("distance", DISTANCES[self.distance].to_string().as_bytes());
+        let _ = storage::set("detail", if self.reduced { b"reduced" } else { b"full" });
+    }
+}
+
+fn stored(key: &str) -> Option<String> {
+    storage::get(key)
+        .and_then(|v| String::from_utf8(v).ok())
+        .map(|v| v.trim().to_owned())
+}
+
+impl Mod for FarView {
+    fn init() -> Result<(Self, Registration), String> {
+        // 256 chunks and full detail, as the docs suggest; an unknown value
+        // keeps the default.
+        let far = FarView {
+            distance: stored("distance")
+                .and_then(|v| DISTANCES.iter().position(|d| d.to_string() == v))
+                .unwrap_or(2),
+            reduced: stored("detail").as_deref() == Some("reduced"),
+        };
+        far.show();
+        far.page();
+        Ok((far, Registration::new()))
+    }
+    fn ui_select(&mut self, id: u32, _row: u32) {
+        match id {
+            DISTANCE_BUTTON => self.distance = (self.distance + 1) % DISTANCES.len(),
+            DETAIL_BUTTON => self.reduced = !self.reduced,
+            _ => return,
+        }
+        self.save();
+        self.show();
+        self.page();
+    }
+    fn ui_settings_opened(&mut self) {
+        self.page();
+    }
+}
+
+horizon_mod_sdk::export_mod!(FarView);

From 7b3595b8f29cb00d0a29a40a726a1492484566b7 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:34:18 +0100
Subject: [PATCH 246/475] Draw the snow golem's pumpkin and the mooshroom's
 mushrooms

---
 crates/horizon-client/src/game/lan.rs         | 14 ++++
 crates/horizon-client/src/game/mob_blocks.rs  | 74 ++++++++++++++++++-
 .../src/game/remote_mob_data.rs               |  6 ++
 3 files changed, 93 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..c469472b5 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -223,6 +223,20 @@ fn mob_meta(
             }
             defaults.push((16, serializer::BYTE, Value::Byte(0)));
         }
+        // SnowGolem.DATA_PUMPKIN_ID: 16 while the pumpkin is on (the default).
+        "minecraft:snow_golem" => {
+            if e.sheared {
+                meta.push((16, serializer::BYTE, Value::Byte(0)));
+            }
+            defaults.push((16, serializer::BYTE, Value::Byte(16)));
+        }
+        // MushroomCow.DATA_TYPE: 0 red, 1 brown.
+        "minecraft:mooshroom" => {
+            if e.variant == 1 {
+                meta.push((17, serializer::INT, Value::Int(1)));
+            }
+            defaults.push((17, serializer::INT, Value::Int(0)));
+        }
         // Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 when sheared.
         "minecraft:sheep" => {
             let value = (e.color & 15) | if e.sheared { 16 } else { 0 };
diff --git a/crates/horizon-client/src/game/mob_blocks.rs b/crates/horizon-client/src/game/mob_blocks.rs
index 083c96a66..a0ce5e9db 100644
--- a/crates/horizon-client/src/game/mob_blocks.rs
+++ b/crates/horizon-client/src/game/mob_blocks.rs
@@ -1,6 +1,7 @@
 //! Blocks mobs carry: block items in a hand (`ItemInHandLayer`) and the
 //! block an enderman holds (`CarriedBlockLayer`), drawn as shaded cubes like
-//! dropped block items.
+//! dropped block items. Also the block models mobs wear (`SnowGolemHeadLayer`,
+//! `MushroomCowMushroomLayer`).
 use super::Game;
 use horizon_client::{
     items::ItemStack,
@@ -218,6 +219,7 @@ impl Game<'_> {
     ) {
         self.captain_banner_geometry(mob, camera, alpha, light, out);
         self.held_item_geometry(mob, camera, alpha, light, true, out);
+        self.worn_block_geometry(mob, camera, alpha, light, out);
         if mob.species() == Species::Enderman
             && let Some(state) = mob.extra.carried
             && let Some((sprite, tint)) = self.block_face_sprite(state)
@@ -244,6 +246,76 @@ impl Game<'_> {
             );
         }
     }
+    /// `SnowGolemHeadLayer` and `MushroomCowMushroomLayer`: the carved pumpkin
+    /// on a snow golem's head, and the mushrooms on an adult mooshroom's back
+    /// and head, as baked block models.
+    fn worn_block_geometry(
+        &self,
+        mob: &Mob,
+        camera: glam::DVec3,
+        alpha: f64,
+        light: u32,
+        out: &mut Vec<Vertex>,
+    ) {
+        use glam::{Mat4, Vec3};
+        let species = mob.species();
+        let on_head = match species {
+            Species::SnowGolem => !mob.extra.sheared,
+            Species::Mooshroom => !mob.is_baby(),
+            _ => false,
+        };
+        // The layers draw nothing on an invisible mob (the glow outline is not drawn).
+        if !on_head || horizon_client::mobs::trader::is_invisible(mob) {
+            return;
+        }
+        let registry = &self.pack.assets.registry;
+        let block = match species {
+            Species::SnowGolem => "minecraft:carved_pumpkin",
+            _ if mob.extra.variant == 1 => "minecraft:brown_mushroom",
+            _ => "minecraft:red_mushroom",
+        };
+        let Some(state) = registry.default_state(block) else {
+            return;
+        };
+        let alpha = alpha as f32;
+        let Some(head) = render::part_transform(mob, alpha, camera, self.res.mob_data(), "head")
+        else {
+            return;
+        };
+        let unit = Mat4::from_translation(Vec3::splat(-0.5));
+        let flip = Mat4::from_scale(Vec3::new(-1.0, -1.0, 1.0));
+        let at = |x: f32, y: f32, z: f32| Mat4::from_translation(Vec3::new(x, y, z));
+        let spin = |degrees: f32| Mat4::from_rotation_y(degrees.to_radians());
+        let transforms = if species == Species::SnowGolem {
+            vec![
+                head * at(0.0, -0.34375, 0.0)
+                    * spin(180.0)
+                    * Mat4::from_scale(Vec3::new(0.625, -0.625, -0.625))
+                    * unit,
+            ]
+        } else {
+            let base = render::base_transform(mob, alpha, camera);
+            vec![
+                base * at(0.2, -0.35, 0.5) * spin(-48.0) * flip * unit,
+                base * at(0.2, -0.35, 0.5)
+                    * spin(42.0)
+                    * at(0.1, 0.0, -0.6)
+                    * spin(-48.0)
+                    * flip
+                    * unit,
+                head * at(0.0, -0.7, -0.2) * spin(-78.0) * flip * unit,
+            ]
+        };
+        // The hurt tint reaches these blocks as it does the body.
+        let overlay = horizon_client::overlay::living(0.0, mob.hurt_time > 0 || mob.death_time > 0);
+        for t in transforms {
+            let start = out.len();
+            self.block_model_vertices(state, 0, t, light, true, out);
+            for vertex in &mut out[start..] {
+                vertex.layer = overlay;
+            }
+        }
+    }
     /// `ItemInHandLayer`: both hands through the item model pipeline; `lit`
     /// applies the level's diffuse lighting (off for GUI previews, which
     /// light the projected quads themselves).
diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs
index c6702dfb6..110281363 100644
--- a/crates/horizon-client/src/game/remote_mob_data.rs
+++ b/crates/horizon-client/src/game/remote_mob_data.rs
@@ -66,6 +66,12 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
                 m.extra.color = (*wool & 15) as u8;
                 m.extra.sheared = wool & 16 != 0;
             }
+            // SnowGolem.DATA_PUMPKIN_ID: 16 while the pumpkin is on.
+            (Species::SnowGolem, 16, Value::Byte(flags)) => m.extra.sheared = flags & 16 == 0,
+            // MushroomCow.DATA_TYPE: 0 red, 1 brown.
+            (Species::Mooshroom, 17, Value::Int(variant)) => {
+                m.extra.variant = (*variant == 1) as u8
+            }
             // TamableAnimal.DATA_FLAGS_ID: sitting 1, tame 4.
             (Species::Wolf | Species::Cat | Species::Parrot, 18, Value::Byte(flags)) => {
                 m.extra.sitting = flags & 1 != 0;

From 27b81d9a8f5390a2992385ba67ecc0902bea742a Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:35:42 +0100
Subject: [PATCH 247/475] Give /damage on a player its source, knockback and
 kill credit

---
 .../src/game/commands/world_cmds.rs           | 23 +++++----
 crates/horizon-client/src/game/creatures.rs   | 50 +++++++++++++------
 2 files changed, 47 insertions(+), 26 deletions(-)

diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs
index 687eb3f88..80145ab0d 100644
--- a/crates/horizon-client/src/game/commands/world_cmds.rs
+++ b/crates/horizon-client/src/game/commands/world_cmds.rs
@@ -140,27 +140,30 @@ impl Game<'_> {
             Some(Arg::Entity(_)) => self.entities(ctx, "entity", false)?.first().copied(),
             _ => None,
         };
+        let cause = match ctx.get("cause") {
+            Some(Arg::Entity(_)) => self.entities(ctx, "cause", false)?.first().copied(),
+            _ => None,
+        };
         let from = match ctx.get("location") {
             Some(Arg::Coords(_)) => self.position_arg(ctx, "location"),
             _ => by.and_then(|t| self.target_position(t)),
         };
         let hurt = match target {
+            // The causing mob is the one the hit is credited to and thorns
+            // answer; the source position gives the knockback its direction.
             Target::Player => {
-                if self.creative || self.spectator() {
+                if self.spectator() {
                     false
-                } else if let Some(player) = self.player.as_mut() {
-                    match self.motion.health.damage.id(&ty) {
-                        Some(id) => player
-                            .hurt(&self.motion.health, self.world.health_rules, id, amount)
-                            .unwrap_or(false),
-                        None => false,
-                    }
                 } else {
-                    false
+                    let attacker = match cause.or(by) {
+                        Some(Target::Mob(i)) => Some(Some(i)),
+                        _ => Some(None),
+                    };
+                    self.hurt_player_from(amount, from, &ty, attacker)
                 }
             }
             Target::Mob(id) => {
-                let attacker = by.and_then(|t| match t {
+                let attacker = cause.or(by).and_then(|t| match t {
                     Target::Player => Some(Who::Player),
                     Target::Mob(i) => Some(Who::Mob(i)),
                     _ => None,
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 545b306dc..a06bf80ac 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1552,6 +1552,18 @@ impl Game<'_> {
         amount: f32,
         from: [f64; 3],
         damage_type: &str,
+    ) -> bool {
+        self.hurt_player_from(amount, Some(from), damage_type, None)
+    }
+    /// `hurtServer` on the player. `from` is the source's position (none: no
+    /// direction), `known`: the causing mob when it is given (`/damage`),
+    /// else the melee attacker is the mob nearest to `from`.
+    pub(super) fn hurt_player_from(
+        &mut self,
+        amount: f32,
+        from: Option<[f64; 3]>,
+        damage_type: &str,
+        known: Option<Option<u32>>,
     ) -> bool {
         // ServerPlayer.canHarmPlayer refused another player's projectile.
         if self.creative || self.combat.refuse_player_hit {
@@ -1564,23 +1576,26 @@ impl Game<'_> {
             .damage_tags
             .get("minecraft:is_projectile")
             .is_some_and(|t| t.contains(damage_type));
-        let blocking = self.player_blocking(Some(from), damage_type, false);
+        let blocking = self.player_blocking(from, damage_type, false);
         let raised = blocking.is_some();
         // Melee: the attacker stands at `from` (another player's hit has no mob behind it).
-        let attacker = (!projectile && damage_type != "minecraft:player_attack")
-            .then(|| {
-                self.mobs
-                    .iter()
-                    .filter(|m| m.alive())
-                    .min_by(|a, b| {
-                        let d = |m: &horizon_client::mobs::Mob| {
-                            (m.position.x - from[0]).powi(2) + (m.position.z - from[2]).powi(2)
-                        };
-                        d(a).total_cmp(&d(b))
-                    })
-                    .map(|m| m.id)
-            })
-            .flatten();
+        let attacker = match known {
+            Some(known) => known,
+            None => from
+                .filter(|_| !projectile && damage_type != "minecraft:player_attack")
+                .and_then(|from| {
+                    self.mobs
+                        .iter()
+                        .filter(|m| m.alive())
+                        .min_by(|a, b| {
+                            let d = |m: &horizon_client::mobs::Mob| {
+                                (m.position.x - from[0]).powi(2) + (m.position.z - from[2]).powi(2)
+                            };
+                            d(a).total_cmp(&d(b))
+                        })
+                        .map(|m| m.id)
+                }),
+        };
         // The causing entity for the death message.
         let owner = self.combat.projectile_owner.take();
         if let Some(a) = attacker.or(owner) {
@@ -1608,7 +1623,10 @@ impl Game<'_> {
             // LivingEntity.hurtServer's dealDefaultKnockback: not inside the
             // hurt cooldown (a stronger hit there only adds its difference).
             if o.knockback {
-                let (xd, zd) = (from[0] - player.position.x, from[2] - player.position.z);
+                // No source position: a random direction.
+                let (xd, zd) = from.map_or((0.0, 0.0), |from| {
+                    (from[0] - player.position.x, from[2] - player.position.z)
+                });
                 self.knock_back_player(f64::from(0.4_f32), xd, zd);
                 if let Some(p) = self.player.as_mut()
                     && let Some(r) = p.hurt_log.last_mut()

From e23fcb1040d573c9254223af79a1f4c27c30bd35 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:35:46 +0100
Subject: [PATCH 248/475] Scale a baby's walk position when it is read, as
 vanilla does

---
 crates/horizon-client/src/mobs/anim.rs   | 3 ++-
 crates/horizon-client/src/mobs/living.rs | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs
index b81f224ae..d71b303dc 100644
--- a/crates/horizon-client/src/mobs/anim.rs
+++ b/crates/horizon-client/src/mobs/anim.rs
@@ -197,7 +197,8 @@ pub fn state(m: &Mob, alpha: f32) -> State {
     let walking = m.alive() && !m.extra.passenger;
     State {
         pos: if walking {
-            m.limb_position - m.limb_speed * (1.0 - alpha)
+            // WalkAnimationState.position(partial): babies' legs move 3 times as far.
+            (m.limb_position - m.limb_speed * (1.0 - alpha)) * if m.is_baby() { 3.0 } else { 1.0 }
         } else {
             0.0
         },
diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs
index 394821ace..e9cd42798 100644
--- a/crates/horizon-client/src/mobs/living.rs
+++ b/crates/horizon-client/src/mobs/living.rs
@@ -908,7 +908,7 @@ impl Mob {
                 (distance * 4.0).min(1.0)
             };
             self.limb_speed += (target - self.limb_speed) * 0.4;
-            self.limb_position += self.limb_speed * if self.is_baby() { 3.0 } else { 1.0 };
+            self.limb_position += self.limb_speed;
         } else {
             self.limb_speed = 0.0;
         }

From 4cf9ffd8472ef7e4c23045b503772ba5fd46d31f Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:36:40 +0100
Subject: [PATCH 249/475] Draw the autosave indicator

---
 crates/horizon-client/src/game.rs            | 13 +++++-
 crates/horizon-client/src/game/integrated.rs | 12 +++++
 crates/horizon-client/src/game/titles.rs     | 22 +++++++++
 crates/horizon-client/src/hud_overlays.rs    | 47 ++++++++++++++++++++
 4 files changed, 93 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 20f6e01bc..99c471fa6 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -1427,6 +1427,10 @@ struct Game<'a> {
     titles: titles::Titles,
     /// `Hud.toolHighlightTimer`: the selected item name.
     tool_highlight: horizon_client::hud_overlays::ToolHighlight,
+    /// `Hud.autosaveIndicatorValue`.
+    saving_indicator: horizon_client::hud_overlays::SavingIndicator,
+    /// This game's world is autosaving this tick (`MinecraftServer.isSaving`).
+    autosaving: bool,
     applied_modifiers: Vec<(String, String)>,
     experience: Experience,
     orbs: Vec<ExperienceOrb>,
@@ -4396,7 +4400,11 @@ impl Game<'_> {
             self.world.weather.tick_levels();
             self.tick_weather_effects();
         }
-        if self.ticks.is_multiple_of(6000) {
+        self.autosaving = self.ticks.is_multiple_of(6000);
+        if let Some(serving) = &self.serving {
+            serving.set_saving(self.autosaving);
+        }
+        if self.autosaving {
             self.save_game_with(false)?;
         }
         if running {
@@ -5399,6 +5407,7 @@ impl Game<'_> {
             Screen::Mod => self.draw_mod_screen(&mut batch),
             Screen::Playing | Screen::Options | Screen::Win => {}
         }
+        self.draw_saving_indicator(&mut batch);
         self.draw_toasts(&mut batch);
         self.draw_pack_toasts(&mut batch);
         self.remote_hud(&mut batch);
@@ -12689,6 +12698,8 @@ impl<'a> Game<'a> {
             command_source: None,
             titles: Default::default(),
             tool_highlight: Default::default(),
+            saving_indicator: Default::default(),
+            autosaving: false,
             applied_modifiers: Vec::new(),
             experience: Experience::default(),
             orbs: Vec::new(),
diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs
index dd1c04e23..7d81c971d 100644
--- a/crates/horizon-client/src/game/integrated.rs
+++ b/crates/horizon-client/src/game/integrated.rs
@@ -52,6 +52,8 @@ struct Flags {
     /// server follows while it runs (IntegratedServer.tickServer).
     render_distance: AtomicI32,
     simulation_distance: AtomicI32,
+    /// `MinecraftServer.isCurrentlySaving`: the server is autosaving.
+    saving: AtomicBool,
 }
 
 /// Work the window hands its server thread (`MinecraftServer.execute`).
@@ -69,6 +71,10 @@ impl Integrated {
     pub fn smoothed_tick_ms(&self) -> f32 {
         f32::from_bits(self.flags.smoothed_tick_ms.load(Ordering::Relaxed))
     }
+    /// `MinecraftServer.isCurrentlySaving`.
+    pub fn is_saving(&self) -> bool {
+        self.flags.saving.load(Ordering::Relaxed)
+    }
     /// `IntegratedServer.tickServer` skips the world while the game is paused.
     pub fn set_paused(&self, paused: bool) {
         self.flags.paused.store(paused, Ordering::Relaxed);
@@ -148,6 +154,12 @@ pub(super) struct Serving {
     /// is out of its place: applied after the tick.
     pending: Option<Publish>,
 }
+impl Serving {
+    /// The window reads this as `MinecraftServer.isCurrentlySaving`.
+    pub(super) fn set_saving(&self, saving: bool) {
+        self.flags.saving.store(saving, Ordering::Relaxed);
+    }
+}
 enum Publish {
     Open(TcpListener, LanSettings),
     Close,
diff --git a/crates/horizon-client/src/game/titles.rs b/crates/horizon-client/src/game/titles.rs
index cbae1f6b4..9bb000314 100644
--- a/crates/horizon-client/src/game/titles.rs
+++ b/crates/horizon-client/src/game/titles.rs
@@ -21,6 +21,22 @@ impl Game<'_> {
         draws.extend(self.titles.title(w, h, partial, font, background));
         hud_layout::paint(batch, &self.gui.atlas, &draws);
     }
+    /// `Hud.extractSavingIndicator`, under the screens: the option, then the
+    /// fading "Saving world" text.
+    pub(super) fn draw_saving_indicator(&self, batch: &mut HudBatch) {
+        if !self.settings.autosave_indicator {
+            return;
+        }
+        let draws = self.saving_indicator.draw(
+            batch.width as i32,
+            batch.height as i32,
+            self.clock.fraction() as f32,
+            &self.gui.atlas.font,
+            Text::literal(self.translate("menu.savingLevel", "Saving world")),
+            self.settings.text_background(0.0),
+        );
+        hud_layout::paint(batch, &self.gui.atlas, &draws);
+    }
     /// The selected stack as `Hud.tick` compares it for the name highlight.
     fn held_name(&self) -> Option<HeldName> {
         let stack = self.inventory.get(self.selected)?.as_ref()?;
@@ -44,6 +60,12 @@ impl Game<'_> {
     /// The title, action bar and selected-item parts of `Hud.tick`.
     pub(super) fn tick_hud(&mut self) {
         self.titles.tick();
+        // `MinecraftServer.isCurrentlySaving` of single player's server.
+        let saving = self
+            .integrated
+            .as_ref()
+            .map_or(self.autosaving, |server| server.is_saving());
+        self.saving_indicator.tick(saving);
         let held = self.held_name();
         self.tool_highlight
             .tick(held, f64::from(self.settings.notification_display_time));
diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs
index ebd860e08..c6b098f75 100644
--- a/crates/horizon-client/src/hud_overlays.rs
+++ b/crates/horizon-client/src/hud_overlays.rs
@@ -191,6 +191,53 @@ pub fn effects(w: i32, demo: bool, effects: &[EffectIcon]) -> Vec<GuiDraw> {
     out
 }
 
+/// The saving indicator: `Hud.tickAutosaveIndicator` fades a value towards 1
+/// while the server is saving and `extractSavingIndicator` draws the text.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct SavingIndicator {
+    last: f32,
+    value: f32,
+}
+impl SavingIndicator {
+    /// `Hud.tickAutosaveIndicator`: `Mth.lerp(0.2F, value, saving ? 1 : 0)`.
+    pub fn tick(&mut self, saving: bool) {
+        self.last = self.value;
+        self.value += (if saving { 1.0 } else { 0.0 } - self.value) * 0.2;
+    }
+    /// `Hud.extractSavingIndicator` without the option check: the text in the
+    /// bottom right corner.
+    pub fn draw(
+        &self,
+        w: i32,
+        h: i32,
+        partial: f32,
+        font: &Font,
+        label: Text,
+        background: u32,
+    ) -> Vec<GuiDraw> {
+        let mut out = Vec::new();
+        if self.value <= 0.0 && self.last <= 0.0 {
+            return out;
+        }
+        let fade = (self.last + (self.value - self.last) * partial).clamp(0.0, 1.0);
+        let alpha = (255.0 * fade).floor() as u32;
+        if alpha > 0 {
+            let label_width = width(font, &label);
+            let color = crate::hud_layout::argb(alpha, 255, 255, 255);
+            text_with_backdrop(
+                &mut out,
+                label,
+                w - label_width - 5,
+                h - 9 - 5,
+                label_width,
+                color,
+                background,
+            );
+        }
+        out
+    }
+}
+
 /// Titles and the action bar: `Hud.title`, `subtitle`, `titleTime`, the
 /// fade times and `overlayMessageString` / `overlayMessageTime`.
 #[derive(Clone, Debug, PartialEq)]

From ffc343aadd48cefd6d4aa95c6fa946ae9f6310f8 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:37:39 +0100
Subject: [PATCH 250/475] Make execute on origin and leasher find their entity

---
 .../src/game/commands/execute.rs              | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/crates/horizon-client/src/game/commands/execute.rs b/crates/horizon-client/src/game/commands/execute.rs
index 3f7e4c2a0..88d24e9bc 100644
--- a/crates/horizon-client/src/game/commands/execute.rs
+++ b/crates/horizon-client/src/game/commands/execute.rs
@@ -606,6 +606,68 @@ impl Game<'_> {
                     .collect(),
                 _ => Vec::new(),
             },
+            // Leashable.getLeashHolder: a fence knot is not an entity here.
+            Some("leasher") => match entity {
+                Target::Mob(id) => self
+                    .mobs
+                    .iter()
+                    .find(|m| m.id == id)
+                    .and_then(|m| m.extra.leash)
+                    .and_then(|holder| match holder {
+                        horizon_client::mobs::leash::Holder::Player => Some(Target::Player),
+                        horizon_client::mobs::leash::Holder::Mob(i) => Some(Target::Mob(i)),
+                        horizon_client::mobs::leash::Holder::Knot(_) => None,
+                    })
+                    .into_iter()
+                    .collect(),
+                _ => Vec::new(),
+            },
+            // TraceableEntity.getOwner: who shot a projectile, who threw an
+            // item, who summoned a vex.
+            Some("origin") => match entity {
+                Target::Projectile(i) => self
+                    .creatures
+                    .projectiles
+                    .get(i)
+                    .and_then(|p| match (p.owner?, p.guest) {
+                        // A guest's shot: `Who::Player` is them.
+                        (horizon_client::mobs::Who::Player, Some(conn))
+                            if self.lan_acting == Some(conn) =>
+                        {
+                            Some(Target::Player)
+                        }
+                        (horizon_client::mobs::Who::Player, Some(conn)) => {
+                            Some(Target::Guest(conn))
+                        }
+                        (horizon_client::mobs::Who::Player, None) => Some(Target::Player),
+                        (horizon_client::mobs::Who::Mob(id), _) => Some(Target::Mob(id)),
+                    })
+                    .into_iter()
+                    .collect(),
+                Target::Item(id) => self
+                    .dropped
+                    .iter()
+                    .find(|d| d.id == id)
+                    .and_then(|d| d.thrower)
+                    .and_then(|words| {
+                        let uuid = words
+                            .iter()
+                            .fold(0u128, |all, w| all << 32 | u128::from(*w as u32));
+                        self.target_by_uuid(uuid)
+                    })
+                    .into_iter()
+                    .collect(),
+                Target::Mob(id) => self
+                    .mobs
+                    .iter()
+                    .find(|m| m.id == id && m.kind.id == "minecraft:vex")
+                    .map(|m| m.extra.counter2 as u32)
+                    .filter(|owner| *owner != 0)
+                    .map(Target::Mob)
+                    .into_iter()
+                    .collect(),
+                _ => Vec::new(),
+            },
             Some("vehicle") => self.ride_vehicle(entity).into_iter().collect(),
             Some("controller") | Some("passengers") => match entity {
                 Target::Mob(id) if self.mobs.iter().any(|m| m.id == id && m.rider.is_some()) => {

From b92a53e47cbed57d92d0c6a38f605dd8cec12ec9 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:37:52 +0100
Subject: [PATCH 251/475] Swing and pose the main arm of a left-handed mob

---
 .../examples/probe/entity_anim_fixture.rs     |  1 +
 crates/horizon-client/src/mobs/anim.rs        | 39 +++++++++-----
 crates/horizon-client/src/mobs/illager.rs     | 11 ++--
 crates/horizon-client/src/mobs/piglin.rs      | 52 +++++++++++--------
 4 files changed, 67 insertions(+), 36 deletions(-)

diff --git a/crates/horizon-client/examples/probe/entity_anim_fixture.rs b/crates/horizon-client/examples/probe/entity_anim_fixture.rs
index 4aceb9f6f..4582033fe 100644
--- a/crates/horizon-client/examples/probe/entity_anim_fixture.rs
+++ b/crates/horizon-client/examples/probe/entity_anim_fixture.rs
@@ -592,6 +592,7 @@ pub fn main() -> horizon_client::Result<()> {
                     pose,
                     num("maxCrossbowChageDuration"),
                     num("ticksUsingItem"),
+                    false,
                 );
             }
             Species::Evoker | Species::Illusioner | Species::Pillager | Species::Vindicator => {
diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs
index b81f224ae..c183aa59d 100644
--- a/crates/horizon-client/src/mobs/anim.rs
+++ b/crates/horizon-client/src/mobs/anim.rs
@@ -248,18 +248,24 @@ pub enum ArmPose {
 pub fn humanoid_pub(p: &mut Poses, s: &State, _m: &Mob) {
     humanoid(p, s, &Hum::new(ArmPose::Empty, ArmPose::Empty));
 }
-/// `AnimationUtils.swingWeaponDown` with the right arm as the main arm.
-pub(super) fn swing_weapon_down(p: &mut Poses, swing: f32, age: f32) {
+/// `AnimationUtils.swingWeaponDown`: the main arm swings down, the other
+/// one hangs and bobs.
+pub(super) fn swing_weapon_down(p: &mut Poses, swing: f32, age: f32, left_main: bool) {
     let attack2 = (swing * PI).msin();
     let attack = ((1.0 - (1.0 - swing) * (1.0 - swing)) * PI).msin();
+    let (main, off) = if left_main {
+        ("left_arm", "right_arm")
+    } else {
+        ("right_arm", "left_arm")
+    };
     p.zrot("right_arm", 0.0);
     p.zrot("left_arm", 0.0);
     p.yrot("right_arm", PI / 20.0);
     p.yrot("left_arm", -PI / 20.0);
-    p.xrot("right_arm", -1.884_955_8 + (age * 0.09).mcos() * 0.15);
-    p.xrot("left_arm", -0.0 + (age * 0.19).mcos() * 0.5);
-    p.get("right_arm")[3] += attack2 * 2.2 - attack * 0.4;
-    p.get("left_arm")[3] += attack2 * 1.2 - attack * 0.4;
+    p.xrot(main, -1.884_955_8 + (age * 0.09).mcos() * 0.15);
+    p.xrot(off, -0.0 + (age * 0.19).mcos() * 0.5);
+    p.get(main)[3] += attack2 * 2.2 - attack * 0.4;
+    p.get(off)[3] += attack2 * 1.2 - attack * 0.4;
     bob(p, "right_arm", age, 1.0);
     bob(p, "left_arm", age, -1.0);
 }
@@ -286,6 +292,8 @@ pub struct Hum {
     pub using_item: bool,
     /// The arm the current swing moves (`Some(true)` for the right one).
     pub swing_right_arm: Option<bool>,
+    /// `mainArm` is the left one (`Mob.isLeftHanded`): a mob's swing uses it.
+    pub left_main: bool,
 }
 impl Hum {
     pub fn new(right: ArmPose, left: ArmPose) -> Self {
@@ -303,6 +311,7 @@ impl Hum {
             swim: 0.0,
             using_item: false,
             swing_right_arm: None,
+            left_main: false,
         }
     }
 }
@@ -315,7 +324,7 @@ impl ArmPose {
     }
 }
 /// `AnimationUtils.animateCrossbowHold`.
-fn crossbow_hold(p: &mut Poses, hx: f32, hy: f32, in_right: bool) {
+pub(super) fn crossbow_hold(p: &mut Poses, hx: f32, hy: f32, in_right: bool) {
     let (hold, shoot) = if in_right {
         ("right_arm", "left_arm")
     } else {
@@ -327,7 +336,7 @@ fn crossbow_hold(p: &mut Poses, hx: f32, hy: f32, in_right: bool) {
     p.xrot(shoot, -1.5 + hx);
 }
 /// `AnimationUtils.animateCrossbowCharge`.
-fn crossbow_charge(p: &mut Poses, max: f32, ticks: f32, in_right: bool) {
+pub(super) fn crossbow_charge(p: &mut Poses, max: f32, ticks: f32, in_right: bool) {
     let (hold, pull) = if in_right {
         ("right_arm", "left_arm")
     } else {
@@ -418,13 +427,17 @@ pub(super) fn humanoid(p: &mut Poses, s: &State, h: &Hum) {
             pose_arm(p, h.right, true, h);
         }
     }
-    // setupAttackAnimation (WHACK swing with the right arm).
+    // setupAttackAnimation (WHACK swing with the arm of the swinging hand).
     let hx = p.get("head")[3];
     let swing = s.swing;
+    let swing_left = h.swing_right_arm.map_or(h.left_main, |right| !right);
     if swing > 0.0 && h.weapon_swing {
-        swing_weapon_down(p, swing, s.age);
+        swing_weapon_down(p, swing, s.age, h.left_main);
     } else if swing > 0.0 {
-        let body_y = (swing.sqrt() * PI * 2.0).msin() * 0.2;
+        let mut body_y = (swing.sqrt() * PI * 2.0).msin() * 0.2;
+        if swing_left {
+            body_y = -body_y;
+        }
         p.yrot("body", body_y);
         let age_scale = if s.baby { 0.5 } else { 1.0 };
         {
@@ -444,7 +457,7 @@ pub(super) fn humanoid(p: &mut Poses, s: &State, h: &Hum) {
         let eased = 1.0 - (1.0 - swing).powi(4);
         let aa = (eased * PI).msin();
         let bb = (swing * PI).msin() * -(hx - 0.7) * 0.75;
-        let r = p.get("right_arm");
+        let r = p.get(if swing_left { "left_arm" } else { "right_arm" });
         r[3] -= aa * 1.2 + bb;
         r[4] += body_y * 2.0;
         r[5] += (swing * PI).msin() * -0.4;
@@ -652,6 +665,7 @@ pub fn setup(
             } else {
                 Hum::new(main, ArmPose::Empty)
             };
+            h.left_main = m.main_arm_left();
             h.zombie = Some(m.ai.aggressive);
             h.holding = m.extra.main_hand.is_some();
             h.crouching = m.extra.crouching;
@@ -715,6 +729,7 @@ pub fn setup(
             h.swim = m.extra.swim.amount(s.partial);
             h.using_item = m.extra.using_item > 0;
             h.swing_right_arm = m.extra.swing_right_arm;
+            h.left_main = m.main_arm_left();
             humanoid(p, s, &h);
             if m.ai.aggressive && !bow {
                 // SkeletonModel melee pose.
diff --git a/crates/horizon-client/src/mobs/illager.rs b/crates/horizon-client/src/mobs/illager.rs
index a037e7c5f..9bdfec3e2 100644
--- a/crates/horizon-client/src/mobs/illager.rs
+++ b/crates/horizon-client/src/mobs/illager.rs
@@ -672,7 +672,12 @@ pub fn anim_pose(m: &Mob, s: &State, p: &mut Poses, pose: ArmPose) {
                 p.xrot("right_arm", x + a * 1.2 - b * 0.4);
                 p.xrot("left_arm", x + a * 1.2 - b * 0.4);
             } else {
-                // swingWeaponDown (right-handed).
+                // swingWeaponDown: the main arm swings down.
+                let (main, off) = if m.main_arm_left() {
+                    ("left_arm", "right_arm")
+                } else {
+                    ("right_arm", "left_arm")
+                };
                 let swing = s.swing;
                 let a2 = (swing * PI).msin();
                 let a = ((1.0 - (1.0 - swing) * (1.0 - swing)) * PI).msin();
@@ -681,11 +686,11 @@ pub fn anim_pose(m: &Mob, s: &State, p: &mut Poses, pose: ArmPose) {
                 p.yrot("right_arm", PI / 20.0);
                 p.yrot("left_arm", -PI / 20.0);
                 p.xrot(
-                    "right_arm",
+                    main,
                     -1.884_955_8 + (s.age * 0.09).mcos() * 0.15 + (a2 * 2.2 - a * 0.4),
                 );
                 p.xrot(
-                    "left_arm",
+                    off,
                     -0.0 + (s.age * 0.19).mcos() * 0.5 + (a2 * 1.2 - a * 0.4),
                 );
             }
diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs
index de9ba42dd..a057581e6 100644
--- a/crates/horizon-client/src/mobs/piglin.rs
+++ b/crates/horizon-client/src/mobs/piglin.rs
@@ -431,7 +431,14 @@ pub fn piglin_anim(m: &Mob, s: &State, p: &mut Poses) {
     } else {
         PiglinPose::Default
     };
-    piglin_pose(p, s, pose, 25.0, m.extra.using_item as f32);
+    piglin_pose(
+        p,
+        s,
+        pose,
+        25.0,
+        m.extra.using_item as f32,
+        m.main_arm_left(),
+    );
 }
 /// `PiglinArmPose`.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -443,11 +450,19 @@ pub enum PiglinPose {
     CrossbowCharge,
     AdmiringItem,
 }
-/// `PiglinModel.setupAnim` for a piglin facing right-handed.
-pub fn piglin_pose(p: &mut Poses, s: &State, pose: PiglinPose, max_charge: f32, ticks: f32) {
-    use super::anim::{ArmPose, Hum, humanoid};
+/// `PiglinModel.setupAnim`; `left` when the piglin's main arm is the left one.
+pub fn piglin_pose(
+    p: &mut Poses,
+    s: &State,
+    pose: PiglinPose,
+    max_charge: f32,
+    ticks: f32,
+    left: bool,
+) {
+    use super::anim::{ArmPose, Hum, crossbow_charge, crossbow_hold, humanoid};
     let mut h = Hum::new(ArmPose::Empty, ArmPose::Empty);
     h.weapon_swing = pose == PiglinPose::MeleeWeapon;
+    h.left_main = left;
     h.charge = (max_charge, ticks);
     humanoid(p, s, &h);
     ears(p, s);
@@ -474,27 +489,22 @@ pub fn piglin_pose(p: &mut Poses, s: &State, pose: PiglinPose, max_charge: f32,
             p.get("left_arm")[1] += (dance * 40.0).msin() * 0.5 + 0.5;
             p.get("body")[1] += (dance * 40.0).msin() * 0.35;
         }
-        PiglinPose::MeleeWeapon if s.swing == 0.0 => p.xrot("right_arm", -1.8),
-        PiglinPose::CrossbowHold => {
-            p.yrot("right_arm", -0.3 + hy);
-            p.yrot("left_arm", 0.6 + hy);
-            p.xrot("right_arm", -PI / 2.0 + hx + 0.1);
-            p.xrot("left_arm", -1.5 + hx);
-        }
-        PiglinPose::CrossbowCharge => {
-            p.yrot("right_arm", -0.8);
-            p.xrot("right_arm", -0.970_796_35);
-            p.xrot("left_arm", -0.970_796_35);
-            let alpha = ticks.clamp(0.0, max_charge) / max_charge;
-            p.yrot("left_arm", 0.4 + alpha * (0.85 - 0.4));
-            let x = -0.970_796_35 + alpha * (-PI / 2.0 - -0.970_796_35);
-            p.xrot("left_arm", x);
+        // holdWeaponHigh
+        PiglinPose::MeleeWeapon if s.swing == 0.0 => {
+            p.xrot(if left { "left_arm" } else { "right_arm" }, -1.8)
         }
+        PiglinPose::CrossbowHold => crossbow_hold(p, hx, hy, !left),
+        PiglinPose::CrossbowCharge => crossbow_charge(p, max_charge, ticks, !left),
         PiglinPose::AdmiringItem => {
             p.xrot("head", 0.5);
             p.yrot("head", 0.0);
-            p.yrot("left_arm", 0.5);
-            p.xrot("left_arm", -0.9);
+            if left {
+                p.yrot("right_arm", -0.5);
+                p.xrot("right_arm", -0.9);
+            } else {
+                p.yrot("left_arm", 0.5);
+                p.xrot("left_arm", -0.9);
+            }
         }
         _ => {}
     }

From 46b71954e162c8b355e26d8afb132d2060bf5fcf Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:38:38 +0100
Subject: [PATCH 252/475] Make the High Contrast option turn its resource pack
 on and off

---
 crates/horizon-client/src/options_ui.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs
index 61fda9878..b6a3a0f3e 100644
--- a/crates/horizon-client/src/options_ui.rs
+++ b/crates/horizon-client/src/options_ui.rs
@@ -2533,6 +2533,17 @@ impl OptionsUi {
                             if opt == Opt::Preset {
                                 apply_preset(s);
                             }
+                            if opt == Opt::HighContrast {
+                                // Options.highContrast: the built-in pack follows the option.
+                                let on = s.resource_packs.iter().any(|id| id == "high_contrast");
+                                if on != s.high_contrast {
+                                    s.resource_packs.retain(|id| id != "high_contrast");
+                                    if s.high_contrast {
+                                        s.resource_packs.push("high_contrast".into());
+                                    }
+                                    events.push(Event::Packs(s.resource_packs.clone()));
+                                }
+                            }
                             events.push(Event::Changed);
                         }
                         Act::Extra(item) => {

From 8920f08fd9724262e03220a561518b0d9a252b7b Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 19:07:44 +0100
Subject: [PATCH 253/475] Streaming: rank queued jobs again when the centre or
 the loading screen changes

Jobs queued while the loading screen was up carried ring-order priorities,
far above the plain distances used once it closed, so they waited behind
every later job. The proto chunks they generated held back the decoration
of the chunks around the player: at render distance 32 in-frame, nothing
was decorated until every proto chunk had been generated. Queued jobs now
keep their column and bias and are ranked again from the current centre,
extra areas, band and loading screen when those change, as vanilla's
chunk task queue follows the current ticket levels.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/streaming.rs | 122 +++++++++++++++++++++++--
 1 file changed, 113 insertions(+), 9 deletions(-)

diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs
index 643a604bc..0c9ae0c5b 100644
--- a/crates/horizon-client/src/streaming.rs
+++ b/crates/horizon-client/src/streaming.rs
@@ -175,6 +175,11 @@ pub enum Done {
 }
 struct Queued {
     priority: i64,
+    /// The column the job is for and what it adds to the column's distance
+    /// (`Streaming::submit`): the priority is computed again from them when
+    /// the centre moves (`Streaming::requeue`). None for saves, which go first.
+    at: Option<(i32, i32)>,
+    bias: i64,
     order: u64,
     job: Job,
 }
@@ -222,6 +227,9 @@ pub struct Streaming {
     /// radius it was last ranked for.
     decoration_order: DecorationOrder,
     order_area: Option<((i32, i32), i32)>,
+    /// What the queued jobs' priorities were computed from (`requeue`): the
+    /// centre, the loading screen, the band, and the extra areas.
+    queue_basis: (((i32, i32), bool, Option<Band>), Vec<((i32, i32), i32)>),
     finishing: FxHashSet<(i32, i32)>,
     decorates: bool,
     lighting: FxHashMap<(i32, i32), u64>,
@@ -544,6 +552,7 @@ impl Streaming {
             saving: 0,
             decoration_order: DecorationOrder::default(),
             order_area: None,
+            queue_basis: Default::default(),
             finishing: Default::default(),
             decorates: generator.decorates(),
             lighting: Default::default(),
@@ -648,15 +657,39 @@ impl Streaming {
         world.dirty_sections.take_column(x, z);
         world.chunks.remove(&(x, z))
     }
-    fn submit(&mut self, priority: i64, job: Job) {
+    /// Queue a job for the column `at`, nearest first: its distance (`distance`)
+    /// times four plus `bias`, which orders a column's jobs. A job without a
+    /// column (a save) goes ahead of every other.
+    fn submit(&mut self, at: Option<(i32, i32)>, bias: i64, job: Job) {
         self.order += 1;
+        let priority = at.map_or(i64::MIN, |(x, z)| self.distance(x, z) * 4 + bias);
         self.shared.queue.lock().unwrap().push(Queued {
             priority,
+            at,
+            bias,
             order: self.order,
             job,
         });
         self.shared.ready.notify_one();
     }
+    /// Rank the queued jobs again when what their priorities were computed
+    /// from changed: the centre, the extra areas, the band, or the loading
+    /// screen (ring order, `Ranges::rings`, whose values are far above the
+    /// distances used after it). Vanilla's chunk task queue follows the
+    /// current ticket levels in the same way. Without it, generation queued
+    /// while the loading screen was up waited behind every job queued after
+    /// it, and with it the decoration of the chunks around the player: at
+    /// render distance 32 nothing was decorated until every proto chunk had
+    /// been generated.
+    fn requeue(&mut self) {
+        let basis = (self.center, self.loading, self.band);
+        if self.queue_basis.0 == basis && self.queue_basis.1 == self.extra {
+            return;
+        }
+        self.queue_basis = (basis, self.extra.clone());
+        let mut queue = self.shared.queue.lock().unwrap();
+        rank_again(&mut queue, |x, z| self.distance(x, z));
+    }
     fn receive_decorated(&mut self, x: i32, z: i32, region: [Proto; 9]) {
         self.generation_scan.exhausted = false;
         self.decorating -= 1;
@@ -686,7 +719,7 @@ impl Streaming {
             self.saving += 1;
             // Ahead of every other job: a column generated again meanwhile
             // would not find them saved.
-            self.submit(i64::MIN, Job::Save(protos));
+            self.submit(None, 0, Job::Save(protos));
         }
     }
     fn receive_generated(&mut self, mut chunk: Chunk, world: &mut World) {
@@ -829,6 +862,7 @@ impl Streaming {
             return (uploads, Vec::new());
         }
         ExtraCover::refresh(&mut self.cover, &self.extra);
+        self.requeue();
         self.relight_edits(world);
         let deferred = std::mem::take(&mut self.deferred);
         let received = std::iter::from_fn(|| self.results.try_recv().ok());
@@ -984,7 +1018,7 @@ impl Streaming {
                     .expect("present proto");
                 self.finishing.insert((x, z));
                 self.written.remove(&(x, z));
-                self.submit(self.distance(x, z) * 4, Job::Finish(proto));
+                self.submit(Some((x, z)), 0, Job::Finish(proto));
             }
         }
         // Decorate chunks whose 3x3 proto neighbourhood is available, in
@@ -1052,7 +1086,7 @@ impl Streaming {
                 w.0 = self.decoration_order.rank_or_append(w.2, w.3);
             }
             wanted.sort_unstable();
-            for (_, d, x, z) in wanted {
+            for (_, _, x, z) in wanted {
                 if self.decorating >= workers * 2 {
                     break;
                 }
@@ -1091,7 +1125,7 @@ impl Streaming {
                     Err(_) => continue,
                 };
                 self.decorating += 1;
-                self.submit(d * 4 + 1, Job::Decorate(x, z, region));
+                self.submit(Some((x, z)), 1, Job::Decorate(x, z, region));
             }
         }
         self.schedule_generation(world, workers);
@@ -1111,7 +1145,8 @@ impl Streaming {
             self.light_snapshots
                 .insert((x, z), self.light_edit_sequence);
             self.submit(
-                self.distance(x, z) * 4 + 1,
+                Some((x, z)),
+                1,
                 Job::Light(x, z, region, self.sequence, self.sky_light),
             );
         }
@@ -1183,7 +1218,8 @@ impl Streaming {
                 self.sequence += 1;
                 self.meshing.insert((x, sy, z), self.sequence);
                 self.submit(
-                    self.distance(x, z) * 4 + if first { 2 } else { 0 },
+                    Some((x, z)),
+                    if first { 2 } else { 0 },
                     Job::Mesh(
                         x,
                         sy,
@@ -1222,9 +1258,9 @@ impl Streaming {
             loading: self.loading,
         };
         if let Some(wanted) = self.generation_scan.candidates(input, workers * 3) {
-            for (d, x, z) in wanted {
+            for (_, x, z) in wanted {
                 self.generating.insert((x, z));
-                self.submit(d * 4, Job::Generate(x, z));
+                self.submit(Some((x, z)), 0, Job::Generate(x, z));
             }
         }
     }
@@ -1738,10 +1774,78 @@ fn section_indexes(mut bits: u32) -> impl Iterator<Item = i32> {
         })
     })
 }
+/// The queued jobs' priorities computed again from each one's column
+/// `distance` (`Streaming::submit`).
+fn rank_again(queue: &mut BinaryHeap<Queued>, distance: impl Fn(i32, i32) -> i64) {
+    if queue.is_empty() {
+        return;
+    }
+    let mut jobs = std::mem::take(queue).into_vec();
+    for job in &mut jobs {
+        if let Some((x, z)) = job.at {
+            job.priority = distance(x, z) * 4 + job.bias;
+        }
+    }
+    *queue = BinaryHeap::from(jobs);
+}
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn queued_jobs_follow_the_centre_and_the_loading_screen() {
+        let forced = HashSet::new();
+        let ranges = |center| Ranges {
+            center,
+            radius: 32,
+            extra: &[],
+            forced: &forced,
+            cover: None,
+            band: None,
+        };
+        let generate = |x, z, priority, order| Queued {
+            priority,
+            at: Some((x, z)),
+            bias: 0,
+            order,
+            job: Job::Generate(x, z),
+        };
+        let loading = ranges((0, 0));
+        let queued = || {
+            BinaryHeap::from(vec![
+                // Queued while the loading screen was up: ring order.
+                generate(3, 1, loading.priority(3, 1, true) * 4, 1),
+                // Queued after it closed: plain distances, far below any ring past the first.
+                generate(20, 0, loading.priority(20, 0, false) * 4, 2),
+                Queued {
+                    priority: i64::MIN,
+                    at: None,
+                    bias: 0,
+                    order: 3,
+                    job: Job::Save(Vec::new()),
+                },
+            ])
+        };
+        let pops = |mut queue: BinaryHeap<Queued>| {
+            std::iter::from_fn(move || queue.pop())
+                .map(|q| q.at)
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(
+            pops(queued()),
+            [None, Some((20, 0)), Some((3, 1))],
+            "the stale order"
+        );
+        let mut queue = queued();
+        rank_again(&mut queue, |x, z| loading.priority(x, z, false));
+        assert_eq!(pops(queue), [None, Some((3, 1)), Some((20, 0))]);
+        // The player moved: the job near the new centre goes first.
+        let mut queue = BinaryHeap::from(vec![generate(3, 1, 0, 1), generate(20, 0, 1, 2)]);
+        let moved = ranges((19, 0));
+        rank_again(&mut queue, |x, z| moved.priority(x, z, false));
+        assert_eq!(queue.pop().and_then(|q| q.at), Some((20, 0)));
+    }
+
     #[test]
     fn view_distance_is_vanillas_shape() {
         // ChunkTrackingView.isInViewDistance at render distance 12: a column

From 4201fd23c0dda6ab5ff3624cc79e4c322800980c Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:39:05 +0100
Subject: [PATCH 254/475] Use real eye heights in /execute and keep the anchor
 on positioned as

---
 .../src/game/commands/execute.rs              | 40 ++++++++++++++++++-
 1 file changed, 38 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/commands/execute.rs b/crates/horizon-client/src/game/commands/execute.rs
index 3f7e4c2a0..c48cd8adf 100644
--- a/crates/horizon-client/src/game/commands/execute.rs
+++ b/crates/horizon-client/src/game/commands/execute.rs
@@ -145,9 +145,44 @@ impl Game<'_> {
                 .iter()
                 .find(|m| m.id == id)
                 .map_or(0.0, |m| m.eye_y() - m.position.y),
-            _ => 0.0,
+            // An armor stand's dimensions are halved when small and empty
+            // when a marker (ArmorStand.getDefaultDimensions).
+            Target::Stand(id) => {
+                let stand = self.armor_stands.iter().find(|a| a.id == id);
+                let scale = match stand {
+                    Some(a) if a.marker => 0.0,
+                    Some(a) if a.small => 0.5,
+                    _ => 1.0,
+                };
+                scale * self.type_eye_height(&self.target_type(t))
+            }
+            // Entity.getEyeHeight: the type's dimensions.
+            _ => self.type_eye_height(&self.target_type(t)),
         }
     }
+    /// `EntityType.getDimensions().eyeHeight()` from `entity-types.json`,
+    /// read once.
+    fn type_eye_height(&self, ty: &str) -> f64 {
+        static EYE_HEIGHTS: std::sync::OnceLock<std::collections::HashMap<String, f64>> =
+            std::sync::OnceLock::new();
+        EYE_HEIGHTS
+            .get_or_init(|| {
+                std::fs::read(self.options.resources.join("entity-types.json"))
+                    .ok()
+                    .and_then(|b| serde_json::from_slice::<serde_json::Value>(&b).ok())
+                    .and_then(|v| {
+                        v.as_object().map(|o| {
+                            o.iter()
+                                .filter_map(|(k, t)| Some((k.clone(), t["eye_height"].as_f64()?)))
+                                .collect()
+                        })
+                    })
+                    .unwrap_or_default()
+            })
+            .get(ty)
+            .copied()
+            .unwrap_or(0.0)
+    }
     /// EntityAnchorArgument.Anchor.apply.
     pub(super) fn anchor_position(&self, s: &Source) -> [f64; 3] {
         match s.entity {
@@ -467,9 +502,10 @@ impl Game<'_> {
             "positioned" if c.has("as") => targets(self)?
                 .into_iter()
                 .filter_map(|t| {
+                    // withPosition keeps the anchor (only `positioned <pos>`
+                    // resets it to the feet).
                     Some(Source {
                         pos: self.target_position(t)?,
-                        eyes: false,
                         ..s
                     })
                 })

From ad6f2320b0a6bbfaa016f9b1f978d8348989015a Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:40:06 +0100
Subject: [PATCH 255/475] Wire the Music Frequency option to the music manager

---
 crates/horizon-client/src/game.rs       |  9 ++++++++-
 crates/horizon-client/src/game/music.rs |  7 ++++++-
 crates/horizon-client/src/options_ui.rs | 15 ++++++++++++++-
 3 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 20f6e01bc..0e4756abf 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -12645,7 +12645,14 @@ impl<'a> Game<'a> {
             level,
             session_lock: None,
             audio,
-            music: Default::default(),
+            music: {
+                // The manager starts with the saved option (MusicManager's constructor).
+                let mut music = horizon_client::music::MusicManager::default();
+                music.frequency = horizon_client::music::MusicFrequency::parse(
+                    &settings.file.name("musicFrequency"),
+                );
+                music
+            },
             ambience: Default::default(),
             sound_paused: false,
             cart_sounds: HashSet::new(),
diff --git a/crates/horizon-client/src/game/music.rs b/crates/horizon-client/src/game/music.rs
index fa5e71f7b..97ca3763e 100644
--- a/crates/horizon-client/src/game/music.rs
+++ b/crates/horizon-client/src/game/music.rs
@@ -3,7 +3,7 @@
 use super::Game;
 use horizon_client::{
     blocks::Fluid,
-    music::{BackgroundMusic, Music, Situation},
+    music::{BackgroundMusic, Music, MusicFrequency, Situation},
     sound_engine::TickContext,
 };
 
@@ -11,6 +11,11 @@ impl Game<'_> {
     /// `Minecraft.tick` -> `MusicManager.tick`, once per client tick.
     pub(super) fn tick_music(&mut self) {
         let (music, volume) = self.situational_music();
+        // Options.musicFrequency's listener: MusicManager.setMinutesBetweenSongs.
+        let frequency = MusicFrequency::parse(&self.settings.file.name("musicFrequency"));
+        if frequency != self.music.frequency {
+            self.music.set_frequency(frequency, music.as_ref());
+        }
         // LevelLoadingScreen: no new track before the player is in the world.
         let loading = self.title.is_none() && self.player.is_none() && self.win.is_none();
         self.music
diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs
index 61fda9878..50eb50f6f 100644
--- a/crates/horizon-client/src/options_ui.rs
+++ b/crates/horizon-client/src/options_ui.rs
@@ -67,6 +67,7 @@ pub enum Opt {
     ReducedDebugInfo,
     HighContrast,
     ShowSubtitles,
+    MusicFrequency,
     NotificationDisplayTime,
     Narrator,
     TextBackground,
@@ -192,6 +193,7 @@ impl Opt {
             Opt::NarratorHotkey => "narratorHotkey",
             Opt::RotateWithMinecarts => "rotateWithMinecart",
             Opt::HighContrastBlockOutlines => "highContrastBlockOutline",
+            Opt::MusicFrequency => "musicFrequency",
             _ => return None,
         })
     }
@@ -248,6 +250,7 @@ impl Opt {
             Opt::ReducedDebugInfo => "options.reducedDebugInfo",
             Opt::HighContrast => "options.accessibility.high_contrast",
             Opt::ShowSubtitles => "options.showSubtitles",
+            Opt::MusicFrequency => "options.music_frequency",
             Opt::NotificationDisplayTime => "options.notifications.display_time",
             Opt::Narrator => "options.narrator",
             Opt::TextBackground => "options.accessibility.text_background",
@@ -578,6 +581,11 @@ impl Opt {
             Opt::ReducedDebugInfo => on_off(s.reduced_debug_info),
             Opt::HighContrast => on_off(s.high_contrast),
             Opt::ShowSubtitles => on_off(s.show_subtitles),
+            Opt::MusicFrequency => tr([
+                "options.music_frequency.default",
+                "options.music_frequency.frequent",
+                "options.music_frequency.constant",
+            ][s.file.int("musicFrequency").clamp(0, 2) as usize]),
             Opt::ForceUnicode => on_off(s.force_unicode),
             Opt::JapaneseGlyphs => on_off(s.japanese_glyphs),
             Opt::PadEnabled => on_off(s.controller.enabled),
@@ -747,6 +755,11 @@ impl Opt {
             Opt::ReducedDebugInfo => s.reduced_debug_info = !s.reduced_debug_info,
             Opt::HighContrast => s.high_contrast = !s.high_contrast,
             Opt::ShowSubtitles => s.show_subtitles = !s.show_subtitles,
+            Opt::MusicFrequency => {
+                let n = next(s.file.int("musicFrequency").clamp(0, 2) as u8, 3);
+                s.file
+                    .set("musicFrequency", crate::options_file::V::Int(i32::from(n)));
+            }
             Opt::ForceUnicode => s.force_unicode = !s.force_unicode,
             Opt::JapaneseGlyphs => s.japanese_glyphs = !s.japanese_glyphs,
             Opt::PadEnabled => s.controller.enabled = !s.controller.enabled,
@@ -1411,7 +1424,7 @@ impl OptionsUi {
                 let mut rows = vec![Row::Big(Opt::Volume(0))];
                 let others: Vec<Opt> = (1..SOUND_SOURCES.len()).map(Opt::Volume).collect();
                 rows.extend(pairs(&others));
-                rows.extend(pairs(&[Opt::ShowSubtitles]));
+                rows.extend(pairs(&[Opt::ShowSubtitles, Opt::MusicFrequency]));
                 rows
             }
             Page::Controls => {

From 36c06d6133a3e09d95c5027aa89ee15620596c02 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:41:38 +0100
Subject: [PATCH 256/475] Let a piglin celebrate a killed target and dance over
 a hoglin

---
 crates/horizon-client/src/game/lan.rs         |  7 ++
 .../src/game/remote_mob_data.rs               |  2 +
 crates/horizon-client/src/mobs/ai.rs          |  3 +
 crates/horizon-client/src/mobs/piglin.rs      | 87 ++++++++++++++++++-
 4 files changed, 98 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..1682e6498 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -223,6 +223,13 @@ fn mob_meta(
             }
             defaults.push((16, serializer::BYTE, Value::Byte(0)));
         }
+        // Piglin.DATA_IS_DANCING (after the baby flag and the crossbow charge).
+        "minecraft:piglin" => {
+            if e.scratch[0] > 0 {
+                meta.push((19, serializer::BOOLEAN, Value::Bool(true)));
+            }
+            defaults.push((19, serializer::BOOLEAN, Value::Bool(false)));
+        }
         // Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 when sheared.
         "minecraft:sheep" => {
             let value = (e.color & 15) | if e.sheared { 16 } else { 0 };
diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs
index c6702dfb6..3ee576e78 100644
--- a/crates/horizon-client/src/game/remote_mob_data.rs
+++ b/crates/horizon-client/src/game/remote_mob_data.rs
@@ -66,6 +66,8 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
                 m.extra.color = (*wool & 15) as u8;
                 m.extra.sheared = wool & 16 != 0;
             }
+            // Piglin.DATA_IS_DANCING: the dance pose.
+            (Species::Piglin, 19, Value::Bool(dancing)) => m.extra.scratch[0] = i32::from(*dancing),
             // TamableAnimal.DATA_FLAGS_ID: sitting 1, tame 4.
             (Species::Wolf | Species::Cat | Species::Parrot, 18, Value::Byte(flags)) => {
                 m.extra.sitting = flags & 1 != 0;
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 7f6c33fc1..8911d343f 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -668,6 +668,9 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &
     // serverAiStep has no goals, so it only falls and is pushed.
     let immobile = (m.species() == Species::Ravager && super::ravager::immobile(m))
         || m.species() == Species::Mannequin;
+    if m.species() == Species::Piglin && m.alive() {
+        super::piglin::celebrate(m, w);
+    }
     if m.alive() && !immobile {
         server_ai_step(m, w, level_random, events);
     } else {
diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs
index de9ba42dd..028fa0386 100644
--- a/crates/horizon-client/src/mobs/piglin.rs
+++ b/crates/horizon-client/src/mobs/piglin.rs
@@ -20,6 +20,9 @@ pub const ADMIRE: i32 = 119;
 pub const ATE_RECENTLY: i32 = 200;
 /// `AbstractPiglin.CONVERSION_TIME` (and the hoglin's).
 const CONVERSION: i32 = 300;
+/// `PiglinAi.CELEBRATION_TIME`: how long the `CELEBRATE_LOCATION` and
+/// `DANCING` memories last.
+const CELEBRATION: i32 = 300;
 
 fn hostile_to_player(m: &Mob, w: &MobWorld) -> bool {
     if m.is_baby() {
@@ -50,6 +53,7 @@ pub fn register_piglin(m: &mut Mob) {
     g.add(3, MeleeAttack::new(1.0, true));
     g.add(4, PiglinAvoidRepellent);
     g.add(4, GoToWantedItem);
+    g.add(4, Celebrate);
     g.add(5, Stroll::avoiding_water(0.6));
     g.add(6, LookAtPlayer::new(8.0));
     g.add(7, RandomLookAround::default());
@@ -243,6 +247,45 @@ impl Goal for Admire {
         m.nav_stop();
     }
 }
+/// The celebrate activity: `GoToTargetLocation` on the spot a killed target
+/// fell (within 2 blocks, or 4 and slower while dancing).
+#[derive(Clone, Debug)]
+struct Celebrate;
+impl Celebrate {
+    fn walk(m: &mut Mob, cx: &mut Cx) {
+        let Some(at) = m.extra.home else { return };
+        let (close, speed) = if m.extra.scratch[0] > 0 {
+            (4.0, 0.6)
+        } else {
+            (2.0, 1.0)
+        };
+        let center = Vec3::new(
+            f64::from(at[0]) + 0.5,
+            f64::from(at[1]),
+            f64::from(at[2]) + 0.5,
+        );
+        if m.distance_sqr(center) >= close * close {
+            m.nav_move_to(cx.w, [center.x, center.y, center.z], speed);
+        }
+    }
+}
+impl Goal for Celebrate {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        MOVE
+    }
+    fn can_use(&mut self, m: &mut Mob, _: &mut Cx) -> bool {
+        m.extra.scratch[1] > 0 && m.extra.home.is_some() && m.extra.using_item == 0
+    }
+    fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
+        Self::walk(m, cx);
+    }
+    fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
+        if m.ai.nav.is_done() {
+            Self::walk(m, cx);
+        }
+    }
+}
 /// `GoToWantedItem`: walk to the gold the game spotted.
 #[derive(Clone, Debug)]
 struct GoToWantedItem;
@@ -294,6 +337,45 @@ fn hoglin_repellent(m: &mut Mob, w: &MobWorld) {
         m.ai.target = None;
     }
 }
+/// `StartCelebratingIfTargetDead` for a piglin (`scratch[0]` dancing,
+/// `scratch[1]` ticks of celebration left, `scratch[2]` the hit seen, `home`
+/// the `CELEBRATE_LOCATION`): a killed target starts a celebration at its
+/// spot, and a hoglin's death makes the piglin dance one time in ten.
+/// `PiglinAi.wasHurtBy` ends both. Runs before the target goals drop the
+/// dead target.
+pub fn celebrate(m: &mut Mob, w: &MobWorld) {
+    if m.extra.scratch[1] > 0 {
+        m.extra.scratch[1] -= 1;
+        if m.extra.scratch[1] == 0 {
+            m.extra.scratch[0] = 0;
+            m.extra.home = None;
+        }
+    }
+    if m.ai.last_hurt_by.is_some() && m.ai.last_hurt_by_time != m.extra.scratch[2] {
+        m.extra.scratch[2] = m.ai.last_hurt_by_time;
+        m.extra.scratch[0] = 0;
+        m.extra.scratch[1] = 0;
+        m.extra.home = None;
+    }
+    if m.extra.scratch[1] > 0 {
+        return;
+    }
+    let Some(target) = m.ai.target else { return };
+    let Some(t) = w.target_info(target).filter(|t| !t.alive) else {
+        return;
+    };
+    let hoglin =
+        matches!(target, Who::Mob(id) if w.seen(id).is_some_and(|s| s.species == Species::Hoglin));
+    if hoglin && m.random.next_float() < 0.1 {
+        m.extra.scratch[0] = 1;
+    }
+    m.extra.scratch[1] = CELEBRATION;
+    m.extra.home = Some([
+        t.position.x.floor() as i32,
+        t.position.y.floor() as i32,
+        t.position.z.floor() as i32,
+    ]);
+}
 /// Per-tick piglin and hoglin state: admiring, anger, zombification and the
 /// hoglin attack animation. Returns a conversion when it happens.
 pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
@@ -420,7 +502,10 @@ pub fn ears(p: &mut Poses, s: &State) {
 /// Piglins' and brutes' ears flap (`AbstractPiglinModel`), arms follow the
 /// arm pose (`PiglinModel`).
 pub fn piglin_anim(m: &Mob, s: &State, p: &mut Poses) {
-    let pose = if m.extra.using_item > 0 {
+    // Piglin.getArmPose: dancing comes first.
+    let pose = if m.extra.scratch[0] > 0 {
+        PiglinPose::Dancing
+    } else if m.extra.using_item > 0 {
         PiglinPose::AdmiringItem
     } else if m.extra.flag {
         PiglinPose::CrossbowCharge

From 34dabe4afdfafd89c5bb1240843d4253d4f74fa2 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:41:49 +0100
Subject: [PATCH 257/475] Grey out Chunk Fade-in, Improved Transparency and
 Chunk Builder

---
 crates/horizon-client/src/options_ui.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs
index 61fda9878..d441819d8 100644
--- a/crates/horizon-client/src/options_ui.rs
+++ b/crates/horizon-client/src/options_ui.rs
@@ -172,6 +172,10 @@ impl Opt {
                 | Opt::MonochromeLogo
                 | Opt::RotateWithMinecarts
                 | Opt::HighContrastBlockOutlines
+                // Saved, but nothing in rendering reads them yet.
+                | Opt::ChunkFade
+                | Opt::ImprovedTransparency
+                | Opt::ChunkBuilder
         )
     }
     fn file_key(self) -> Option<&'static str> {

From 851789830a7fbf4b325963f5252273fc5281627a Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:44:17 +0100
Subject: [PATCH 258/475] Open chat links from open_url click events

---
 crates/horizon-client/src/component.rs  |  4 ++
 crates/horizon-client/src/game.rs       | 16 ++++++
 crates/horizon-client/src/game/chat.rs  | 65 +++++++++++++++++++++++++
 crates/horizon-client/src/game/packs.rs |  4 ++
 crates/horizon-client/src/text.rs       |  3 ++
 5 files changed, 92 insertions(+)

diff --git a/crates/horizon-client/src/component.rs b/crates/horizon-client/src/component.rs
index fced49898..0f0adef57 100644
--- a/crates/horizon-client/src/component.rs
+++ b/crates/horizon-client/src/component.rs
@@ -173,6 +173,10 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
     if let Some(e) = o.get("click_event").and_then(Value::as_object) {
         let text = |k: &str| e.get(k).and_then(Value::as_str).map(str::to_owned);
         style.click = match e.get("action").and_then(Value::as_str) {
+            // ClickEvent.OpenUrl.CODEC: ExtraCodecs.UNTRUSTED_URI allows http and https only.
+            Some("open_url") => text("url")
+                .filter(|u| u.starts_with("http://") || u.starts_with("https://"))
+                .map(crate::text::ClickEvent::OpenUrl),
             Some("suggest_command") => text("command").map(crate::text::ClickEvent::SuggestCommand),
             Some("copy_to_clipboard") => {
                 text("value").map(crate::text::ClickEvent::CopyToClipboard)
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index b4b2861ce..f4682e44c 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -1218,6 +1218,8 @@ struct Game<'a> {
     pending_pack_reload: bool,
     /// A server's resource packs (game/server_packs.rs).
     server_packs: server_packs::ServerPackState,
+    /// The link a chat click asks to open (`ConfirmLinkScreen`).
+    link_prompt: Option<String>,
     dialogs: dialogs::DialogState,
     world_renderer_ready: bool,
     collision: &'a BlockCollisionRegistry<'a>,
@@ -5150,6 +5152,7 @@ impl Game<'_> {
         };
         self.draw_dialog(&mut batch);
         self.draw_pack_prompt(&mut batch);
+        self.draw_link_prompt(&mut batch);
         // Gui.extractRenderState: the debug overlay comes after the screen
         // and the toasts, so it is over everything, menus included.
         self.draw_debug_overlay(&mut batch, size);
@@ -11825,6 +11828,11 @@ impl ApplicationHandler for Game<'_> {
                         self.advancements_scroll(scaled(raw_x) as f32, d);
                     }
                 }
+                WindowEvent::MouseInput { state, button, .. } if self.link_prompt.is_some() => {
+                    if state == ElementState::Pressed && button == MouseButton::Left {
+                        self.link_prompt_click();
+                    }
+                }
                 WindowEvent::MouseInput { state, button, .. }
                     if self.server_packs.prompt.is_some() =>
                 {
@@ -12044,6 +12052,13 @@ impl ApplicationHandler for Game<'_> {
                     }
                 }
                 // ConfirmScreen.keyPressed: Escape answers no.
+                WindowEvent::KeyboardInput { event, .. } if self.link_prompt.is_some() => {
+                    if event.state == ElementState::Pressed
+                        && event.physical_key == PhysicalKey::Code(KeyCode::Escape)
+                    {
+                        self.answer_link_prompt(false);
+                    }
+                }
                 WindowEvent::KeyboardInput { event, .. } if self.server_packs.prompt.is_some() => {
                     if event.state == ElementState::Pressed
                         && event.physical_key == PhysicalKey::Code(KeyCode::Escape)
@@ -12559,6 +12574,7 @@ impl<'a> Game<'a> {
             world_loader: None,
             pending_pack_reload: false,
             server_packs: Default::default(),
+            link_prompt: None,
             dialogs: Default::default(),
             world_renderer_ready: false,
             collision: res.collision(),
diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs
index 03174c009..29cda8b2c 100644
--- a/crates/horizon-client/src/game/chat.rs
+++ b/crates/horizon-client/src/game/chat.rs
@@ -695,6 +695,7 @@ impl Game<'_> {
             Some(ClickEvent::OpenFile(path)) => {
                 super::packs::open_folder(std::path::Path::new(&path));
             }
+            Some(ClickEvent::OpenUrl(url)) => self.click_url(url),
             Some(ClickEvent::SuggestCommand(command)) => {
                 if let Some(screen) = self.ui.chat_screen.as_mut() {
                     screen.suggest_command(&m, &c, &command);
@@ -703,6 +704,70 @@ impl Game<'_> {
             None => {}
         }
     }
+    /// `Screen.clickUrlAction`: nothing with Web Links off, else the link
+    /// opens, after the confirmation unless Prompt on Links is off.
+    fn click_url(&mut self, url: String) {
+        if !self.settings.chat_links {
+            return;
+        }
+        if self.settings.file.bool("chatLinksPrompt") {
+            self.link_prompt = Some(url);
+        } else {
+            super::packs::open_uri(&url);
+        }
+    }
+    /// `ConfirmLinkScreen` (untrusted): the link and its warning over the
+    /// chat, answered yes to open it.
+    fn link_prompt_layout(
+        &self,
+        url: &str,
+        size: (f32, f32),
+    ) -> horizon_client::confirm_screen::Confirm {
+        let warning = Text::translate("chat.link.warning", &[]).with_color(0xFF_CCCC);
+        let message = Text::literal(url)
+            .append(Text::literal("\n"))
+            .append(warning);
+        horizon_client::confirm_screen::Confirm::new(
+            &self.gui.atlas.font,
+            size,
+            &Text::translate("chat.link.confirm", &[]),
+            &message,
+        )
+    }
+    pub(super) fn draw_link_prompt(&self, batch: &mut HudBatch) {
+        let Some(url) = &self.link_prompt else {
+            return;
+        };
+        let atlas = &self.gui.atlas;
+        let (w, h) = (batch.width, batch.height);
+        horizon_client::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true);
+        let (yes, no) = (
+            Text::translate("gui.yes", &[]),
+            Text::translate("gui.no", &[]),
+        );
+        self.link_prompt_layout(url, (w, h))
+            .draw(batch, atlas, self.cursor, [&yes, &no]);
+    }
+    /// The prompt's answer: the link opens on yes; either way the chat is back.
+    pub(super) fn answer_link_prompt(&mut self, yes: bool) {
+        if let Some(url) = self.link_prompt.take()
+            && yes
+        {
+            super::packs::open_uri(&url);
+        }
+    }
+    pub(super) fn link_prompt_click(&mut self) {
+        let Some(url) = &self.link_prompt else {
+            return;
+        };
+        let answer = self
+            .link_prompt_layout(url, self.gui_size())
+            .answer_at(self.cursor);
+        if let Some(yes) = answer {
+            self.audio.play_button_click();
+            self.answer_link_prompt(yes);
+        }
+    }
     /// Chat lines over the HUD (focused while the chat screen is open).
     pub(super) fn draw_chat(&mut self, batch: &mut HudBatch) {
         let focused = self.screen == Screen::Chat;
diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs
index 569c63083..92587e1f6 100644
--- a/crates/horizon-client/src/game/packs.rs
+++ b/crates/horizon-client/src/game/packs.rs
@@ -34,6 +34,10 @@ pub fn open_folder(dir: &Path) {
         log::warn!("Horizon: could not open {}: {e}", dir.display());
     }
 }
+/// `Util.getPlatform().openUri`: the system's handler for a link.
+pub fn open_uri(uri: &str) {
+    open_folder(Path::new(uri));
+}
 /// The resource root to load from, given the vanilla root, the selection and
 /// a server's packs, which go on top (`Pack.Position.TOP`, fixed).
 pub fn startup_root(
diff --git a/crates/horizon-client/src/text.rs b/crates/horizon-client/src/text.rs
index 4c04c9da5..20cbdc65a 100644
--- a/crates/horizon-client/src/text.rs
+++ b/crates/horizon-client/src/text.rs
@@ -42,6 +42,8 @@ pub fn named_color(name: &str) -> Option<u32> {
 /// Click actions carried by locally constructed text components.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum ClickEvent {
+    /// `ClickEvent.OpenUrl`: an http or https link.
+    OpenUrl(String),
     SuggestCommand(String),
     CopyToClipboard(String),
     /// A local file to open with the system handler.
@@ -529,6 +531,7 @@ fn style_json(style: &Style) -> Vec<(String, Value)> {
     }
     if let Some(click) = &style.click {
         let event = match click {
+            ClickEvent::OpenUrl(url) => json!({ "action": "open_url", "url": url }),
             ClickEvent::SuggestCommand(command) => {
                 json!({ "action": "suggest_command", "command": command })
             }

From c85f6f2e398eb73ececd12a1dadf3c10383de945 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 20:50:13 +0100
Subject: [PATCH 259/475] Give polar bears their attack AI and rearing pose

Polar bears only panicked and strolled. They now follow vanilla's goals: melee attack that rears up and growls before each strike, hurt-by and cub-defending targets, anger at the player, and fox hunting. A hurt cub calls the adults. The standing flag is synched and the client animates it.
---
 crates/horizon-client/src/game/lan.rs         |   8 +
 crates/horizon-client/src/game/remote.rs      |   4 +
 .../src/game/remote_mob_data.rs               |   2 +
 crates/horizon-client/src/mobs.rs             |   1 +
 crates/horizon-client/src/mobs/ai.rs          |   4 +
 crates/horizon-client/src/mobs/body_anim.rs   |   2 +-
 crates/horizon-client/src/mobs/goals.rs       |  41 +++-
 crates/horizon-client/src/mobs/polar_bear.rs  | 191 ++++++++++++++++++
 8 files changed, 250 insertions(+), 3 deletions(-)
 create mode 100644 crates/horizon-client/src/mobs/polar_bear.rs

diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..b82d0ed1a 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -337,6 +337,14 @@ fn mob_meta(
             }
             defaults.push((17, serializer::BOOLEAN, Value::Bool(false)));
         }
+        // PolarBear.DATA_STANDING_ID (after AgeableMob's two): the bear
+        // rears up; the client animates it.
+        "minecraft:polar_bear" => {
+            if e.flag {
+                meta.push((18, serializer::BOOLEAN, Value::Bool(true)));
+            }
+            defaults.push((18, serializer::BOOLEAN, Value::Bool(false)));
+        }
         // SpellcasterIllager.DATA_SPELL_CASTING_ID: the casting pose.
         "minecraft:evoker" | "minecraft:illusioner" => {
             if e.variant2 != 0 {
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..a8ed5800d 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3517,6 +3517,10 @@ impl Game<'_> {
             ) {
                 horizon_client::mobs::guardian::client_tick(m);
             }
+            // PolarBear.tick: the stand animation follows the synched flag.
+            if m.species() == horizon_client::mobs::Species::PolarBear {
+                horizon_client::mobs::polar_bear::client_tick(m);
+            }
             if m.hurt_time > 0 {
                 m.hurt_time -= 1;
             }
diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs
index c6702dfb6..b023cdd01 100644
--- a/crates/horizon-client/src/game/remote_mob_data.rs
+++ b/crates/horizon-client/src/game/remote_mob_data.rs
@@ -59,6 +59,8 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
                     Who::Mob(*target as u32)
                 });
             }
+            // PolarBear.DATA_STANDING_ID: the client animates the rearing.
+            (Species::PolarBear, 18, Value::Bool(standing)) => m.extra.flag = *standing,
             // Bat.DATA_ID_FLAGS: resting in bit 0.
             (Species::Bat, 16, Value::Byte(flags)) => bat::set_resting(m, flags & 1 != 0),
             // Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 sheared.
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index f88fa7b06..39ac31ce4 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -50,6 +50,7 @@ pub mod nether;
 pub mod path;
 pub mod phantom;
 pub mod piglin;
+pub mod polar_bear;
 pub mod rabbit;
 pub mod raider;
 pub mod ravager;
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 8505d71d2..d3a0df0ac 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -106,6 +106,7 @@ pub enum Family {
     Strider,
     Bat,
     Bee,
+    PolarBear,
 }
 pub fn family(s: Species) -> Family {
     use Species as S;
@@ -167,6 +168,7 @@ pub fn family(s: Species) -> Family {
         S::Strider => Family::Strider,
         S::Bat => Family::Bat,
         S::Bee => Family::Bee,
+        S::PolarBear => Family::PolarBear,
         _ => Family::Generic,
     }
 }
@@ -224,6 +226,7 @@ pub fn register(m: &mut Mob) {
         Family::Strider => super::strider::register(m),
         Family::Bat => super::bat::register(m),
         Family::Bee => super::bee::register(m),
+        Family::PolarBear => super::polar_bear::register(m),
     }
     // FloatGoal's constructor lets the navigation float, as do the
     // constructors of these brain-driven and flying mobs. A floater rises
@@ -984,6 +987,7 @@ fn species_ai_step(
         Species::Wither => super::wither::ai_step(m, w, events),
         Species::Allay => super::allay::ai_step(m),
         Species::Bee => super::bee::ai_step(m, w),
+        Species::PolarBear => super::polar_bear::ai_step(m, w),
         Species::Breeze => super::breeze::ai_step(m),
         Species::Sniffer => super::sniffer::ai_step(m, events),
         Species::HappyGhast => super::happy_ghast::ai_step(m, w),
diff --git a/crates/horizon-client/src/mobs/body_anim.rs b/crates/horizon-client/src/mobs/body_anim.rs
index 4411d347b..4cc6662ce 100644
--- a/crates/horizon-client/src/mobs/body_anim.rs
+++ b/crates/horizon-client/src/mobs/body_anim.rs
@@ -959,7 +959,7 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool {
     let st = &m.anim.states;
     match m.species() {
         Species::Goat => goat(p, s, &Goat::from_mob(m)),
-        Species::PolarBear => polar_bear(p, s, 0.0),
+        Species::PolarBear => polar_bear(p, s, super::polar_bear::standing_scale(m, s.partial)),
         Species::Panda => panda(p, s, &Panda::default()),
         Species::Llama | Species::TraderLlama => {
             llama(p, s, m.extra.chested && !s.baby);
diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs
index cbb7cfec5..3b82f3094 100644
--- a/crates/horizon-client/src/mobs/goals.rs
+++ b/crates/horizon-client/src/mobs/goals.rs
@@ -1017,6 +1017,8 @@ pub struct MeleeAttack {
     pub speed: f64,
     pub follow_unseen: bool,
     pub zombie: bool,
+    /// `PolarBear.PolarBearMeleeAttackGoal`: rears up before each strike.
+    pub polar_bear: bool,
     path_target: [f64; 3],
     recalc: i32,
     pub until_attack: i32,
@@ -1031,6 +1033,7 @@ impl MeleeAttack {
             speed,
             follow_unseen,
             zombie: false,
+            polar_bear: false,
             path_target: [0.0; 3],
             recalc: 0,
             until_attack: 0,
@@ -1043,6 +1046,10 @@ impl MeleeAttack {
         self.zombie = true;
         self
     }
+    pub fn polar_bear(mut self) -> Self {
+        self.polar_bear = true;
+        self
+    }
     pub fn interval(mut self, ticks: i32) -> Self {
         self.interval = ticks;
         self
@@ -1098,6 +1105,9 @@ impl Goal for MeleeAttack {
         }
         m.ai.aggressive = false;
         m.nav_stop();
+        if self.polar_bear {
+            super::polar_bear::set_standing(m, false);
+        }
     }
     fn every_tick(&self) -> bool {
         true
@@ -1131,7 +1141,17 @@ impl Goal for MeleeAttack {
             self.recalc = adjusted(true, self.recalc);
         }
         self.until_attack = (self.until_attack - 1).max(0);
-        if self.until_attack <= 0 && m.within_melee_range(&t) && m.sees(cx.w, who) {
+        if self.polar_bear {
+            let cooldown = adjusted(true, self.interval);
+            super::polar_bear::check_and_perform_attack(
+                &mut self.until_attack,
+                cooldown,
+                m,
+                who,
+                &t,
+                cx,
+            );
+        } else if self.until_attack <= 0 && m.within_melee_range(&t) && m.sees(cx.w, who) {
             self.until_attack = adjusted(true, self.interval);
             m.swing();
             super::ai::do_hurt_target(m, who, cx);
@@ -1422,6 +1442,9 @@ pub struct HurtByTarget {
     /// `Bee.BeeHurtByOtherGoal`: kept only while angry, and alerting others
     /// only when the attacker is in sight.
     pub bee: bool,
+    /// `PolarBear.PolarBearHurtByTargetGoal`: a hurt cub only calls the
+    /// adult bears and drops the target itself.
+    pub polar_bear: bool,
     timestamp: i32,
     st: TargetState,
 }
@@ -1432,6 +1455,7 @@ impl HurtByTarget {
             alert_except: vec![],
             ignore: vec![],
             bee: false,
+            polar_bear: false,
             timestamp: 0,
             st: TargetState {
                 unseen_memory: 300,
@@ -1451,6 +1475,10 @@ impl HurtByTarget {
         self.bee = true;
         self
     }
+    pub fn polar_bear(mut self) -> Self {
+        self.polar_bear = true;
+        self
+    }
 }
 impl Default for HurtByTarget {
     fn default() -> Self {
@@ -1462,6 +1490,8 @@ impl Goal for HurtByTarget {
     fn name(&self) -> &'static str {
         if self.bee {
             "BeeHurtByOtherGoal"
+        } else if self.polar_bear {
+            "PolarBearHurtByTargetGoal"
         } else {
             "HurtByTarget"
         }
@@ -1500,7 +1530,9 @@ impl Goal for HurtByTarget {
         self.timestamp = m.ai.last_hurt_by_time;
         self.st.unseen_memory = 300;
         self.st.unseen = 0;
-        if self.alert
+        // PolarBearHurtByTargetGoal.start: a cub alerts the adults itself.
+        let cub = self.polar_bear && m.is_baby();
+        if (self.alert || cub)
             && let Some(by) = m.ai.target
         {
             let range = m.attrs.follow_range;
@@ -1520,6 +1552,8 @@ impl Goal for HurtByTarget {
                             && (s.position.z - pos.z).abs() <= range + 1.0
                     })
                     .filter(|s| !self.alert_except.contains(&s.species))
+                    // PolarBearHurtByTargetGoal.alertOther: adults only.
+                    .filter(|s| !(self.polar_bear && s.baby))
                     .filter(|s| Who::Mob(s.id) != by)
                     .map(|s| s.id)
                     .collect();
@@ -1534,6 +1568,9 @@ impl Goal for HurtByTarget {
                 });
             }
         }
+        if cub {
+            m.ai.target = None;
+        }
     }
     fn stop(&mut self, m: &mut Mob, _: &mut Cx) {
         m.ai.target = None;
diff --git a/crates/horizon-client/src/mobs/polar_bear.rs b/crates/horizon-client/src/mobs/polar_bear.rs
new file mode 100644
index 000000000..bfd464a93
--- /dev/null
+++ b/crates/horizon-client/src/mobs/polar_bear.rs
@@ -0,0 +1,191 @@
+//! Polar bears (`PolarBear`): a neutral animal that defends its cubs,
+//! fights back when hurt, and rears up before each swing. A cub flees what
+//! hurts it and calls the adults.
+//!
+//! `extra.flag` is `DATA_STANDING_ID`, `extra.counter` the warning sound's
+//! delay, `extra.anger` the `NeutralMob` anger left and `extra.flag2` whether
+//! the player is who it is angry at. `anim.v[STAND]` is
+//! `clientSideStandAnimation`.
+use horizon_core::{geometry::Vec3, random::RandomSource};
+
+use super::{
+    DamageKind, Mob, MobWorld, Species, Who,
+    goals::{
+        Cx, Float, FollowParent, Goal, HurtByTarget, LookAtPlayer, MOVE, MeleeAttack,
+        NearestTarget, Panic, RandomLookAround, Stroll, goal_clone,
+    },
+    world::TargetInfo,
+};
+
+/// `anim.v` slot of `clientSideStandAnimation`.
+pub const STAND: usize = 0;
+/// `STAND_ANIMATION_TICKS`.
+const STAND_TICKS: f32 = 6.0;
+
+pub fn register(m: &mut Mob) {
+    let g = &mut m.ai.goals;
+    g.add(0, Float);
+    g.add(1, MeleeAttack::new(1.25, true).polar_bear());
+    g.add(1, PolarBearPanic(Panic::new(2.0)));
+    g.add(4, FollowParent::new(1.25));
+    g.add(5, Stroll::new(1.0));
+    g.add(6, LookAtPlayer::new(6.0));
+    g.add(7, RandomLookAround::default());
+    let t = &mut m.ai.targets;
+    t.add(1, HurtByTarget::new().polar_bear());
+    // PolarBearAttackPlayersGoal: players near a cub, within half the
+    // follow range, never for a cub itself.
+    t.add(
+        2,
+        NearestTarget::player(true)
+            .interval(20)
+            .follow_scale(0.5)
+            .reach()
+            .gate(|m, _| !m.is_baby())
+            .when(cub_nearby)
+            .named("PolarBearAttackPlayersGoal"),
+    );
+    t.add(
+        3,
+        NearestTarget::player(true).when(|m, _| m.extra.anger > 0 && m.extra.flag2),
+    );
+    t.add(
+        4,
+        NearestTarget::species(&[Species::Fox], true)
+            .interval(10)
+            .reach()
+            .when(|m, _| !m.is_baby()),
+    );
+}
+
+/// `PolarBearAttackPlayersGoal.canUse`: a polar bear cub within 8 blocks
+/// (4 up and down).
+fn cub_nearby(m: &Mob, w: &MobWorld) -> bool {
+    let area = m.bounds().inflate(Vec3::new(8.0, 4.0, 8.0));
+    w.others_near(area)
+        .any(|s| s.species == Species::PolarBear && s.baby && s.bounds.intersects(area))
+}
+
+/// `PanicGoal` with a function of the bear's age for the damage tag: a cub
+/// panics at `PANIC_CAUSES`, an adult only at `PANIC_ENVIRONMENTAL_CAUSES`.
+#[derive(Clone, Debug)]
+struct PolarBearPanic(Panic);
+impl Goal for PolarBearPanic {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        MOVE
+    }
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        (m.is_baby() || environmental_panic(m)) && self.0.can_use(m, cx)
+    }
+    fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        self.0.can_continue(m, cx)
+    }
+    fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
+        self.0.start(m, cx)
+    }
+    fn stop(&mut self, m: &mut Mob, cx: &mut Cx) {
+        self.0.stop(m, cx)
+    }
+}
+/// `DamageTypeTags.PANIC_ENVIRONMENTAL_CAUSES` (fire, lava, cactus), or
+/// burning.
+fn environmental_panic(m: &Mob) -> bool {
+    m.fire_ticks > 0 && !m.kind.flags.fire_immune
+        || m.last_damage.is_some_and(|(d, t)| {
+            matches!(
+                d.kind,
+                DamageKind::OnFire | DamageKind::InFire | DamageKind::Lava | DamageKind::Cactus
+            ) && i64::from(m.age) - t <= 40
+        })
+}
+
+/// `PolarBear.setStanding`.
+pub fn set_standing(m: &mut Mob, standing: bool) {
+    m.extra.flag = standing;
+}
+
+/// `PolarBear.playWarningSound`.
+fn play_warning_sound(m: &mut Mob, cx: &mut Cx) {
+    if m.extra.counter <= 0 {
+        m.voice("entity.polar_bear.warning", cx.events);
+        m.extra.counter = 40;
+    }
+}
+
+/// `PolarBearMeleeAttackGoal.checkAndPerformAttack`: strike when ready and
+/// in reach, rear up and growl in the last 10 ticks while close.
+pub fn check_and_perform_attack(
+    until_attack: &mut i32,
+    cooldown: i32,
+    m: &mut Mob,
+    who: Who,
+    t: &TargetInfo,
+    cx: &mut Cx,
+) {
+    if *until_attack <= 0 && m.within_melee_range(t) && m.sees(cx.w, who) {
+        *until_attack = cooldown;
+        super::ai::do_hurt_target(m, who, cx);
+        set_standing(m, false);
+        return;
+    }
+    let reach = t.bounds.size().x as f32 + 3.0;
+    if m.distance_sqr(t.position) < f64::from(reach * reach) {
+        if *until_attack <= 0 {
+            set_standing(m, false);
+            *until_attack = cooldown;
+        }
+        if *until_attack <= 10 {
+            set_standing(m, true);
+            play_warning_sound(m, cx);
+        }
+    } else {
+        *until_attack = cooldown;
+        set_standing(m, false);
+    }
+}
+
+/// `PolarBear.tick`'s client half: `clientSideStandAnimation` follows the
+/// synched standing flag by one tick a tick. A client of a server runs it
+/// too.
+pub fn client_tick(m: &mut Mob) {
+    let v = m.anim.v[STAND];
+    m.anim.vo[STAND] = v;
+    let step = if m.extra.flag { 1.0 } else { -1.0 };
+    m.anim.v[STAND] = (v + step).clamp(0.0, STAND_TICKS);
+}
+/// `PolarBear.getStandingAnimationScale`.
+pub fn standing_scale(m: &Mob, partial: f32) -> f32 {
+    m.anim.lerp(STAND, partial) / STAND_TICKS
+}
+
+/// `PolarBear.tick`: the stand animation, the warning sound's delay and
+/// `NeutralMob.updatePersistentAnger`.
+pub fn ai_step(m: &mut Mob, w: &MobWorld) {
+    client_tick(m);
+    if m.extra.counter > 0 {
+        m.extra.counter -= 1;
+    }
+    if m.ai.target.is_some() {
+        // Anger follows the target and starts over every tick it is held:
+        // 20 to 39 seconds (`PERSISTENT_ANGER_TIME`).
+        m.extra.flag2 = m.ai.target == Some(Who::Player);
+        m.extra.anger = 400 + m.random.next_int_bound(381).unwrap_or(0);
+    } else if m.extra.anger > 0 {
+        m.extra.anger -= 1;
+        if m.extra.anger == 0 {
+            stop_being_angry(m);
+        }
+    }
+    // A player in creative or spectator mode is forgiven at once.
+    if m.extra.flag2 && w.player.as_ref().is_some_and(|p| p.creative || p.spectator) {
+        stop_being_angry(m);
+    }
+}
+/// `NeutralMob.stopBeingAngry`.
+fn stop_being_angry(m: &mut Mob) {
+    m.ai.last_hurt_by = None;
+    m.ai.target = None;
+    m.extra.anger = 0;
+    m.extra.flag2 = false;
+}

From bb9b0424b44606cd7af0bb57e4610d24c0af2a68 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 20:52:11 +0100
Subject: [PATCH 260/475] Axolotl rain: the biome's height-adjusted temperature

Level.isRainingAt takes Biome.getHeightAdjustedTemperature, which applies
the frozen oceans' temperature modifier and the height noise above the snow
level; reuse horizon-world's version instead of a simplified copy.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/biome.rs      | 25 ++++++++++++++++++++++++-
 crates/horizon-client/src/mobs/world.rs | 12 +++---------
 2 files changed, 27 insertions(+), 10 deletions(-)

diff --git a/crates/horizon-client/src/biome.rs b/crates/horizon-client/src/biome.rs
index 63ad004d4..9d68bfefa 100644
--- a/crates/horizon-client/src/biome.rs
+++ b/crates/horizon-client/src/biome.rs
@@ -1,7 +1,7 @@
 //! Biome colours from the pinned biome definitions and colormaps
 //! (`Biome.getGrassColor`/`getFoliageColor`/..., `BlockTintSources`).
 use crate::Result;
-use horizon_core::{noise::SimplexNoise, random::LegacyRandom};
+use horizon_core::{noise::SimplexNoise, position::BlockPos, random::LegacyRandom};
 use serde_json::Value;
 use std::{collections::HashMap, fs, path::Path};
 
@@ -30,6 +30,8 @@ pub struct BiomeInfo {
     pub creature_probability: f32,
     pub name: String,
     pub temperature: f32,
+    /// `temperature_modifier: frozen` (the frozen oceans).
+    pub frozen: bool,
     pub downfall: f32,
     pub precipitation: bool,
     pub grass: u32,
@@ -42,6 +44,26 @@ pub struct BiomeInfo {
     pub fog: Option<u32>,
     pub water_fog: u32,
 }
+impl BiomeInfo {
+    /// `Biome.getHeightAdjustedTemperature`: the frozen modifier, then cooler
+    /// with height above `sea_level + 17`.
+    pub fn temperature_at(&self, pos: BlockPos, sea_level: i32) -> f32 {
+        use horizon_world::worldgen::biome_temperature::{
+            BiomeTemperatureSettings, TemperatureModifier,
+        };
+        BiomeTemperatureSettings {
+            base_temperature: self.temperature,
+            modifier: if self.frozen {
+                TemperatureModifier::Frozen
+            } else {
+                TemperatureModifier::None
+            },
+            has_precipitation: self.precipitation,
+            downfall: self.downfall,
+        }
+        .height_adjusted(pos, sea_level)
+    }
+}
 pub struct Biomes {
     pub list: Vec<BiomeInfo>,
     pub index: HashMap<String, u16>,
@@ -129,6 +151,7 @@ impl Biomes {
                         .as_f64()
                         .unwrap_or(0.1) as f32,
                 temperature,
+                frozen: v["temperature_modifier"].as_str() == Some("frozen"),
                 downfall,
                 precipitation: v["has_precipitation"].as_bool().unwrap_or(true),
                 grass: color(&effects["grass_color"])
diff --git a/crates/horizon-client/src/mobs/world.rs b/crates/horizon-client/src/mobs/world.rs
index db2557e72..f893559f6 100644
--- a/crates/horizon-client/src/mobs/world.rs
+++ b/crates/horizon-client/src/mobs/world.rs
@@ -178,8 +178,8 @@ impl MobWorld<'_> {
         self.world.light(x, y, z) >> 4 == 15
     }
     /// Level.isRainingAt: raining, open to the sky, nothing motion blocking
-    /// above, and the biome's precipitation at the position (its temperature
-    /// lowered above the snow level) is rain, not snow or none.
+    /// above, and the biome's precipitation at the position is rain, not snow
+    /// or none.
     pub fn raining_at(&self, x: i32, y: i32, z: i32) -> bool {
         if !self.raining || !self.can_see_sky(x, y, z) || self.motion_blocking_height(x, z) > y {
             return false;
@@ -188,13 +188,7 @@ impl MobWorld<'_> {
             return false;
         };
         let biome = self.biomes.get(chunk.biome(x, y, z));
-        let snow_level = self.sea_level + 17;
-        let temperature = if y > snow_level {
-            biome.temperature - (y - snow_level) as f32 * 0.05 / 40.0
-        } else {
-            biome.temperature
-        };
-        biome.precipitation && temperature >= 0.15
+        biome.precipitation && biome.temperature_at(BlockPos::new(x, y, z), self.sea_level) >= 0.15
     }
     /// Level.getLightLevelDependentMagicValue: the dimension's brightness curve
     /// at the raw (sky darkened) light level.

From 37559dae820de4f3fee3c83dccb7dd0840640cdf Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 20:58:06 +0100
Subject: [PATCH 261/475] pr_ready: run CI's clippy, CI's test features, Python
 tests and launcher rule

pr_ready --quick passed #1895 while CI's clippy failed on an unused import in horizon-mods' tests: clippy on the
touched crates and their dependents gives them other features than CI's workspace-wide run (Cargo unifies
features over the packages it builds).
- clippy: CI's two commands as they are. The whole workspace runs with the game's code mods, and the server build
  (horizon-client --no-default-features) runs when horizon-client is affected. Warm on the Mac mini, a change to
  hud.rs took 14-16 s against 17 s before, and food.rs 22-32 s against 14 s. Each worktree's first run costs
  about 3 min once.
- tests stay on the touched crates, with the features CI's workspace run gives them: horizon-client's code mods,
  and horizon-mods' runtime, pack and index.
- The Python tests always run, as in CI: some read the crates, the roadmap or the workflows.
- The launcher steps run when CI's launcher job would (tools/ci/rust_changes.py's rule, which also covers the
  root manifests and the check itself).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_pr_ready.py | 41 +++++++++++++++++++---------
 tools/pr_ready.py      | 61 +++++++++++++++++++++++++-----------------
 2 files changed, 66 insertions(+), 36 deletions(-)

diff --git a/tests/test_pr_ready.py b/tests/test_pr_ready.py
index 0eab92fb0..87373cb31 100644
--- a/tests/test_pr_ready.py
+++ b/tests/test_pr_ready.py
@@ -9,7 +9,8 @@ PACKAGES = {"horizon-core": "crates/horizon-core", "horizon-client": "crates/hor
             "horizon-theme": "crates/horizon-theme", "xtask": "xtask"}
 LIBRARIES = set(PACKAGES) - {"xtask"}
 DEPENDENCIES = {"horizon-client": {"horizon-core"}}
-MODS = " --features horizon-mods/runtime,horizon-mods/pack,horizon-client/mods"
+MODS = " --features horizon-client/mods,horizon-mods/pack"
+CLIPPY = pr_ready.CI_CLIPPY + " && " + pr_ready.CI_CLIPPY_SERVER
 
 
 def args(host="local", quick=False):
@@ -35,6 +36,9 @@ class PrReadyTests(unittest.TestCase):
         self.assertFalse(pr_ready.workspace_rust("crates/horizon-client/README.md"))
         self.assertFalse(pr_ready.workspace_rust("launcher/src/main.rs"))
         self.assertTrue(pr_ready.launcher_rust("launcher/src/main.rs"))
+        # CI's launcher job also runs for the root workspace's manifests and for its own check.
+        self.assertTrue(pr_ready.launcher_rust("Cargo.lock"))
+        self.assertTrue(pr_ready.launcher_rust("tools/ci/rust_changes.py"))
         self.assertTrue(pr_ready.launcher_rust("crates/horizon-prepare/src/lib.rs"))
         self.assertTrue(pr_ready.launcher_rust("crates/horizon-theme/src/lib.rs"))
         self.assertTrue(pr_ready.launcher_rust("crates/horizon-telemetry/src/lib.rs"))
@@ -46,10 +50,9 @@ class PrReadyTests(unittest.TestCase):
         with mock.patch.object(pr_ready, "affected_here", return_value=[]):
             steps = pr_ready.plan(args(quick=True), "origin/main", {"crates/horizon-client/src/game.rs"}, PACKAGES, LIBRARIES, DEPENDENCIES)
         by_name = {step.name: step for step in steps}
-        self.assertEqual(by_name["clippy"].command,
-                         "cargo clippy -p horizon-client --all-targets --locked -- -D warnings")
+        self.assertEqual(by_name["clippy"].command, CLIPPY)
         self.assertEqual(by_name["tests: horizon-client"].command,
-                         "cargo test --locked -p horizon-client --tests")
+                         "cargo test --locked -p horizon-client --features horizon-client/mods --tests")
         self.assertEqual(by_name["doc tests"].command, "cargo test --locked -p horizon-client --doc")
         self.assertIsNone(by_name["doc tests"].status)
 
@@ -58,12 +61,24 @@ class PrReadyTests(unittest.TestCase):
             with self.subTest(path=path), mock.patch.object(pr_ready, "affected_here", return_value=[]):
                 steps = pr_ready.plan(args(quick=True), "origin/main", {path}, PACKAGES, LIBRARIES, DEPENDENCIES)
                 by_name = {step.name: step for step in steps}
-                self.assertEqual(by_name["clippy"].command,
-                                 "cargo clippy --workspace" + MODS + " --all-targets --locked -- -D warnings")
+                self.assertEqual(by_name["clippy"].command, CLIPPY)
                 self.assertEqual(by_name["tests: workspace"].command,
                                  "cargo test --locked --workspace" + MODS + " --tests")
                 self.assertEqual(by_name["doc tests"].command, "cargo test --locked --workspace --doc")
 
+    def test_tests_get_the_features_ci_s_workspace_run_gives_them(self):
+        self.assertEqual(pr_ready.mod_features(["horizon-world"]), "")
+        self.assertEqual(pr_ready.mod_features(["horizon-client"]), " --features horizon-client/mods")
+        self.assertEqual(pr_ready.mod_features(["horizon-mods"]),
+                         " --features horizon-mods/runtime,horizon-mods/pack,horizon-mods/index")
+        self.assertEqual(pr_ready.mod_features(None), MODS)
+
+    def test_python_tests_always_run(self):
+        with mock.patch.object(pr_ready, "affected_here", return_value=[]):
+            steps = pr_ready.plan(args(quick=True), "origin/main", {"crates/horizon-core/src/lib.rs"},
+                                  PACKAGES, LIBRARIES, DEPENDENCIES)
+        self.assertIsNone({step.name: step for step in steps}["Python tests"].status)
+
     def test_non_rust_changes_skip_workspace_checks(self):
         for path in ("README.md", "tools/pr_ready.py", "launcher/src/main.rs"):
             with self.subTest(path=path), mock.patch.object(pr_ready, "affected_here", return_value=[]):
@@ -77,7 +92,7 @@ class PrReadyTests(unittest.TestCase):
             steps = pr_ready.plan(args(), "origin/main",
                                   {"crates/horizon-core/src/lib.rs", "crates/horizon-client/examples/probe.rs"}, PACKAGES, LIBRARIES, DEPENDENCIES)
         for step in steps:
-            if step.name in ("clippy", "tests: horizon-client, horizon-core", "doc tests"):
+            if step.name in ("tests: horizon-client, horizon-core", "doc tests"):
                 self.assertIn("-p horizon-client -p horizon-core", step.command)
                 self.assertIsNone(step.status)
 
@@ -94,15 +109,17 @@ class PrReadyTests(unittest.TestCase):
         by_name = {step.name: step for step in steps}
         self.assertEqual(by_name["doc tests"].command, "cargo test --locked -p horizon-core --doc")
 
-    def test_clippy_checks_transitive_consumers_but_tests_only_touched_crates(self):
-        packages = {name: f"crates/{name}" for name in ("core", "world", "client", "unrelated")}
-        dependencies = {"world": {"core"}, "client": {"world"}, "unrelated": set()}
+    def test_clippy_is_ci_s_and_the_server_build_when_the_game_is_affected(self):
+        packages = {name: f"crates/{name}" for name in ("core", "world", "horizon-client", "unrelated")}
+        dependencies = {"world": {"core"}, "horizon-client": {"world"}, "unrelated": set()}
         with mock.patch.object(pr_ready, "affected_here", return_value=[]):
             steps = pr_ready.plan(args(), "origin/main", {"crates/core/src/lib.rs"},
                                   packages, set(packages), dependencies)
+            unrelated = pr_ready.plan(args(), "origin/main", {"crates/unrelated/src/lib.rs"},
+                                      packages, set(packages), dependencies)
+        self.assertEqual({step.name: step for step in unrelated}["clippy"].command, pr_ready.CI_CLIPPY)
         by_name = {step.name: step for step in steps}
-        self.assertEqual(by_name["clippy"].command,
-                         "cargo clippy -p client -p core -p world --all-targets --locked -- -D warnings")
+        self.assertEqual(by_name["clippy"].command, CLIPPY)
         self.assertEqual(by_name["tests: core"].command, "cargo test --locked -p core --tests")
         self.assertEqual(by_name["doc tests"].command, "cargo test --locked -p core --doc")
 
diff --git a/tools/pr_ready.py b/tools/pr_ready.py
index 5b1622e2e..89a529192 100755
--- a/tools/pr_ready.py
+++ b/tools/pr_ready.py
@@ -7,12 +7,13 @@
     python3 tools/pr_ready.py --quick               # without running the vanilla harnesses
 
 From the files the branch changes since its merge base with --base (committed or not) it decides what to run:
-rustfmt, clippy with warnings denied and the tests of the touched crates; the launcher (its own workspace) the
-same way when it, horizon-prepare or horizon-theme changed; crates/horizon-theme/tokens.css against horizon-theme;
-Cargo.lock changing only with a Cargo.toml; the Python tests and the public-tree check; and the vanilla
-harnesses the changes can affect, picked as CI's parity job picks them (tools/parity.py --changed). Harnesses run
-where the vanilla data is (a prepared .local/ here, or the Mac mini); elsewhere they are listed for CI.
-Clippy checks all targets of touched crates and their transitive workspace dependents, including examples.
+rustfmt, and clippy with warnings denied exactly as CI's verify job runs it (the whole workspace with the game's code
+mods, plus the server build when horizon-client is affected); the tests of the touched crates, with the features
+CI's workspace-wide run gives them; the launcher (its own workspace) the same way when CI's launcher job would run
+(tools/ci/rust_changes.py --launcher); crates/horizon-theme/tokens.css against horizon-theme; Cargo.lock changing
+only with a Cargo.toml; the Python tests (always, as in CI) and the public-tree check; and the vanilla harnesses the
+changes can affect, picked as CI's parity job picks them (tools/parity.py --changed). Harnesses run where the
+vanilla data is (a prepared .local/ here, or the Mac mini); elsewhere they are listed for CI.
 Tests select library, binary and integration targets explicitly, followed by doc tests, so unrelated example
 executables are not built and linked again.
 
@@ -43,6 +44,7 @@ if "PARITY_SHARED" not in os.environ and not (ROOT / ".local" / "minecraft").exi
     # A fleet worktree without vanilla data still knows each harness's dependencies.
     os.environ["PARITY_SHARED"] = str(FLEET_SHARED)
 from tools import parity, release_train  # noqa: E402
+from tools.ci import rust_changes  # noqa: E402
 
 RBUILD = Path.home() / "fleet" / "rbuild"
 LINE_LIMIT = 500
@@ -82,9 +84,8 @@ def workspace_rust(path):
 
 
 def launcher_rust(path):
-    """Whether a change to path is built into the launcher (its own workspace)."""
-    return not is_doc(path) and any(path.startswith(p) for p in release_train.LAUNCHER_PATHS) and \
-        path != "launcher/links.json" and not path.startswith("launcher/docs/")
+    """Whether a change to path is built into the launcher (its own workspace): CI's launcher job's own rule."""
+    return rust_changes.needs_launcher([path])
 
 
 def touched_crates(paths, packages):
@@ -268,14 +269,25 @@ def parity_summary(output):
     return text
 
 
+# CI's verify job (.github/workflows/ci.yml): clippy over the whole workspace with the game's code mods, and over the
+# server build (the game without sound or controllers); tests with code mods and mod packaging.
+CI_CLIPPY = "cargo clippy --workspace --all-targets --locked --features horizon-client/mods -- -D warnings"
+CI_CLIPPY_SERVER = "cargo clippy -p horizon-client --all-targets --locked --no-default-features -- -D warnings"
+CI_TEST_FEATURES = "horizon-client/mods,horizon-mods/pack"
+
+
 def mod_features(crates):
-    """Code mods are off by default (docs/mods.md): on wherever horizon-mods is checked, as in CI."""
-    if crates is not None and "horizon-mods" not in crates:
-        return ""
-    features = ["horizon-mods/runtime", "horizon-mods/pack"]
-    if crates is None or "horizon-client" in crates:
+    """The features CI's workspace-wide test run gives these crates (code mods are off by default: docs/mods.md).
+    Cargo unifies features over the packages it builds, so a crate tested alone needs the ones the workspace would
+    have turned on for it: horizon-client's code mods, and horizon-mods' runtime, packaging and index."""
+    if crates is None:
+        return f" --features {CI_TEST_FEATURES}"
+    features = []
+    if "horizon-mods" in crates:
+        features += ["horizon-mods/runtime", "horizon-mods/pack", "horizon-mods/index"]
+    if "horizon-client" in crates:
         features.append("horizon-client/mods")
-    return f" --features {','.join(features)}"
+    return f" --features {','.join(features)}" if features else ""
 
 
 def plan(args, base, changed, crates_of, libraries, dependencies):
@@ -283,16 +295,18 @@ def plan(args, base, changed, crates_of, libraries, dependencies):
     rust = any(workspace_rust(path) for path in changed)
     launcher = any(launcher_rust(path) for path in changed)
     # The Python tests also hold ROADMAP.md to roadmap/roadmap.toml (tests/test_roadmap.py).
-    python = any(path.endswith(".py") or path.startswith(("tests/", "tools/", "roadmap/")) or path == "ROADMAP.md"
-                 for path in changed)
     crates = touched_crates(changed, crates_of) if rust else []
     # An unrecognised Rust path must not silently skip validation.
     if rust and crates == []:
         crates = None
     selection = "--workspace" if crates is None else " ".join(f"-p {shlex.quote(c)}" for c in crates)
+    # CI's own clippy commands: a crate checked alone gets other features than in CI's workspace-wide run, and an
+    # unused import behind a feature passed here and failed in CI (#1895). Warm, the workspace run costs about what
+    # the touched crates and their dependents did (14-32 s against 14-17 s on the Mac mini, 2026-10-26).
     clippy_crates = dependent_crates(crates, dependencies)
-    clippy_selection = "--workspace" if clippy_crates is None else " ".join(
-        f"-p {shlex.quote(c)}" for c in clippy_crates)
+    clippy = CI_CLIPPY
+    if clippy_crates is None or "horizon-client" in clippy_crates:
+        clippy += f" && {CI_CLIPPY_SERVER}"
     test_skip = None if crates is None or crates else "no crate touched"
     doc_crates = sorted(libraries if crates is None else libraries.intersection(crates))
     doc_selection = "--workspace" if crates is None else " ".join(f"-p {shlex.quote(c)}" for c in doc_crates)
@@ -300,11 +314,10 @@ def plan(args, base, changed, crates_of, libraries, dependencies):
     steps = [
         Step("Cargo.lock", where="git"),
         Step("Public tree", "python3 tools/check_public_tree.py", where="here"),
-        Step("Python tests", "python3 -m unittest discover -s tests", where="here",
-             skip=None if python else "no Python change", summary=unittest_passed),
+        # Always, as in CI: some read the crates, the roadmap or the workflows.
+        Step("Python tests", "python3 -m unittest discover -s tests", where="here", summary=unittest_passed),
         Step("rustfmt", "cargo fmt --all -- --check", skip=None if rust else no_rust),
-        Step("clippy", f"cargo clippy {clippy_selection}{mod_features(clippy_crates)} --all-targets --locked -- -D warnings",
-             skip=None if rust else no_rust),
+        Step("clippy", clippy, skip=None if rust else no_rust),
         Step("tests" + (": workspace" if crates is None else f": {', '.join(crates)}" if crates else ""),
              f"cargo test --locked {selection}{mod_features(crates)} --tests",
              skip=test_skip, summary=tests_passed),
@@ -404,7 +417,7 @@ def run_windows(steps, verbose):
         elif step.name == "rustfmt":
             command = ["cargo", "fmt", "--all", "--", "--check"]
         elif step.name == "clippy":
-            command = ["cargo", "clippy", "--workspace", "--all-targets", "--locked", "--", "-D", "warnings"]
+            command = shlex.split(CI_CLIPPY)  # the server build's clippy runs in CI (Linux)
         elif step.name.startswith("tests"):
             command = shlex.split(step.command)
         elif step.name == "tokens.css up to date":

From 6af81b600f6001f9e7ce25b549028f08fb106926 Mon Sep 17 00:00:00 2001
From: levzzz <86072227+levzzz5154@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:01:31 +0500
Subject: [PATCH 262/475] Push entities with moving pistons

Move players, mobs and common objects when piston block entities advance, applying collision and the per-tick piston limit. Exercise host, guest, inventory-open and mob pushes in both single-player paths, and compare the push geometry with vanilla.

Co-Authored-By: Codex (GPT-6) <noreply@openai.com>
---
 crates/horizon-client/src/collisions.rs       |  47 +-
 crates/horizon-client/src/game.rs             |  28 +-
 crates/horizon-client/src/game/minecarts.rs   |   2 +-
 .../horizon-client/src/game/moving_pistons.rs |   4 +-
 crates/horizon-client/src/game/piston_push.rs | 479 ++++++++++++++++++
 crates/horizon-client/src/game/remote.rs      |   2 +
 crates/horizon-client/src/mobs.rs             |   4 +
 crates/horizon-client/src/motion.rs           |  14 +-
 crates/horizon-client/src/world.rs            |   5 +-
 crates/horizon-world/examples/probe/main.rs   |   2 +
 .../examples/probe/piston_push_fixture.rs     | 163 ++++++
 crates/horizon-world/src/level/pistons.rs     |  18 +-
 crates/horizon-world/src/level/ticks.rs       |   6 +
 crates/horizon-world/src/lib.rs               |   1 +
 crates/horizon-world/src/piston_push.rs       | 461 +++++++++++++++++
 .../parity/VanillaPistonPushOracle.java       |  78 +++
 tools/lan_e2e.py                              |  57 ++-
 tools/test_piston_push_parity.py              | 193 +++++++
 18 files changed, 1542 insertions(+), 22 deletions(-)
 create mode 100644 crates/horizon-client/src/game/piston_push.rs
 create mode 100644 crates/horizon-world/examples/probe/piston_push_fixture.rs
 create mode 100644 crates/horizon-world/src/piston_push.rs
 create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPistonPushOracle.java
 create mode 100644 tools/test_piston_push_parity.py

diff --git a/crates/horizon-client/src/collisions.rs b/crates/horizon-client/src/collisions.rs
index 7c32bd829..9ec271b27 100644
--- a/crates/horizon-client/src/collisions.rs
+++ b/crates/horizon-client/src/collisions.rs
@@ -54,6 +54,27 @@ fn strider_liquid_shape() -> VoxelShape {
     VoxelShape::from_cube([1, 2, 1], &[true, false]).expect("a valid half-block column")
 }
 
+// Vanilla scopes this direction to Entity.move while a piston pushes it.
+thread_local! {
+    static PISTON_NOCLIP: std::cell::Cell<Option<horizon_core::geometry::Direction>> = const { std::cell::Cell::new(None) };
+}
+
+/// Suppress the moving part of pistons moving in this direction during a push.
+pub fn with_piston_noclip<T>(
+    direction: horizon_core::geometry::Direction,
+    f: impl FnOnce() -> T,
+) -> T {
+    struct Reset(Option<horizon_core::geometry::Direction>);
+    impl Drop for Reset {
+        fn drop(&mut self) {
+            PISTON_NOCLIP.with(|value| value.set(self.0));
+        }
+    }
+    let previous = PISTON_NOCLIP.with(|value| value.replace(Some(direction)));
+    let _reset = Reset(previous);
+    f()
+}
+
 pub struct SceneCollisions<'w, 'r> {
     pub world: &'w World,
     pub binding: &'w BlockCollisionRegistry<'r>,
@@ -324,7 +345,7 @@ impl DynamicSupportWorld for SceneCollisions<'_, '_> {
             return Ok(None);
         };
         pistons
-            .collision_shape(self, p, piston, None)
+            .collision_shape(self, p, piston, PISTON_NOCLIP.with(|value| value.get()))
             .map(Some)
             .map_err(io::Error::other)
     }
@@ -475,3 +496,27 @@ impl PowderSnowWorld for LookupCollisions<'_, '_> {
         Ok(false)
     }
 }
+
+#[cfg(test)]
+mod piston_noclip_tests {
+    use super::*;
+    use horizon_core::geometry::Direction;
+
+    #[test]
+    fn piston_noclip_is_scoped_and_restored_after_unwind() {
+        assert_eq!(PISTON_NOCLIP.with(|value| value.get()), None);
+        with_piston_noclip(Direction::East, || {
+            assert_eq!(
+                PISTON_NOCLIP.with(|value| value.get()),
+                Some(Direction::East)
+            );
+            let _ =
+                std::panic::catch_unwind(|| with_piston_noclip(Direction::West, || panic!("test")));
+            assert_eq!(
+                PISTON_NOCLIP.with(|value| value.get()),
+                Some(Direction::East)
+            );
+        });
+        assert_eq!(PISTON_NOCLIP.with(|value| value.get()), None);
+    }
+}
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index f9edd98bb..cffafb7d3 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -127,6 +127,7 @@ mod persist;
 mod perspective;
 mod pickups;
 mod piglins;
+mod piston_push;
 mod player_equip;
 mod postprocess;
 mod potions;
@@ -2821,20 +2822,29 @@ impl Game<'_> {
             b.run_block_events(level, ticks);
             b.tick_block_entities(level, ticks);
         });
+        // `PistonMovingBlockEntity.tick` pushes what its block just ran into,
+        // with the progress it is about to take.
+        let pushes = std::mem::take(&mut self.block_ticks.piston_pushes);
+        self.push_piston_entities(pushes);
+        self.process_level_events()?;
         self.sync_moving_pistons();
-        self.process_level_events()
+        Ok(())
     }
     /// Copies the moving-piston block entities into the world, where the
     /// collision queries and the renderer read them.
     fn sync_moving_pistons(&mut self) {
-        let pistons = &mut self.world.moving_pistons;
-        pistons.clear();
-        pistons.extend(
-            self.block_ticks
-                .moving_pistons
-                .iter()
-                .map(|(p, piston)| ([p.x, p.y, p.z], piston.shape_state())),
-        );
+        let previous = std::mem::take(&mut self.world.moving_pistons);
+        let current: Vec<_> = self
+            .block_ticks
+            .moving_pistons
+            .iter()
+            .map(|(p, piston)| ([p.x, p.y, p.z], piston.shape_state()))
+            .collect();
+        self.world.moving_piston_fallback = previous
+            .into_iter()
+            .filter(|(pos, _)| !current.iter().any(|(next, _)| next == pos))
+            .collect();
+        self.world.moving_pistons = current;
     }
     /// `ServerLevel.tick`'s scheduled block then fluid ticks, one at a time:
     /// the side effects of each (a shrieker summoning a warden, drops, game
diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index 072059e49..58e1a2690 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -73,7 +73,7 @@ pub(super) struct Minecart {
     pub yaw: f32,
     pub previous_yaw: f32,
     pub flipped: bool,
-    on_ground: bool,
+    pub(super) on_ground: bool,
     horizontal_collision: bool,
     fall_distance: f64,
     pub hurt_time: i32,
diff --git a/crates/horizon-client/src/game/moving_pistons.rs b/crates/horizon-client/src/game/moving_pistons.rs
index 17247850e..e1bdf89d0 100644
--- a/crates/horizon-client/src/game/moving_pistons.rs
+++ b/crates/horizon-client/src/game/moving_pistons.rs
@@ -14,7 +14,9 @@ impl Game<'_> {
         out: &mut Vec<Vertex>,
     ) {
         let partial = alpha as f32;
-        for &(p, piston) in &self.world.moving_pistons {
+        let mut states = self.world.moving_pistons.clone();
+        states.extend(self.world.moving_piston_fallback.iter().copied());
+        for (p, piston) in states {
             let Some((block, base)) = self.moving_piston_blocks(piston, partial) else {
                 continue;
             };
diff --git a/crates/horizon-client/src/game/piston_push.rs b/crates/horizon-client/src/game/piston_push.rs
new file mode 100644
index 000000000..9c3eebb50
--- /dev/null
+++ b/crates/horizon-client/src/game/piston_push.rs
@@ -0,0 +1,479 @@
+//! `PistonMovingBlockEntity.moveCollidedEntities` and `moveStuckEntities` for
+//! the entities the game moves itself: the players and the mobs.
+//!
+//! The geometry is in [`horizon_world::piston_push`]; this file supplies the
+//! bodies and applies the movement the way `Entity.move(MoverType.PISTON, …)`
+//! does: limited to 0.51 blocks per tick per axis (`Entity.limitPistonMovement`),
+//! then run through the block collision scan, so a pushed entity stops at a
+//! wall instead of passing through it.
+//!
+use super::Game;
+use horizon_client::collisions::{SceneCollisions, with_piston_noclip};
+use horizon_core::geometry::{Aabb, Direction, Vec3};
+use horizon_core::position::BlockPos;
+use horizon_world::{level::pistons::MovingPiston, piston_movement::PistonMovement, piston_push};
+
+/// What one piston asks for this tick: where it is, its state, and the progress
+/// `moveCollidedEntities` runs at (before the tick stores it).
+pub(super) type Push = (BlockPos, MovingPiston, f32);
+
+/// Which entity was pushed, so its storage can be reached after the world
+/// borrow ends.
+#[derive(Clone, Copy, Hash, PartialEq, Eq)]
+enum Target {
+    Player,
+    Guest(u32),
+    Mob(usize),
+    Item(usize),
+    Boat(usize),
+    Cart(usize),
+    ArmorStand(usize),
+}
+
+/// `Entity.getStepHeight` of each body, read before the push.
+struct StepHeights {
+    player: f32,
+    guests: std::collections::HashMap<u32, f32>,
+}
+
+/// What the push needs from one entity.
+#[derive(Clone, Copy)]
+struct Body {
+    bounds: Aabb,
+    position: Vec3,
+    on_ground: bool,
+    step_height: f32,
+    /// Standing on the piston's own block (`Entity.isSupportedBy`).
+    supported: bool,
+}
+
+impl Game<'_> {
+    /// Push whatever this tick's moving pistons ran into, in the order the
+    /// pistons ticked: vanilla pushes from each block entity's own tick.
+    pub(super) fn push_piston_entities(&mut self, pushes: Vec<Push>) {
+        let mut accumulators = std::collections::HashMap::new();
+        for push in pushes {
+            self.push_for_piston(push, &mut accumulators);
+        }
+    }
+
+    fn push_for_piston(
+        &mut self,
+        (pos, piston, new_progress): Push,
+        accumulators: &mut std::collections::HashMap<Target, PistonMovement>,
+    ) {
+        let delta_progress = f64::from(new_progress - piston.progress);
+        if delta_progress <= 0.0 {
+            return;
+        }
+        let Some(bindings) = self.collision.pistons() else {
+            return;
+        };
+        let Ok(state) = bindings.collision_related_state(piston.shape_state()) else {
+            return;
+        };
+        let mut scene = SceneCollisions {
+            world: &self.world,
+            binding: self.collision,
+            subject: None,
+        };
+        let Ok(shape) = self
+            .collision
+            .collision_shape(&mut scene, state, [pos.x, pos.y, pos.z])
+        else {
+            return;
+        };
+        if shape.is_empty() {
+            return;
+        }
+        let movement = piston.movement_direction();
+        let boxes: Vec<Aabb> = shape.boxes().to_vec();
+        let facts = self.res.facts();
+        let slime = &*facts.get(piston.moved_state).name == "minecraft:slime_block";
+        let honey = &*facts.get(piston.moved_state).name == "minecraft:honey_block";
+        // `moveStuckEntities` asks the moved state's own top for its box.
+        let sticky_top = if honey {
+            let mut scene = SceneCollisions {
+                world: &self.world,
+                binding: self.collision,
+                subject: None,
+            };
+            self.collision
+                .collision_shape(&mut scene, piston.moved_state, [pos.x, pos.y, pos.z])
+                .ok()
+                .and_then(|s| s.bounds())
+                .map_or(0.0, |b| b.max_position().y)
+        } else {
+            0.0
+        };
+
+        let steps = self.push_step_heights();
+        let search = shape.bounds().map(|bounds| {
+            piston_push::movement_search_area(
+                piston_push::move_by_position_and_progress(pos, bounds, piston.shape_state()),
+                movement,
+                delta_progress,
+            )
+        });
+        let targets = self.push_targets();
+        for &target in &targets {
+            let Some(body) = self.push_body(target, pos, &steps) else {
+                continue;
+            };
+            let amount = piston_push::collided_amount(
+                &boxes,
+                pos,
+                piston.shape_state(),
+                new_progress,
+                movement,
+                body.bounds,
+            );
+            if slime && search.is_some_and(|area| area.intersects(body.bounds)) {
+                self.bounce(target, movement);
+            }
+            if amount > 0.0 {
+                let step = piston_push::step_vector(movement);
+                let before = body.bounds;
+                self.move_pushed(
+                    target,
+                    before,
+                    body.step_height,
+                    body.on_ground,
+                    step.scale(amount),
+                    movement,
+                    accumulators,
+                );
+                // `fixEntityWithinPistonBase`: a retracting source piston drags
+                // an entity that is still inside its own block.
+                if !piston.extending
+                    && piston.source
+                    && let Some(after) = self.push_body(target, pos, &steps)
+                    && let Some(fix) = piston_push::fix_within_piston_base(
+                        pos,
+                        after.bounds,
+                        movement,
+                        delta_progress,
+                    )
+                {
+                    let back = piston_push::step_vector(movement.opposite());
+                    self.move_pushed(
+                        target,
+                        after.bounds,
+                        after.step_height,
+                        after.on_ground,
+                        back.scale(fix),
+                        movement,
+                        accumulators,
+                    );
+                }
+            }
+        }
+        // Vanilla selects honey passengers after all collided entities have moved.
+        if honey && movement.normal()[1] == 0 {
+            let area = piston_push::sticky_area(pos, piston.shape_state(), sticky_top);
+            for target in targets {
+                let Some(body) = self.push_body(target, pos, &steps) else {
+                    continue;
+                };
+                if piston_push::sticky_entity_selected(
+                    area,
+                    body.bounds,
+                    horizon_world::level::data::PushReaction::PushPull,
+                    body.on_ground,
+                    body.supported,
+                    body.position,
+                ) {
+                    self.move_pushed(
+                        target,
+                        body.bounds,
+                        body.step_height,
+                        body.on_ground,
+                        piston_push::step_vector(movement).scale(delta_progress),
+                        movement,
+                        accumulators,
+                    );
+                }
+            }
+        }
+    }
+
+    /// `Entity.getStepHeight` for each body, read once: the attribute lookup
+    /// needs the mutable body, and the push only needs the number.
+    fn push_step_heights(&mut self) -> StepHeights {
+        let player = self
+            .player
+            .as_mut()
+            .and_then(|p| p.attribute("minecraft:step_height").ok())
+            .map_or(0.6, |v| v as f32);
+        let mut guests = std::collections::HashMap::new();
+        if let Some(host) = self.lan.as_mut() {
+            for g in &mut host.hub.guests {
+                let step = g
+                    .motion
+                    .as_mut()
+                    .and_then(|m| m.attribute("minecraft:step_height").ok())
+                    .map_or(0.6, |v| v as f32);
+                guests.insert(g.conn, step);
+            }
+        }
+        StepHeights { player, guests }
+    }
+
+    /// The entities a moving block can run into: the window's player, the LAN
+    /// guests in the level, then the mobs.
+    fn push_targets(&self) -> Vec<Target> {
+        let mut targets = Vec::new();
+        if self.player.is_some() {
+            targets.push(Target::Player);
+        }
+        if let Some(host) = self.lan.as_ref() {
+            targets.extend(
+                host.hub
+                    .guests
+                    .iter()
+                    .filter(|g| host.hub.here(g) && g.loaded && !g.dead)
+                    .map(|g| Target::Guest(g.conn)),
+            );
+        }
+        targets.extend((0..self.mobs.len()).map(Target::Mob));
+        targets.extend((0..self.dropped.len()).map(Target::Item));
+        targets.extend((0..self.boats.len()).map(Target::Boat));
+        targets.extend((0..self.carts.len()).map(Target::Cart));
+        targets.extend((0..self.armor_stands.len()).map(Target::ArmorStand));
+        targets
+    }
+
+    /// What the push needs from one entity, or `None` when it is not pushed:
+    /// removed, dead, a spectator, or an armor-stand marker.
+    fn push_body(&self, target: Target, pos: BlockPos, steps: &StepHeights) -> Option<Body> {
+        let at = [pos.x, pos.y, pos.z];
+        match target {
+            Target::Player => {
+                let p = self.player.as_ref()?;
+                if p.spectator {
+                    return None;
+                }
+                Some(Body {
+                    bounds: p.bounds(),
+                    position: p.position,
+                    on_ground: p.ground.on_ground,
+                    step_height: steps.player,
+                    supported: p.ground.supporting_block == Some(pos),
+                })
+            }
+            Target::Guest(conn) => {
+                let host = self.lan.as_ref()?;
+                let g = host.hub.guests.iter().find(|g| g.conn == conn)?;
+                if g.dead || g.game_mode == 3 {
+                    return None;
+                }
+                let p = g.position;
+                Some(Body {
+                    bounds: Aabb::new(
+                        Vec3::new(p[0] - 0.3, p[1], p[2] - 0.3),
+                        Vec3::new(p[0] + 0.3, p[1] + 1.8, p[2] + 0.3),
+                    ),
+                    position: Vec3::new(p[0], p[1], p[2]),
+                    on_ground: g.on_ground,
+                    step_height: steps.guests.get(&conn).copied().unwrap_or(0.6),
+                    supported: g
+                        .motion
+                        .as_ref()
+                        .is_some_and(|m| m.ground.supporting_block == Some(pos)),
+                })
+            }
+            Target::Mob(i) => {
+                let m = &self.mobs[i];
+                if m.removed || !m.alive() {
+                    return None;
+                }
+                Some(Body {
+                    bounds: m.bounds(),
+                    position: m.position,
+                    on_ground: m.on_ground,
+                    step_height: m.kind.step_height as f32,
+                    supported: m.supporting == Some(at),
+                })
+            }
+            Target::Item(i) => {
+                let entity = &self.dropped[i];
+                Some(Body {
+                    bounds: entity.bounds(),
+                    position: entity.position,
+                    on_ground: entity.on_ground,
+                    step_height: 0.0,
+                    supported: false,
+                })
+            }
+            Target::Boat(i) => {
+                let entity = &self.boats[i];
+                Some(Body {
+                    bounds: entity.bounds(),
+                    position: entity.position,
+                    on_ground: entity.on_ground,
+                    step_height: 0.0,
+                    supported: false,
+                })
+            }
+            Target::Cart(i) => {
+                let entity = &self.carts[i];
+                Some(Body {
+                    bounds: entity.bounds(),
+                    position: entity.position,
+                    on_ground: entity.on_ground,
+                    step_height: 0.0,
+                    supported: false,
+                })
+            }
+            Target::ArmorStand(i) => {
+                let entity = &self.armor_stands[i];
+                if entity.marker {
+                    return None;
+                }
+                Some(Body {
+                    bounds: entity.bounds(),
+                    position: entity.position,
+                    on_ground: entity.on_ground,
+                    step_height: 0.0,
+                    supported: false,
+                })
+            }
+        }
+    }
+
+    /// `Entity.move(MoverType.PISTON, movement)` for one pushed entity: the
+    /// per-tick piston limit, then the block collision scan.
+    fn move_pushed(
+        &mut self,
+        target: Target,
+        before: Aabb,
+        step_height: f32,
+        on_ground: bool,
+        movement: Vec3,
+        piston_direction: Direction,
+        accumulators: &mut std::collections::HashMap<Target, PistonMovement>,
+    ) {
+        let Some(limited) = self.limit_piston(target, movement, accumulators) else {
+            return;
+        };
+        // `limitPistonMovement` returns zero once the tick's budget is spent.
+        if limited == Vec3::ZERO {
+            return;
+        }
+        let resolved = with_piston_noclip(piston_direction, || {
+            SceneCollisions {
+                world: &self.world,
+                binding: self.collision,
+                subject: None,
+            }
+            .resolve(before, limited, step_height, on_ground)
+            .unwrap_or(Vec3::ZERO)
+        });
+        if resolved.length_squared() <= 1.0e-7
+            && limited.length_squared() - resolved.length_squared() >= 1.0e-7
+        {
+            return;
+        }
+        self.apply_push(target, resolved);
+    }
+
+    /// `Entity.limitPistonMovement`: each axis may travel at most 0.51 blocks
+    /// per game tick, and a move touches only its first non-zero axis.
+    fn limit_piston(
+        &mut self,
+        target: Target,
+        movement: Vec3,
+        accumulators: &mut std::collections::HashMap<Target, PistonMovement>,
+    ) -> Option<Vec3> {
+        let time = self.world.game_time;
+        let limit = |state: &mut PistonMovement| state.limit(movement, || Ok::<i64, ()>(time)).ok();
+        match target {
+            Target::Player => {
+                let p = self.player.as_mut()?;
+                limit(&mut p.piston)
+            }
+            Target::Guest(conn) => {
+                let host = self.lan.as_mut()?;
+                let g = host.hub.guests.iter_mut().find(|g| g.conn == conn)?;
+                limit(&mut g.motion.as_deref_mut()?.piston)
+            }
+            Target::Mob(i) => limit(&mut self.mobs[i].piston),
+            _ => limit(accumulators.entry(target).or_default()),
+        }
+    }
+
+    fn apply_push(&mut self, target: Target, movement: Vec3) {
+        match target {
+            Target::Player => {
+                if let Some(p) = self.player.as_mut() {
+                    p.position = p.position.add_vector(movement);
+                }
+            }
+            Target::Guest(conn) => {
+                if let Some(host) = self.lan.as_mut()
+                    && let Some(g) = host.hub.guests.iter_mut().find(|g| g.conn == conn)
+                {
+                    // The body and the hub's copy of its position move together:
+                    // `leave_guest` writes the body back over the hub's.
+                    for (slot, delta) in g.position.iter_mut().zip(movement.components()) {
+                        *slot += delta;
+                    }
+                    if let Some(m) = g.motion.as_deref_mut() {
+                        m.position = m.position.add_vector(movement);
+                    }
+                }
+            }
+            Target::Mob(i) => {
+                let m = &mut self.mobs[i];
+                m.position = m.position.add_vector(movement);
+            }
+            Target::Item(i) => {
+                self.dropped[i].position = self.dropped[i].position.add_vector(movement)
+            }
+            Target::Boat(i) => self.boats[i].position = self.boats[i].position.add_vector(movement),
+            Target::Cart(i) => self.carts[i].position = self.carts[i].position.add_vector(movement),
+            Target::ArmorStand(i) => {
+                self.armor_stands[i].position = self.armor_stands[i].position.add_vector(movement)
+            }
+        }
+    }
+
+    /// `causeBounce`: a slime block sets the velocity along the movement axis.
+    fn bounce(&mut self, target: Target, movement: Direction) {
+        match target {
+            Target::Player => {
+                if let Some(p) = self.player.as_mut() {
+                    p.velocity = piston_push::bounce_velocity(movement, p.velocity);
+                }
+            }
+            Target::Mob(i) => {
+                let m = &mut self.mobs[i];
+                m.velocity = piston_push::bounce_velocity(movement, m.velocity);
+            }
+            Target::Guest(conn) => {
+                if let Some(host) = self.lan.as_mut()
+                    && let Some(guest) = host.hub.guests.iter_mut().find(|g| g.conn == conn)
+                    && let Some(motion) = guest.motion.as_deref_mut()
+                {
+                    motion.velocity = piston_push::bounce_velocity(movement, motion.velocity);
+                }
+            }
+            Target::Item(i) => {
+                self.dropped[i].velocity =
+                    piston_push::bounce_velocity(movement, self.dropped[i].velocity)
+            }
+            Target::Boat(i) => {
+                self.boats[i].velocity =
+                    piston_push::bounce_velocity(movement, self.boats[i].velocity)
+            }
+            Target::Cart(i) => {
+                self.carts[i].velocity =
+                    piston_push::bounce_velocity(movement, self.carts[i].velocity)
+            }
+            Target::ArmorStand(i) => {
+                self.armor_stands[i].velocity =
+                    piston_push::bounce_velocity(movement, self.armor_stands[i].velocity)
+            }
+        }
+    }
+}
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..eb7f1409c 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3185,6 +3185,8 @@ impl Game<'_> {
         self.with_level(|b, level, ticks| {
             b.client_tick_block_entities(level, ticks);
         });
+        let pushes = std::mem::take(&mut self.block_ticks.piston_pushes);
+        self.push_piston_entities(pushes);
         self.sync_moving_pistons();
         self.tick_hand();
         self.tick_particles();
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index f4086216d..d27a13658 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -819,6 +819,9 @@ pub struct Mob {
     pub previous_swell: i32,
     pub ambient_timer: i32,
     pub fall_distance: f64,
+    /// `Entity.pistonDeltas` and `pistonDeltasGameTime`: how far a moving
+    /// block has pushed this mob this tick (0.51 at most on any axis).
+    pub piston: horizon_world::piston_movement::PistonMovement,
     pub persistent: bool,
     /// `CustomName` (plain text) and `CustomNameVisible`.
     pub custom_name: Option<String>,
@@ -1648,6 +1651,7 @@ impl Mob {
             // Mob.ambientSoundTime starts at 0.
             ambient_timer: 0,
             fall_distance: 0.0,
+            piston: Default::default(),
             persistent: false,
             random,
             ai: Box::default(),
diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index 234390e23..9e69dc235 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -223,6 +223,9 @@ pub struct PlayerMotion {
     pub history: MovementHistory,
     pub fall_distance: f64,
     pub stuck_multiplier: Vec3,
+    /// `Entity.pistonDeltas` and `pistonDeltasGameTime`: how far a moving
+    /// block has pushed this entity this tick (0.51 at most on any axis).
+    pub piston: horizon_world::piston_movement::PistonMovement,
     pub yaw: f32,
     pub head_yaw: f32,
     pub jumping: bool,
@@ -428,6 +431,7 @@ impl PlayerMotion {
             history: MovementHistory::default(),
             fall_distance: 0.0,
             stuck_multiplier: Vec3::ZERO,
+            piston: Default::default(),
             yaw: 0.0,
             head_yaw: 0.0,
             jumping: false,
@@ -1795,8 +1799,14 @@ impl EntityMoveWorld for MotionWorld<'_, '_, '_> {
     fn set_collision_flags(&mut self, value: CollisionFlags) {
         self.player.collision = value;
     }
-    fn limit_piston_movement(&mut self, _: Vec3) -> Result<Vec3> {
-        Err("piston movement requires a ticking entity runtime".into())
+    /// `Entity.limitPistonMovement`: the per-tick 0.51-block budget shared by
+    /// every move on an axis. A failed game-time read leaves the accumulator
+    /// as it was, as native does.
+    fn limit_piston_movement(&mut self, movement: Vec3) -> Result<Vec3> {
+        let time = self.scene.game_time;
+        self.player
+            .piston
+            .limit(movement, || Ok::<i64, Box<dyn std::error::Error>>(time))
     }
     fn stuck_multiplier(&self) -> Vec3 {
         self.player.stuck_multiplier
diff --git a/crates/horizon-client/src/world.rs b/crates/horizon-client/src/world.rs
index 83083eba2..00ff04ac5 100644
--- a/crates/horizon-client/src/world.rs
+++ b/crates/horizon-client/src/world.rs
@@ -93,11 +93,13 @@ pub struct World {
     pub light_log: Option<crate::fast_hash::FxHashMap<(i32, i32), u32>>,
     /// The villager POIs of each section (`PoiManager`'s sections).
     pub pois: crate::poi_sections::PoiSections<crate::mobs::villager_brain::Poi>,
+    /// Moving-piston states removed during the last tick; retained until the
+    /// final block mesh is visible.
+    pub moving_piston_fallback: Vec<([i32; 3], horizon_world::piston_shape::MovingPistonState)>,
     /// The moving-piston block entities of the level, by position, copied
     /// from the block ticks after each tick: collision and rendering read them.
     pub moving_pistons: Vec<([i32; 3], horizon_world::piston_shape::MovingPistonState)>,
 }
-/// ServerLevel weather state (advanceWeatherCycle).
 #[derive(Clone, Copy, Debug, Default)]
 pub struct Weather {
     pub clear_time: i32,
@@ -187,6 +189,7 @@ impl World {
             weather: Weather::default(),
             block_log: None,
             light_log: None,
+            moving_piston_fallback: Vec::new(),
             moving_pistons: Vec::new(),
             pois: Default::default(),
         }
diff --git a/crates/horizon-world/examples/probe/main.rs b/crates/horizon-world/examples/probe/main.rs
index b87e5620a..56dbc8843 100644
--- a/crates/horizon-world/examples/probe/main.rs
+++ b/crates/horizon-world/examples/probe/main.rs
@@ -137,6 +137,7 @@ mod movement_support_fixture;
 mod object_open_map_fixture;
 mod object_open_set_fixture;
 mod piston_movement_fixture;
+mod piston_push_fixture;
 mod piston_shape_fixture;
 mod placement_fixture;
 mod player_equipment_fixture;
@@ -309,6 +310,7 @@ probes! {
     object_open_map_fixture,
     object_open_set_fixture,
     piston_movement_fixture,
+    piston_push_fixture,
     piston_shape_fixture,
     placement_fixture,
     player_equipment_fixture,
diff --git a/crates/horizon-world/examples/probe/piston_push_fixture.rs b/crates/horizon-world/examples/probe/piston_push_fixture.rs
new file mode 100644
index 000000000..1d40cd610
--- /dev/null
+++ b/crates/horizon-world/examples/probe/piston_push_fixture.rs
@@ -0,0 +1,163 @@
+//! The moving-piston push maths against the real game: `PistonMath.getMovementArea`,
+//! `moveByPositionAndProgress`, `getMovement`, the `moveCollidedEntities` loop
+//! over the block's own boxes, and `moveStuckEntities`' box with
+//! `matchesStickyCritera`.
+use crate::support::common::f64_hex;
+use horizon_core::{
+    geometry::{Aabb, Direction, Vec3},
+    position::BlockPos,
+};
+use horizon_world::{level::data::PushReaction, piston_push, piston_shape::MovingPistonState};
+use serde_json::Value;
+use std::{
+    fs,
+    io::{self, BufWriter, Write},
+    path::Path,
+};
+
+fn number(v: &Value) -> f64 {
+    f64::from_bits(u64::from_str_radix(v.as_str().unwrap(), 16).unwrap())
+}
+
+fn float(v: &Value) -> f32 {
+    f32::from_bits(u32::from_str_radix(v.as_str().unwrap(), 16).unwrap())
+}
+
+fn aabb(v: &Value) -> Aabb {
+    let a = v.as_array().unwrap();
+    Aabb::new(
+        Vec3::new(number(&a[0]), number(&a[1]), number(&a[2])),
+        Vec3::new(number(&a[3]), number(&a[4]), number(&a[5])),
+    )
+}
+
+fn direction(index: i64) -> Direction {
+    Direction::ALL[index.rem_euclid(6) as usize]
+}
+
+fn reaction(index: i64) -> PushReaction {
+    match index.rem_euclid(5) {
+        0 => PushReaction::PushPull,
+        1 => PushReaction::Push,
+        2 => PushReaction::Popped,
+        3 => PushReaction::Immoveable,
+        _ => PushReaction::IgnoreEntity,
+    }
+}
+
+fn line(out: &mut impl Write, name: &str, b: Aabb) -> io::Result<()> {
+    let (min, max) = (b.min_position(), b.max_position());
+    writeln!(
+        out,
+        "{name} {} {} {} {} {} {}",
+        f64_hex(min.x),
+        f64_hex(min.y),
+        f64_hex(min.z),
+        f64_hex(max.x),
+        f64_hex(max.y),
+        f64_hex(max.z)
+    )
+}
+
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let arg = crate::args().nth(1).expect("private fixture directory");
+    let dir = Path::new(&arg);
+    let mut out = BufWriter::new(fs::File::create(dir.join("rust.txt"))?);
+    for text in fs::read_to_string(dir.join("inputs.txt"))?.lines() {
+        let f: Value = serde_json::from_str(text)?;
+        let p = &f["pos"];
+        let pos = BlockPos::new(
+            p[0].as_i64().unwrap() as i32,
+            p[1].as_i64().unwrap() as i32,
+            p[2].as_i64().unwrap() as i32,
+        );
+        let progress = float(&f["progress"]);
+        let piston = MovingPistonState {
+            moved_state: horizon_world::registry::BlockStateId(0),
+            direction: direction(f["direction"].as_i64().unwrap()),
+            extending: f["extending"].as_bool().unwrap(),
+            source: f["source"].as_bool().unwrap(),
+            progress,
+            previous_progress: progress,
+        };
+        let new_progress = float(&f["new_progress"]);
+        let delta_progress = f64::from(new_progress - progress);
+        let movement = piston.movement_direction();
+        let block_box = aabb(&f["block_box"]);
+        let entity = aabb(&f["entity"]);
+        let movement_box = aabb(&f["movement_box"]);
+
+        writeln!(
+            out,
+            "extended {:08x}",
+            piston_push::extended_progress(piston, progress).to_bits()
+        )?;
+        let origin = piston_push::move_by_position_and_progress(pos, block_box, piston);
+        line(&mut out, "origin", origin)?;
+        line(
+            &mut out,
+            "area",
+            piston_push::movement_area(block_box, movement, delta_progress),
+        )?;
+        for (name, face) in [
+            ("east", Direction::East),
+            ("west", Direction::West),
+            ("up", Direction::Up),
+            ("down", Direction::Down),
+            ("south", Direction::South),
+            ("north", Direction::North),
+        ] {
+            writeln!(
+                out,
+                "movement {name} {}",
+                f64_hex(piston_push::get_movement(movement_box, face, entity))
+            )?;
+        }
+
+        // `moveCollidedEntities`' loop: the furthest box reaches into the
+        // entity, capped at the progress delta, plus the push offset.
+        let boxes: Vec<Aabb> = f["boxes"].as_array().unwrap().iter().map(aabb).collect();
+        let mut delta: f64 = 0.0;
+        let mut capped = false;
+        for block in &boxes {
+            let moving = piston_push::movement_area(
+                piston_push::move_by_position_and_progress(pos, *block, piston),
+                movement,
+                delta_progress,
+            );
+            if moving.intersects(entity) {
+                delta = delta.max(piston_push::get_movement(moving, movement, entity));
+                if delta >= delta_progress {
+                    capped = true;
+                    break;
+                }
+            }
+        }
+        let collided = if delta <= 0.0 {
+            0.0
+        } else {
+            delta.min(delta_progress) + piston_push::PUSH_OFFSET
+        };
+        writeln!(out, "collided {} {capped}", f64_hex(collided))?;
+        line(
+            &mut out,
+            "search",
+            piston_push::movement_search_area(origin, movement, delta_progress),
+        )?;
+        let sticky = piston_push::sticky_area(pos, piston, number(&f["sticky_top"]));
+        line(&mut out, "sticky", sticky)?;
+        writeln!(
+            out,
+            "matches {}",
+            piston_push::matches_sticky_criteria(
+                sticky,
+                reaction(f["reaction"].as_i64().unwrap()),
+                f["on_ground"].as_bool().unwrap(),
+                f["supported"].as_bool().unwrap(),
+                Vec3::new(number(&f["entity_x"]), 0.0, number(&f["entity_z"])),
+            )
+        )?;
+    }
+    out.flush()?;
+    Ok(())
+}
diff --git a/crates/horizon-world/src/level/pistons.rs b/crates/horizon-world/src/level/pistons.rs
index 45e469efd..70e8aa32a 100644
--- a/crates/horizon-world/src/level/pistons.rs
+++ b/crates/horizon-world/src/level/pistons.rs
@@ -182,7 +182,9 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
             self.neighbor_changed_at(pos, block);
         }
     }
-    /// `PistonMovingBlockEntity.tick` (entity pushing excluded).
+    /// `PistonMovingBlockEntity.tick`. A piston that is still moving reports
+    /// the push `moveCollidedEntities` would do at its new progress; the caller
+    /// moves the entities, because `Ticks` has none (`piston_pushes`).
     fn moving_piston_tick(&mut self, pos: BlockPos) {
         let Some(mut piston) = self.moving_piston(pos) else {
             return;
@@ -227,14 +229,20 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
                 }
             }
         } else {
-            piston.progress = (piston.progress + 0.5).min(1.0);
-            if let Some(entry) = self
+            // moveCollidedEntities and moveStuckEntities run with the new
+            // progress but read the old one off the entity (their delta),
+            // so the push carries the piston as it was before the advance.
+            let old = piston;
+            let new_progress = (old.progress + 0.5).min(1.0);
+            let current = self
                 .ticks
                 .moving_pistons
                 .iter_mut()
-                .find(|(p, _)| *p == pos)
-            {
+                .find(|(p, _)| *p == pos);
+            if let Some(entry) = current {
+                piston.progress = new_progress;
                 entry.1 = piston;
+                self.ticks.piston_pushes.push((pos, old, new_progress));
             }
         }
     }
diff --git a/crates/horizon-world/src/level/ticks.rs b/crates/horizon-world/src/level/ticks.rs
index c8d715623..195078e31 100644
--- a/crates/horizon-world/src/level/ticks.rs
+++ b/crates/horizon-world/src/level/ticks.rs
@@ -29,6 +29,11 @@ pub struct Ticks {
     /// Moving-piston block entities in ticker order (render and collide
     /// moving blocks from these; see `piston_shape`).
     pub moving_pistons: Vec<(BlockPos, super::pistons::MovingPiston)>,
+    /// The pushes this tick's moving-piston block entities asked for: each
+    /// piston with the progress it is about to reach, in the order they ticked
+    /// (`PistonMovingBlockEntity.tick`'s `moveCollidedEntities` call). The
+    /// caller moves entities by these; `Ticks` has no entities of its own.
+    pub piston_pushes: Vec<(BlockPos, super::pistons::MovingPiston, f32)>,
     pub(crate) next_block_entity_id: u64,
     /// `ServerLevel.blockEvents`, run by `Behaviours::run_block_events`.
     pub block_events: Vec<super::pistons::BlockEventData>,
@@ -65,6 +70,7 @@ impl Ticks {
             comparator_outputs: Default::default(),
             torch_toggles: Vec::new(),
             moving_pistons: Vec::new(),
+            piston_pushes: Vec::new(),
             next_block_entity_id: 0,
             block_events: Vec::new(),
             handling_tick: false,
diff --git a/crates/horizon-world/src/lib.rs b/crates/horizon-world/src/lib.rs
index b6d05ecf6..6df870d42 100644
--- a/crates/horizon-world/src/lib.rs
+++ b/crates/horizon-world/src/lib.rs
@@ -94,6 +94,7 @@ pub mod nbt;
 pub mod object_open_map;
 pub mod object_open_set;
 pub mod piston_movement;
+pub mod piston_push;
 pub mod piston_shape;
 pub mod player_food;
 pub mod player_health;
diff --git a/crates/horizon-world/src/piston_push.rs b/crates/horizon-world/src/piston_push.rs
new file mode 100644
index 000000000..5f64f22ba
--- /dev/null
+++ b/crates/horizon-world/src/piston_push.rs
@@ -0,0 +1,461 @@
+//! `PistonMovingBlockEntity.moveCollidedEntities`, `moveStuckEntities` and
+//! `fixEntityWithinPistonBase` over immutable geometry.
+//!
+//! Entity storage, the moving entities themselves and the blocks they collide
+//! with belong to the caller: these functions decide *how far* an entity is
+//! pushed, which is the part that must match vanilla to the bit. The movement
+//! they describe is an `Entity.move(MoverType.PISTON, …)`, so the caller still
+//! applies it through its own collision resolution and per-tick piston limit.
+use crate::{level::data::PushReaction, piston_shape::MovingPistonState};
+use horizon_core::{
+    geometry::{Aabb, Direction, Vec3},
+    position::BlockPos,
+};
+
+/// `PistonMovingBlockEntity.PUSH_OFFSET`.
+pub const PUSH_OFFSET: f64 = 0.01;
+
+/// `PistonMovingBlockEntity.getExtendedProgress`: where along its travel the
+/// moved block is, in blocks (negative before it starts, 0 when it arrives).
+pub fn extended_progress(piston: MovingPistonState, progress: f32) -> f32 {
+    if piston.extending {
+        progress - 1.0
+    } else {
+        1.0 - progress
+    }
+}
+
+/// `Direction.getAxisDirection().getStep()`.
+fn step_along(direction: Direction) -> i32 {
+    match direction {
+        Direction::East | Direction::Up | Direction::South => 1,
+        Direction::West | Direction::Down | Direction::North => -1,
+    }
+}
+
+/// `Direction.getStepX/Y/Z` as a vector.
+pub fn step_vector(direction: Direction) -> Vec3 {
+    let [x, y, z] = direction.normal();
+    Vec3::new(f64::from(x), f64::from(y), f64::from(z))
+}
+
+/// `PistonMath.getMovementArea`: the slab an entity's box must reach into to be
+/// run over by `amount` of further travel along `direction`.
+pub fn movement_area(aabb: Aabb, direction: Direction, amount: f64) -> Aabb {
+    let delta = amount * f64::from(step_along(direction));
+    let low = delta.min(0.0);
+    let high = delta.max(0.0);
+    let (min, max) = (aabb.min_position(), aabb.max_position());
+    match direction {
+        Direction::West => Aabb::new(
+            Vec3::new(min.x + low, min.y, min.z),
+            Vec3::new(min.x + high, max.y, max.z),
+        ),
+        Direction::East => Aabb::new(
+            Vec3::new(max.x + low, min.y, min.z),
+            Vec3::new(max.x + high, max.y, max.z),
+        ),
+        Direction::Down => Aabb::new(
+            Vec3::new(min.x, min.y + low, min.z),
+            Vec3::new(max.x, min.y + high, max.z),
+        ),
+        Direction::Up => Aabb::new(
+            Vec3::new(min.x, max.y + low, min.z),
+            Vec3::new(max.x, max.y + high, max.z),
+        ),
+        Direction::North => Aabb::new(
+            Vec3::new(min.x, min.y, min.z + low),
+            Vec3::new(max.x, max.y, min.z + high),
+        ),
+        Direction::South => Aabb::new(
+            Vec3::new(min.x, min.y, max.z + low),
+            Vec3::new(max.x, max.y, max.z + high),
+        ),
+    }
+}
+
+/// `PistonMovingBlockEntity.moveByPositionAndProgress`: a box moved to the
+/// block position and on to where the moved block currently is.
+pub fn move_by_position_and_progress(pos: BlockPos, aabb: Aabb, piston: MovingPistonState) -> Aabb {
+    let current = f64::from(extended_progress(piston, piston.progress));
+    let step = step_vector(piston.direction);
+    aabb.move_by(Vec3::new(
+        f64::from(pos.x) + current * step.x,
+        f64::from(pos.y) + current * step.y,
+        f64::from(pos.z) + current * step.z,
+    ))
+}
+
+/// `PistonMovingBlockEntity.getMovement`: how far `entity` stands inside the
+/// block it must be pushed out of, measured along `movement`'s axis.
+pub fn get_movement(block: Aabb, movement: Direction, entity: Aabb) -> f64 {
+    let (bmin, bmax) = (block.min_position(), block.max_position());
+    let (emin, emax) = (entity.min_position(), entity.max_position());
+    match movement {
+        Direction::East => bmax.x - emin.x,
+        Direction::West => emax.x - bmin.x,
+        Direction::Up => bmax.y - emin.y,
+        Direction::Down => emax.y - bmin.y,
+        Direction::South => bmax.z - emin.z,
+        Direction::North => emax.z - bmin.z,
+    }
+}
+
+/// `moveCollidedEntities`' inner loop: the furthest any of the moved block's
+/// boxes reaches into `entity`, capped at the progress delta, plus
+/// [`PUSH_OFFSET`]. `0.0` when the block does not touch the entity.
+pub fn collided_amount(
+    boxes: &[Aabb],
+    pos: BlockPos,
+    piston: MovingPistonState,
+    new_progress: f32,
+    movement: Direction,
+    entity: Aabb,
+) -> f64 {
+    let delta_progress = f64::from(new_progress - piston.progress);
+    let mut delta: f64 = 0.0;
+    for block in boxes {
+        let moving = movement_area(
+            move_by_position_and_progress(pos, *block, piston),
+            movement,
+            delta_progress,
+        );
+        if moving.intersects(entity) {
+            delta = delta.max(get_movement(moving, movement, entity));
+            if delta >= delta_progress {
+                break;
+            }
+        }
+    }
+    if delta <= 0.0 {
+        return 0.0;
+    }
+    delta.min(delta_progress) + PUSH_OFFSET
+}
+
+/// The box `level.getEntities` searches for a push: the moved block's own box
+/// widened by the slab it is about to sweep.
+pub fn movement_search_area(block_box: Aabb, movement: Direction, delta_progress: f64) -> Aabb {
+    movement_area(block_box, movement, delta_progress).union_bounds(block_box)
+}
+
+/// `moveStuckEntities`: the box of standing entities a moving honey block drags
+/// with it. `sticky_top` is the moved state's top collision height.
+pub fn sticky_area(pos: BlockPos, piston: MovingPistonState, sticky_top: f64) -> Aabb {
+    let area = Aabb::new(
+        Vec3::new(0.0, sticky_top, 0.0),
+        Vec3::new(1.0, 1.500_001_000_000_000_1, 1.0),
+    );
+    move_by_position_and_progress(pos, area, piston)
+}
+
+/// `PistonMovingBlockEntity.matchesStickyCritera`.
+pub fn matches_sticky_criteria(
+    area: Aabb,
+    reaction: PushReaction,
+    on_ground: bool,
+    supported_by_piston: bool,
+    entity_position: Vec3,
+) -> bool {
+    if reaction != PushReaction::PushPull || !on_ground {
+        return false;
+    }
+    if supported_by_piston {
+        return true;
+    }
+    let (min, max) = (area.min_position(), area.max_position());
+    entity_position.x >= min.x
+        && entity_position.x <= max.x
+        && entity_position.z >= min.z
+        && entity_position.z <= max.z
+}
+
+/// The level query intersects the sticky box before applying the predicate.
+pub fn sticky_entity_selected(
+    area: Aabb,
+    bounds: Aabb,
+    reaction: PushReaction,
+    on_ground: bool,
+    supported_by_piston: bool,
+    position: Vec3,
+) -> bool {
+    area.intersects(bounds)
+        && matches_sticky_criteria(area, reaction, on_ground, supported_by_piston, position)
+}
+
+/// `fixEntityWithinPistonBase`: a retracting source piston drags an entity that
+/// is still inside the piston's own block out along the opposite of `movement`.
+/// The returned distance is measured along that opposite direction.
+pub fn fix_within_piston_base(
+    pos: BlockPos,
+    entity: Aabb,
+    movement: Direction,
+    delta_progress: f64,
+) -> Option<f64> {
+    let block = Aabb::unit_cube(Vec3::from_block(pos));
+    if !entity.intersects(block) {
+        return None;
+    }
+    let opposite = movement.opposite();
+    let delta = get_movement(block, opposite, entity) + PUSH_OFFSET;
+    let intersected = entity.intersect(block);
+    let delta_intersected = get_movement(block, opposite, intersected) + PUSH_OFFSET;
+    // As deep inside as the block allows: it is stuck in the base itself, so it
+    // leaves along with the retraction.
+    if (delta - delta_intersected).abs() < PUSH_OFFSET {
+        Some(delta.min(delta_progress) + PUSH_OFFSET)
+    } else {
+        None
+    }
+}
+
+/// `PistonMovingBlockEntity.getCollisionRelatedBlockState` uses the moved state
+/// unless a source piston is retracting, where it shows a piston head instead.
+/// The state itself comes from [`PistonBlockBindings::collision_related_state`].
+///
+/// [`PistonBlockBindings::collision_related_state`]:
+///     crate::piston_shape::PistonBlockBindings::collision_related_state
+pub fn uses_moved_state(piston: MovingPistonState) -> bool {
+    piston.extending || !piston.source
+}
+
+/// `moveCollidedEntities`' slime bounce: a slime block sets the velocity along
+/// the movement axis to that direction's step, leaving the other axes.
+pub fn bounce_velocity(movement: Direction, velocity: Vec3) -> Vec3 {
+    let mut velocity = velocity;
+    match movement {
+        Direction::East => velocity.x = 1.0,
+        Direction::West => velocity.x = -1.0,
+        Direction::Up => velocity.y = 1.0,
+        Direction::Down => velocity.y = -1.0,
+        Direction::South => velocity.z = 1.0,
+        Direction::North => velocity.z = -1.0,
+    }
+    velocity
+}
+
+/// `Entity.getPistonPushReaction() == PushReaction.IGNORE_ENTITY`.
+///
+/// `Marker`, `Interaction`, `Display`, `AreaEffectCloud` and
+/// `OminousItemSpawner` return `IGNORE_ENTITY`, and an armor stand does when it
+/// is a marker. Horizon gives those kinds no pushed body, so a caller that has
+/// no box to push never reaches the maths above; this names the predicate for
+/// the kinds that do have one.
+pub fn ignores_push(marker: bool) -> bool {
+    marker
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn unit() -> Aabb {
+        Aabb::new(Vec3::new(0.0, 0.0, 0.0), Vec3::new(1.0, 1.0, 1.0))
+    }
+
+    fn moving(direction: Direction, extending: bool, progress: f32) -> MovingPistonState {
+        MovingPistonState {
+            moved_state: crate::registry::BlockStateId(0),
+            direction,
+            extending,
+            source: false,
+            progress,
+            previous_progress: progress,
+        }
+    }
+
+    /// `getMovementArea` puts the slab on the leading face and widens it by the
+    /// travel in that direction only.
+    #[test]
+    fn movement_area_sits_on_the_leading_face() {
+        let east = movement_area(unit(), Direction::East, 0.5);
+        assert_eq!(east.min_position(), Vec3::new(1.0, 0.0, 0.0));
+        assert_eq!(east.max_position(), Vec3::new(1.5, 1.0, 1.0));
+
+        let west = movement_area(unit(), Direction::West, 0.5);
+        assert_eq!(west.min_position(), Vec3::new(-0.5, 0.0, 0.0));
+        assert_eq!(west.max_position(), Vec3::new(0.0, 1.0, 1.0));
+
+        let up = movement_area(unit(), Direction::Up, 0.5);
+        assert_eq!(up.min_position(), Vec3::new(0.0, 1.0, 0.0));
+        assert_eq!(up.max_position(), Vec3::new(1.0, 1.5, 1.0));
+
+        let north = movement_area(unit(), Direction::North, 0.5);
+        assert_eq!(north.min_position(), Vec3::new(0.0, 0.0, -0.5));
+        assert_eq!(north.max_position(), Vec3::new(1.0, 1.0, 0.0));
+    }
+
+    /// A negative amount sweeps behind the leading face.
+    #[test]
+    fn movement_area_follows_a_negative_amount() {
+        let area = movement_area(unit(), Direction::East, -0.5);
+        assert_eq!(area.min_position(), Vec3::new(0.5, 0.0, 0.0));
+        assert_eq!(area.max_position(), Vec3::new(1.0, 1.0, 1.0));
+    }
+
+    /// The arm of a piston at the origin: the block entity sits in the block it
+    /// pushes into, and at progress 0 its shape is still a block back.
+    const ARM: BlockPos = BlockPos::new(1, 0, 0);
+
+    /// An entity in the way is pushed the progress delta, plus the push offset;
+    /// here it hangs 0.6 into the slab and the delta caps it at 0.5.
+    #[test]
+    fn a_collided_entity_moves_the_progress_delta() {
+        let piston = moving(Direction::East, true, 0.0);
+        let entity = Aabb::new(Vec3::new(0.9, 0.0, 0.2), Vec3::new(1.5, 1.8, 0.8));
+        let amount = collided_amount(&[unit()], ARM, piston, 0.5, Direction::East, entity);
+        assert!((amount - (0.5 + PUSH_OFFSET)).abs() < 1.0e-12, "{amount}");
+    }
+
+    /// The delta is not a floor: an entity barely nicking the slab moves by only
+    /// what it is owed, plus the offset.
+    #[test]
+    fn a_grazed_entity_moves_only_what_it_overlaps() {
+        let piston = moving(Direction::East, true, 0.0);
+        let entity = Aabb::new(Vec3::new(1.4, 0.0, 0.2), Vec3::new(2.0, 1.8, 0.8));
+        let amount = collided_amount(&[unit()], ARM, piston, 0.5, Direction::East, entity);
+        assert!((amount - (0.1 + PUSH_OFFSET)).abs() < 1.0e-12, "{amount}");
+    }
+
+    /// Clear of the block, nothing moves.
+    #[test]
+    fn an_entity_out_of_the_way_is_left_alone() {
+        let piston = moving(Direction::East, true, 0.0);
+        let entity = Aabb::new(Vec3::new(3.0, 0.0, 0.2), Vec3::new(3.6, 1.8, 0.8));
+        let amount = collided_amount(&[unit()], ARM, piston, 0.5, Direction::East, entity);
+        assert_eq!(amount, 0.0);
+    }
+
+    /// A retracting base drags an entity stuck inside its own block, limited by
+    /// the progress delta.
+    #[test]
+    fn a_retracting_base_drags_a_stuck_entity() {
+        let entity = Aabb::new(Vec3::new(0.75, 0.0, 0.2), Vec3::new(1.35, 1.8, 0.8));
+        let amount = fix_within_piston_base(BlockPos::new(0, 0, 0), entity, Direction::West, 0.5)
+            .expect("stuck in the base");
+        assert!(amount > 0.0 && amount <= 0.5 + PUSH_OFFSET, "{amount}");
+    }
+
+    /// An entity outside the base's block is not dragged by it.
+    #[test]
+    fn a_free_entity_is_not_dragged_by_the_base() {
+        let entity = Aabb::new(Vec3::new(2.0, 0.0, 0.2), Vec3::new(2.6, 1.8, 0.8));
+        assert_eq!(
+            fix_within_piston_base(BlockPos::new(0, 0, 0), entity, Direction::West, 0.5),
+            None
+        );
+    }
+
+    /// Honey drags only entities that stand on it and that blocks may push.
+    #[test]
+    fn honey_drags_standing_entities() {
+        let area = Aabb::new(Vec3::new(0.0, 0.0, 0.0), Vec3::new(1.0, 1.5, 1.0));
+        let on_top = Vec3::new(0.5, 0.0, 0.5);
+        assert!(matches_sticky_criteria(
+            area,
+            PushReaction::PushPull,
+            true,
+            false,
+            on_top
+        ));
+        assert!(!matches_sticky_criteria(
+            area,
+            PushReaction::PushPull,
+            false,
+            false,
+            on_top
+        ));
+        assert!(!matches_sticky_criteria(
+            area,
+            PushReaction::Immoveable,
+            true,
+            false,
+            on_top
+        ));
+        // Beside it: only standing on the piston's own block holds it.
+        let beside = Vec3::new(2.0, 0.0, 0.5);
+        assert!(!matches_sticky_criteria(
+            area,
+            PushReaction::PushPull,
+            true,
+            false,
+            beside
+        ));
+        assert!(matches_sticky_criteria(
+            area,
+            PushReaction::PushPull,
+            true,
+            true,
+            beside
+        ));
+    }
+
+    #[test]
+    fn honey_selection_uses_entity_position_and_intersection() {
+        let area = Aabb::new(Vec3::new(0.0, 1.0, 0.0), Vec3::new(1.0, 1.5, 1.0));
+        let position = Vec3::new(0.1, 1.0, 0.5);
+        let bounds = Aabb::new(Vec3::new(-0.2, 1.0, 0.2), Vec3::new(0.4, 2.8, 0.8));
+        assert!(sticky_entity_selected(
+            area,
+            bounds,
+            PushReaction::PushPull,
+            true,
+            false,
+            position
+        ));
+        let above = bounds.move_by(Vec3::new(0.0, 3.0, 0.0));
+        assert!(!sticky_entity_selected(
+            area,
+            above,
+            PushReaction::PushPull,
+            true,
+            true,
+            position
+        ));
+    }
+
+    /// The slime bounce rewrites only the movement axis.
+    #[test]
+    fn a_slime_block_bounces_along_its_axis() {
+        let v = Vec3::new(0.2, -0.5, 0.3);
+        assert_eq!(
+            bounce_velocity(Direction::East, v),
+            Vec3::new(1.0, -0.5, 0.3)
+        );
+        assert_eq!(bounce_velocity(Direction::Up, v), Vec3::new(0.2, 1.0, 0.3));
+        assert_eq!(
+            bounce_velocity(Direction::North, v),
+            Vec3::new(0.2, -0.5, -1.0)
+        );
+    }
+
+    /// The moved block sits along the piston's own direction, half a block short
+    /// at mid-travel and in place once landed.
+    #[test]
+    fn the_moved_block_sits_along_the_piston_direction() {
+        let half = moving(Direction::East, true, 0.5);
+        let moved = move_by_position_and_progress(BlockPos::new(2, 3, 4), unit(), half);
+        assert_eq!(moved.min_position(), Vec3::new(1.5, 3.0, 4.0));
+
+        let landed = moving(Direction::East, true, 1.0);
+        assert_eq!(
+            move_by_position_and_progress(BlockPos::new(2, 3, 4), unit(), landed).min_position(),
+            Vec3::new(2.0, 3.0, 4.0)
+        );
+
+        // Retracting runs the other way: two thirds out at progress 1/3.
+        let pulling = moving(Direction::East, false, 0.5);
+        assert_eq!(
+            move_by_position_and_progress(BlockPos::new(2, 3, 4), unit(), pulling).min_position(),
+            Vec3::new(2.5, 3.0, 4.0)
+        );
+    }
+
+    /// The search area covers the block and the slab in front of it.
+    #[test]
+    fn the_search_area_covers_block_and_sweep() {
+        let area = movement_search_area(unit(), Direction::East, 0.5);
+        assert_eq!(area.min_position(), Vec3::new(0.0, 0.0, 0.0));
+        assert_eq!(area.max_position(), Vec3::new(1.5, 1.0, 1.0));
+    }
+}
diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPistonPushOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPistonPushOracle.java
new file mode 100644
index 000000000..f1cee2fc2
--- /dev/null
+++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPistonPushOracle.java
@@ -0,0 +1,78 @@
+package dev.horizonlab.parity;
+import com.google.gson.*;
+import java.io.*;
+import java.lang.reflect.*;
+import java.nio.file.*;
+import java.util.*;
+import net.minecraft.core.*;
+import net.minecraft.world.entity.*;
+import net.minecraft.world.entity.monster.zombie.Zombie;
+import net.minecraft.world.level.block.*;
+import net.minecraft.world.level.block.piston.*;
+import net.minecraft.world.phys.*;
+import net.minecraft.world.phys.shapes.*;
+/**
+ * The real moving-piston push maths: PistonMath.getMovementArea,
+ * moveByPositionAndProgress, getMovement, the moveCollidedEntities loop over
+ * the block's own boxes, and moveStuckEntities' box and matchesStickyCritera.
+ * fixEntityWithinPistonBase is left out: it moves the entity
+ * (`Entity.move(MoverType.PISTON, ...)`), which needs a live level, so the
+ * Rust side is covered by its own unit tests.
+ */
+public final class VanillaPistonPushOracle {
+ private static float number(JsonElement v){return Float.intBitsToFloat(Integer.parseUnsignedInt(v.getAsString(),16));}
+ private static double dbl(JsonElement v){return Double.longBitsToDouble(Long.parseUnsignedLong(v.getAsString(),16));}
+ private static AABB box(JsonElement v){var a=v.getAsJsonArray();return new AABB(dbl(a.get(0)),dbl(a.get(1)),dbl(a.get(2)),dbl(a.get(3)),dbl(a.get(4)),dbl(a.get(5)));}
+ private static void line(PrintWriter out,String name,AABB b){out.printf(name+" %016x %016x %016x %016x %016x %016x%n",Double.doubleToLongBits(b.minX),Double.doubleToLongBits(b.minY),Double.doubleToLongBits(b.minZ),Double.doubleToLongBits(b.maxX),Double.doubleToLongBits(b.maxY),Double.doubleToLongBits(b.maxZ));}
+ private static Field field(Class<?> c,String name)throws Exception{var f=c.getDeclaredField(name);f.setAccessible(true);return f;}
+ private static Method method(Class<?> c,String name,Class<?>...types)throws Exception{var m=c.getDeclaredMethod(name,types);m.setAccessible(true);return m;}
+ @SuppressWarnings("unchecked") public static void main(String[] args)throws Exception {
+  net.minecraft.SharedConstants.tryDetectVersion();net.minecraft.server.Bootstrap.bootStrap();Path dir=Path.of(args[1]);
+  var allocator=Class.forName("sun.misc.Unsafe");var uf=allocator.getDeclaredField("theUnsafe");uf.setAccessible(true);var unsafe=uf.get(null);var allocate=allocator.getMethod("allocateInstance",Class.class);
+  var progress=field(PistonMovingBlockEntity.class,"progress");
+  var movedBy=method(PistonMovingBlockEntity.class,"moveByPositionAndProgress",BlockPos.class,AABB.class,PistonMovingBlockEntity.class);
+  var extended=method(PistonMovingBlockEntity.class,"getExtendedProgress",float.class);
+  var getMovement=method(PistonMovingBlockEntity.class,"getMovement",AABB.class,Direction.class,AABB.class);
+  var matches=method(PistonMovingBlockEntity.class,"matchesStickyCritera",AABB.class,Entity.class,BlockPos.class);
+  var movementDir=method(PistonMovingBlockEntity.class,"getMovementDirection");
+  var position=field(Entity.class,"position");var onGroundField=field(Entity.class,"onGround");var supporting=field(Entity.class,"mainSupportingBlockPos");var bbField=field(Entity.class,"bb");
+  var faces=new Direction[]{Direction.EAST,Direction.WEST,Direction.UP,Direction.DOWN,Direction.SOUTH,Direction.NORTH};
+  try(var out=new PrintWriter(Files.newBufferedWriter(dir.resolve(args[0]+".txt")));var inputs=Files.lines(dir.resolve("inputs.txt"))) {
+   for(var line:(Iterable<String>)inputs::iterator) {
+    var f=JsonParser.parseString(line).getAsJsonObject();var v=f.getAsJsonArray("pos");var p=new BlockPos(v.get(0).getAsInt(),v.get(1).getAsInt(),v.get(2).getAsInt());
+    var direction=Direction.values()[f.get("direction").getAsInt()];
+    var piston=new PistonMovingBlockEntity(p,Blocks.MOVING_PISTON.defaultBlockState(),Blocks.STONE.defaultBlockState(),direction,f.get("extending").getAsBoolean(),f.get("source").getAsBoolean());
+    float current=number(f.get("progress"));
+    progress.setFloat(piston,current);
+    float newProgress=number(f.get("new_progress"));
+    double deltaProgress=newProgress-current;
+    Direction movement=(Direction)movementDir.invoke(piston);
+    AABB blockBox=box(f.get("block_box"));
+    AABB entityBox=box(f.get("entity"));
+    AABB movementBox=box(f.get("movement_box"));
+    out.printf("extended %08x%n",Float.floatToIntBits((float)extended.invoke(piston,current)));
+    AABB origin=(AABB)movedBy.invoke(null,p,blockBox,piston);
+    line(out,"origin",origin);
+    line(out,"area",PistonMath.getMovementArea(blockBox,movement,deltaProgress));
+    for(var face:faces)out.printf("movement %s %016x%n",face.getSerializedName(),Double.doubleToLongBits((double)getMovement.invoke(null,movementBox,face,entityBox)));
+    double delta=0.0;boolean capped=false;
+    for(var value:f.getAsJsonArray("boxes")){
+     AABB movingAABB=PistonMath.getMovementArea((AABB)movedBy.invoke(null,p,box(value),piston),movement,deltaProgress);
+     if(movingAABB.intersects(entityBox)){delta=Math.max(delta,(double)getMovement.invoke(null,movingAABB,movement,entityBox));if(delta>=deltaProgress){capped=true;break;}}
+    }
+    double collided=delta<=0.0?0.0:Math.min(delta,deltaProgress)+0.01;
+    out.printf("collided %016x %b%n",Double.doubleToLongBits(collided),capped);
+    line(out,"search",PistonMath.getMovementArea(origin,movement,deltaProgress).minmax(origin));
+    AABB sticky=(AABB)movedBy.invoke(null,p,new AABB(0.0,dbl(f.get("sticky_top")),0.0,1.0,1.5000010000000001,1.0),piston);
+    line(out,"sticky",sticky);
+    boolean pushable=f.get("reaction").getAsInt()==0;
+    var entity=(Entity)allocate.invoke(unsafe,pushable?Zombie.class:Marker.class);
+    position.set(entity,new Vec3(dbl(f.get("entity_x")),0.0,dbl(f.get("entity_z"))));
+    bbField.set(entity,entityBox);
+    onGroundField.setBoolean(entity,f.get("on_ground").getAsBoolean());
+    supporting.set(entity,f.get("supported").getAsBoolean()?Optional.of(p):Optional.empty());
+    out.printf("matches %b%n",(boolean)matches.invoke(null,sticky,entity,p));
+   }
+  }
+ }
+}
\ No newline at end of file
diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index ab3fcde1b..4d35dd6ac 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -296,7 +296,7 @@ CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'si
           'arrows', 'kills', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles',
           'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing',
           'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push',
-          'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles',
+          'piston-push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles',
           'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects',
           'portals', 'distance', 'growth', 'doors', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'hands',
           'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption',
@@ -2368,6 +2368,59 @@ def wait_state(game, pos, key, want, ticks):
     return state_of(game, pos, key)
 
 
+def check_piston_push(host, guest, out):
+    """A moving piston pushes both players and a stationary mob on each host path."""
+    hx, _, hz = pos_of(host)
+    x, y, z = (int(hx // 16) * 16 + 8, 100, int(hz // 16) * 16 + 8)
+    host('command', command=f'fill {x-4} {y-1} {z-4} {x+7} {y-1} {z+4} minecraft:stone')
+    host('command', command=f'fill {x-4} {y} {z-4} {x+7} {y+5} {z+4} minecraft:air')
+    host('command', command=f'setblock {x} {y} {z} minecraft:piston[facing=east]')
+    results = {}
+    for player, name in ((host, host.player), (guest, GUEST_NAME)):
+        host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+        host.wait(10)
+        host('command', command=f'tp @s {x+5.5} {y} {z+2.5}')
+        host('command', command=f'tp {GUEST_NAME} {x+5.5} {y} {z-1.5}')
+        host('command', command=f'tp {"@s" if player is host else GUEST_NAME} {x+1.65} {y} {z+0.5}')
+        player.wait(15)
+        before = pos_of(player)
+        assert abs(before[0] - (x + 1.65)) < 0.1, f'{name} did not reach piston: {before}'
+        host('command', command=f'setblock {x-1} {y} {z} minecraft:redstone_block')
+        player.wait(30)
+        after = pos_of(player)
+        results[name] = after[0] - before[0]
+        assert results[name] > 0.3, f'piston did not push {name}: {before} -> {after}'
+    host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+    host.wait(10)
+    host('command', command=f'tp {GUEST_NAME} {x+5.5} {y} {z-1.5}')
+    host('command', command=f'tp @s {x+1.65} {y} {z+0.5}')
+    host.wait(10)
+    host.raw('key', 'e', 'tap')
+    host.raw('wait-for', 'screen', 'inventory')
+    before = pos_of(host)
+    guest('command', command=f'setblock {x-1} {y} {z} minecraft:redstone_block')
+    host.wait(30)
+    after = pos_of(host)
+    results['inventory'] = after[0] - before[0]
+    assert results['inventory'] > 0.3, f'piston did not push player with inventory open: {before} -> {after}'
+    host.raw('key', 'esc', 'tap')
+    host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+    host.wait(10)
+    host('command', command=f'tp @s {x+5.5} {y} {z+2.5}')
+    host('command', command=f'summon minecraft:pig {x+1.65} {y} {z+0.5} {{NoAI:1b}}')
+    host.wait(10)
+    pigs = host('entities', radius=16, type='pig')['entities']
+    pig = min(pigs, key=lambda p: abs(p['pos'][0] - (x + 1.65)) + abs(p['pos'][2] - (z + 0.5)))
+    before = pig['pos'][0]
+    host('command', command=f'setblock {x-1} {y} {z} minecraft:redstone_block')
+    host.wait(30)
+    pigs = host('entities', radius=16, type='pig')['entities']
+    after = next(p['pos'][0] for p in pigs if p['id'] == pig['id'])
+    results['pig'] = after - before
+    assert results['pig'] > 0.3, f'piston did not push pig: {before} -> {after}'
+    return results
+
+
 def check_plates(host, guest, out):
     guest('command', command='gamemode survival')
     x, y, z = (int(v // 1) for v in pos_of(guest))
@@ -4679,7 +4732,7 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour,
              'cartography': check_cartography, 'hurt': check_hurt, 'commands': check_commands,
              'recipes': check_recipes, 'trials': check_trials, 'walls': check_walls,
              'effects': check_effects, 'portals': check_portals, 'distance': check_distance,
-             'clicks': check_clicks, 'sleep': check_sleep, 'push': check_push,
+             'clicks': check_clicks, 'sleep': check_sleep, 'push': check_push, 'piston-push': check_piston_push,
              'eat': check_eat, 'eating': check_eating, 'xp': check_xp,
              'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast,
              'light': check_light, 'plates': check_plates, 'swings': check_swings,
diff --git a/tools/test_piston_push_parity.py b/tools/test_piston_push_parity.py
new file mode 100644
index 000000000..17f1a257d
--- /dev/null
+++ b/tools/test_piston_push_parity.py
@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""Compare moving-piston push geometry and predicates with pinned vanilla.
+
+`PistonMovingBlockEntity.moveCollidedEntities` decides how far an entity is
+pushed; the movement it describes is `Entity.move(MoverType.PISTON, ...)`, whose
+collision and per-tick limit the game owns. This harness covers the deciding
+half: the movement area, the offset block box, `getMovement` on every face, the
+per-box loop, `moveStuckEntities`' box and `matchesStickyCritera`, and
+`fixEntityWithinPistonBase`.
+"""
+import argparse
+import json
+import os
+from pathlib import Path
+import platform
+import random
+import struct
+import subprocess
+try:
+    from . import lab, test_rust_parity as base
+except ImportError:
+    import lab
+    import test_rust_parity as base
+
+
+def corpus():
+    def f32(v): return struct.pack('>f', float(v)).hex()
+    def f64(v): return struct.pack('>d', float(v)).hex()
+    def box(values): return [f64(v) for v in values]
+    step = [1.0 / 3.0, 0.25, 0.5, 0.75, 1.0]
+    unit = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0]
+    offsets = [[0, 0, 0], [-17, -64, 30000000], [2147483647, -2147483648, -2147483648]]
+    faces = [0, 1, 2, 3, 4, 5]
+    # Progress pairs around the 0.25/0.5/1.0 thresholds the head and the
+    # extended-progress offset change at.
+    progress = [0.0, 0.25, 0.49999997, 0.5, 0.75, 0.99999994, 1.0]
+    entities = [
+        [0.9, 0.0, 0.2, 1.5, 1.8, 0.8],
+        [1.4, 0.0, 0.2, 2.0, 1.8, 0.8],
+        [0.75, 0.0, 0.2, 1.35, 1.8, 0.8],
+        [3.0, 0.0, 0.2, 3.6, 1.8, 0.8],
+        [0.49, 0.0, 0.49, 0.51, 1.8, 0.51],
+        [0.0, 1.0, 0.0, 1.0, 2.8, 1.0],
+    ]
+    for index, position in enumerate(offsets):
+        for direction in faces:
+            for extending in (False, True):
+                for source in (False, True):
+                    for current in progress:
+                        advanced = min(current + 0.5, 1.0)
+                        for entity in entities:
+                            yield {
+                                'pos': position,
+                                'direction': direction,
+                                'extending': extending,
+                                'source': source,
+                                'progress': f32(current),
+                                'new_progress': f32(advanced),
+                                'block_box': box(unit),
+                                'movement_box': box(unit),
+                                'entity': box(entity),
+                                'boxes': [box(unit)],
+                                'sticky_top': f64(0.0),
+                                'reaction': 0,
+                                'on_ground': True,
+                                'supported': False,
+                                'entity_x': f64(entity[0]),
+                                'entity_z': f64(entity[2]),
+                            }
+    # Split boxes, a retracting honey drag with every push reaction, and the
+    # predicate's supported/on-ground corners.
+    for index in range(4000):
+        rng = random.Random(0x50555348 + index)
+        current = rng.choice(progress)
+        advanced = min(current + 0.5, 1.0)
+        count = rng.randint(1, 4)
+        boxes = []
+        for _ in range(count):
+            low = [rng.choice([0.0, 0.25, 0.5]), rng.choice([0.0, 0.5]), rng.choice([0.0, 0.5])]
+            high = [min(v + rng.choice([0.25, 0.5, 1.0]), 1.0) for v in low]
+            boxes.append(box(low + high))
+        yield {
+            'pos': rng.choice(offsets),
+            'direction': rng.randrange(6),
+            'extending': rng.random() < 0.5,
+            'source': rng.random() < 0.5,
+            'progress': f32(current),
+            'new_progress': f32(advanced),
+            'block_box': boxes[0],
+            'movement_box': boxes[rng.randrange(len(boxes))],
+            'entity': box([
+                rng.choice([0.0, 0.49, 0.75, 0.9, 1.4]),
+                rng.choice([0.0, 0.5]),
+                rng.choice([0.0, 0.2, 0.49]),
+                rng.choice([0.51, 1.35, 1.5, 2.0]),
+                rng.choice([1.8, 2.8]),
+                rng.choice([0.51, 0.8, 1.0]),
+            ]),
+            'boxes': boxes,
+            'sticky_top': f64(rng.choice([0.0, 0.5, 0.9375])),
+            'reaction': rng.randrange(5),
+            'on_ground': rng.random() < 0.5,
+            'supported': rng.random() < 0.5,
+            'entity_x': f64(rng.choice([0.0, 0.5, 1.0, 2.0])),
+            'entity_z': f64(rng.choice([0.0, 0.5, 1.0, 2.0])),
+        }
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--prepare', action='store_true')
+    args = parser.parse_args()
+    build = lab.LOCAL / 'rust-piston-push-parity'
+    build.mkdir(parents=True, exist_ok=True)
+    report_path = build / 'report.json'
+    report_path.unlink(missing_ok=True)
+    if args.prepare:
+        lab.prepare()
+    lock, jars, libraries = base.verify_artifacts()
+    oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPistonPushOracle.java'
+    helpers = [oracle.with_name(name + '.java')
+               for name in ['VanillaCollisionOracle', 'VanillaBlockStateCodecOracle', 'VanillaFaceSupportOracle']]
+    sources = [oracle, *helpers, Path(__file__), lab.ROOT / 'tools/test_rust_parity.py', lab.ROOT / 'tools/lab.py',
+               lab.ROOT / 'Cargo.toml', lab.ROOT / 'Cargo.lock',
+               lab.ROOT / 'crates/horizon-core/Cargo.toml', lab.ROOT / 'crates/horizon-world/Cargo.toml',
+               *sorted((lab.ROOT / 'crates/horizon-core/src').rglob('*.rs')),
+               *sorted((lab.ROOT / 'crates/horizon-world/src').rglob('*.rs')),
+               lab.ROOT / 'crates/horizon-world/examples/probe/piston_push_fixture.rs']
+    tested_sources = base.source_hashes(sources)
+    classes = build / 'classes'
+    classes.mkdir(exist_ok=True)
+
+    def run(command, name):
+        with (build / (name + '.log')).open('w', encoding='utf-8') as log:
+            base.run(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT)
+
+    dependency_path = os.pathsep.join(map(str, libraries))
+    run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none',
+         '-sourcepath', str(lab.ROOT / 'mods/horizon/src/test/java'),
+         '-cp', str(jars['server']) + os.pathsep + dependency_path,
+         '-d', classes, oracle, *helpers], 'compile-java')
+
+    def java(side, mode, path):
+        run(['java', '-Xmx512M', '-cp', os.pathsep.join([str(classes), str(jars[side]), dependency_path]),
+             'dev.horizonlab.parity.VanillaPistonPushOracle', mode, path], side + '-' + mode)
+
+    fixtures = list(corpus())
+    inputs = build / 'inputs.txt'
+    inputs.write_text(''.join(json.dumps(value, separators=(',', ':')) + '\n' for value in fixtures), encoding='utf-8')
+    fixture_paths = [inputs]
+    tested_fixtures = base.source_hashes(fixture_paths)
+    run(['cargo', 'build', '--release', '-p', 'horizon-world', '--example', 'world_probe'], 'compile-rust')
+    metadata = json.loads(subprocess.check_output(
+        ['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
+    binary = Path(metadata['target_directory']) / 'release/examples' / ('world_probe.exe' if os.name == 'nt' else 'world_probe')
+    run([binary, 'piston_push_fixture', build], 'rust')
+    references = []
+    for side, jar in jars.items():
+        java(side, side, build)
+        reference = build / f'{side}.txt'
+        matched = base.compare(reference, build / 'rust.txt')
+        references.append({'side': side, 'jar_sha256': lab.digest(jar, 'sha256'),
+                           'output_sha256': lab.digest(reference, 'sha256'), 'matched_output_lines': matched})
+        print(f'{side}: {matched:,} piston-push output lines match Rust', flush=True)
+    base.ensure_sources_unchanged(sources, tested_sources)
+    base.ensure_sources_unchanged(fixture_paths, tested_fixtures)
+    report = {
+        'schema': 1,
+        'minecraft': lock['minecraft']['version'],
+        'manifest_sha1': lock['minecraft']['manifest_sha1'],
+        'platform': platform.platform(),
+        'java': subprocess.check_output(['java', '--version'], text=True).splitlines()[0],
+        'rustc': subprocess.check_output(['rustc', '--version'], text=True).strip(),
+        'fixtures': len(fixtures),
+        'sources_sha256': tested_sources,
+        'fixtures_sha256': tested_fixtures,
+        'rust_output_sha256': lab.digest(build / 'rust.txt', 'sha256'),
+        'references': references,
+        'scope': 'Actual PistonMovingBlockEntity push geometry and predicates: getExtendedProgress, '
+                 'moveByPositionAndProgress, PistonMath.getMovementArea, getMovement on every face, the '
+                 'moveCollidedEntities loop over split shapes with its delta cap and PUSH_OFFSET, the '
+                 'getEntities search box, and moveStuckEntities\' box with matchesStickyCritera for every push '
+                 'reaction. fixEntityWithinPistonBase is covered by unit tests only: it calls '
+                 'Entity.move(MoverType.PISTON, ...) and so needs a live level. Entity selection order, that '
+                 'collision pass, the per-tick 0.51 limit, block behaviour of the moved state and full gameplay '
+                 'remain elsewhere.',
+    }
+    lab.write_json(report_path, report)
+    print(f'Scoped piston-push parity passed: {report_path}')
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

From 06b046d8fc3046bc83ad0ee1ba946e2e25676931 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:07:17 +0100
Subject: [PATCH 263/475] Light, scaffolding and shulker box outlines follow
 the held item and the lid

---
 crates/horizon-client/src/blocks.rs |  2 +-
 crates/horizon-client/src/game.rs   | 48 +++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/blocks.rs b/crates/horizon-client/src/blocks.rs
index 27a36396a..8e906e1bc 100644
--- a/crates/horizon-client/src/blocks.rs
+++ b/crates/horizon-client/src/blocks.rs
@@ -90,7 +90,7 @@ pub const MAP_COLORS: [u32; 62] = [
     14200723, 8365974,
 ];
 /// The 12 edges of the unit cube (outline data predating the export).
-fn cube_edges() -> Vec<[f64; 6]> {
+pub fn cube_edges() -> Vec<[f64; 6]> {
     let mut edges = Vec::new();
     for a in 0..3 {
         for (u, v) in [(0., 0.), (1., 0.), (0., 1.), (1., 1.)] {
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index f9edd98bb..20cd34e0c 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -1806,9 +1806,46 @@ impl Game<'_> {
     fn reach(&self) -> f64 {
         if self.creative { 5.0 } else { 4.5 }
     }
+    /// Outline shapes that depend on more than the block state, as one box
+    /// in block space: `LightBlock` and `ScaffoldingBlock.getShape` are a full
+    /// block while the main hand holds the block's own item
+    /// (`CollisionContext.isHoldingItem`), and `ShulkerBoxBlock.getShape`
+    /// grows with the lid (`ShulkerBoxBlockEntity.getBoundingBox`).
+    fn context_outline(&self, pos: [i32; 3], state: BlockStateId) -> Option<[f64; 6]> {
+        let name = &self.res.facts().get(state).name;
+        if matches!(&**name, "minecraft:light" | "minecraft:scaffolding") {
+            return self
+                .held()
+                .is_some_and(|s| *s.item == **name)
+                .then_some([0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);
+        }
+        if !name.ends_with("shulker_box") {
+            return None;
+        }
+        let progress = self.be_anims.shulkers.get(&pos).map_or(0.0, |s| s.progress);
+        let facing = self
+            .pack
+            .assets
+            .registry
+            .state(state)
+            .and_then(|s| s.properties.get("facing").cloned());
+        let d = facing_offset(facing.as_deref().unwrap_or("up"));
+        let mut b = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0];
+        for a in 0..3 {
+            match d[a] {
+                1 => b[a + 3] += 0.5 * f64::from(progress),
+                -1 => b[a] -= 0.5 * f64::from(progress),
+                _ => {}
+            }
+        }
+        Some(b)
+    }
     /// A block's outline boxes in world space (`getShape` plus the random offset).
     fn outline_boxes(&self, pos: [i32; 3]) -> Vec<[f64; 6]> {
         let state = self.world.block(pos[0], pos[1], pos[2]);
+        if let Some(b) = self.context_outline(pos, state) {
+            return vec![std::array::from_fn(|i| f64::from(pos[i % 3]) + b[i])];
+        }
         let f = self.res.facts().get(state);
         let o = if f.outline_offset {
             self.pack
@@ -10756,6 +10793,17 @@ impl Game<'_> {
                         [0.0; 3]
                     };
                     let p = h.pos.map(f64::from);
+                    if let Some(b) = self.context_outline(h.pos, state) {
+                        return horizon_client::blocks::cube_edges()
+                            .iter()
+                            .map(|e| {
+                                std::array::from_fn(|i| {
+                                    let k = i % 3;
+                                    p[k] + b[k] + e[i] * (b[k + 3] - b[k])
+                                })
+                            })
+                            .collect();
+                    }
                     f.outline_edges
                         .iter()
                         .map(|e| std::array::from_fn(|i| p[i % 3] + o[i % 3] + e[i]))

From 94748162bc6103baa74ce633b88b702bebfb5923 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:08:59 +0100
Subject: [PATCH 264/475] Handle a dig packet before the move queued behind it

The client breaks the block under its feet and falls in the same tick. The
hub checked that move against the block that was still there and sent the
player back. Moves queued behind a dig packet now wait for the next tick,
after the break.
---
 crates/horizon-client/src/lan/hub.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs
index b1a8cbc62..e2b36428a 100644
--- a/crates/horizon-client/src/lan/hub.rs
+++ b/crates/horizon-client/src/lan/hub.rs
@@ -2043,6 +2043,20 @@ impl Hub {
                 S::Chat(c) => self.handle_chat(i, c, events),
                 S::ChatAck(p) => self.chat_ack(i, p.offset, events),
                 S::ChatSessionUpdate(p) => self.chat_session_update(i, p, events),
+                // handlePlayerAction (a dig starting, stopping or finishing) is the
+                // game's, run after this pass. A move queued behind it is checked
+                // against the block the player just broke and falls through, so it
+                // would be sent back; it waits for the next tick, when the block is
+                // gone, as vanilla handles the two packets in order.
+                S::PlayerAction(p) if p.action <= 3 => {
+                    events.push(HostEvent::Packet(conn, Box::new(S::PlayerAction(p))));
+                    if matches!(
+                        self.guests[i].inbox.front(),
+                        Some(S::MovePlayerPos(_) | S::MovePlayerPosRot(_))
+                    ) {
+                        break;
+                    }
+                }
                 other => events.push(HostEvent::Packet(conn, Box::new(other))),
             }
         }

From 3755bb7d7763a38c5b81900abba45510212a28ae Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:10:41 +0100
Subject: [PATCH 265/475] parity: stop harnesses on SIGTERM, and reap orphaned
 harness JVMs

Nine vanilla Java servers from harness runs had been orphaned on the Mac mini for 2 to 5 days. Each harness runs in
its own session (killpg on a timeout), so when a CI job was cancelled, its harnesses and their servers outlived
parity.py.
- parity.py: SIGTERM and SIGHUP exit through the finally blocks, which now stop the local executor's harnesses
  too, not only the remote hosts'. The worker (--worker) stops its harnesses the same way.
- runner-gc.sh (every 6 h from launchd): stops Java processes whose parent is gone (launchd, init or
  systemd --user) and whose command line names a runner's checkout or a worktree's .local/, once ORPHAN_HOURS
  (default 3) old.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/release-flow.md  |  5 ++++-
 tools/ci/runner-gc.sh | 23 +++++++++++++++++++++++
 tools/parity.py       | 32 +++++++++++++++++++++++++-------
 3 files changed, 52 insertions(+), 8 deletions(-)

diff --git a/docs/release-flow.md b/docs/release-flow.md
index b0d435c29..7d33b5585 100644
--- a/docs/release-flow.md
+++ b/docs/release-flow.md
@@ -420,6 +420,9 @@ Releases ship often, so nothing they leave behind may grow without bound.
   (`~/.actions-runners/runner-gc.sh`, plist `dev.horizon.runner-gc`), never from a pull request's checkout. It skips a
   runner in a job, removes a checkout's cargo build folders past 12 GB (`MAX_TARGET_GB`) and harness work folders
   under `.local/` untouched for 3 days (`STALE_DAYS`), and keeps the 2 newest shared preparations (`KEEP_PREPARED`)
-  while no runner works. Runner builds go through the machine's sccache (`tools/ci/runner-env.sh`), so what it removes
+  while no runner works. It also stops harness JVMs (vanilla servers, oracles) left orphaned for 3 hours
+  (`ORPHAN_HOURS`): parent gone, command line under a runner's checkout or a worktree's `.local/`. `tools/parity.py`
+  stops its own harnesses on SIGTERM and SIGHUP (a cancelled job), so these come only from a SIGKILL or a harness run
+  by hand. Runner builds go through the machine's sccache (`tools/ci/runner-env.sh`), so what it removes
   comes back from the cache. Update the copy after changing the script:
   `ssh macmini 'curl -fsSL https://raw.githubusercontent.com/ludovic111/horizon/main/tools/ci/runner-gc.sh -o ~/.actions-runners/runner-gc.sh'`.
diff --git a/tools/ci/runner-gc.sh b/tools/ci/runner-gc.sh
index 0f4f1e4c2..7ccf69ff0 100755
--- a/tools/ci/runner-gc.sh
+++ b/tools/ci/runner-gc.sh
@@ -9,6 +9,10 @@
 #     the shared vanilla data) that nothing touched for STALE_DAYS go; a harness that runs again rebuilds its own.
 #     .local/parity-runner (run state, oracle cache) stays.
 #   - The shared prepared resources keep their KEEP_PREPARED newest preparations, only while no runner works.
+#   - Java processes harnesses left behind (vanilla servers, oracles) go once ORPHAN_HOURS old: those whose parent
+#     is gone (adopted by launchd, init or systemd --user) and whose command line names a runner's checkout or a
+#     worktree's .local/. A job cancelled while it ran left such servers for days (2026-10-26); tools/parity.py now
+#     stops its harnesses on SIGTERM, and this catches what it can't (SIGKILL, a harness run by hand).
 set -euo pipefail
 root=${RUNNERS:-$HOME/.actions-runners}
 max_kb=$(( ${MAX_TARGET_GB:-12} * 1024 * 1024 ))
@@ -42,6 +46,25 @@ for runner in "$root"/horizon "$root"/horizon-[0-9]*; do
   fi
 done
 
+# [[dd-]hh:]mm:ss, as ps prints a process's age, in minutes.
+minutes() {
+  local t=$1 d=0 h=0 m a b c
+  if [[ $t == *-* ]]; then d=${t%%-*}; t=${t#*-}; fi
+  IFS=: read -r a b c <<< "$t"
+  if [ -n "$c" ]; then h=$a m=$b; else m=$a; fi
+  echo $(( 10#$d * 1440 + 10#$h * 60 + 10#$m ))
+}
+orphan_min=$(( ${ORPHAN_HOURS:-3} * 60 ))
+ps -A -o pid=,ppid=,etime=,command= | while read -r pid ppid etime command; do
+  case "$command" in *java*) ;; *) continue ;; esac
+  case "$command" in *"$root"/*/_work/*|*/.claude/worktrees/*/.local/*|*/code/horizon/.local/*) ;; *) continue ;; esac
+  [ "$(minutes "$etime")" -ge "$orphan_min" ] || continue
+  if [ "$ppid" != 1 ]; then
+    case "$(ps -o command= -p "$ppid" 2>/dev/null)" in *"systemd --user"*) ;; *) continue ;; esac
+  fi
+  if kill "$pid" 2>/dev/null; then echo "orphaned java $pid ($etime old) stopped: ${command:0:160}"; fi
+done
+
 prepared="$root/horizon/_work/horizon/shared-local/prepared"
 if [ "$any_busy" = 0 ] && [ -d "$prepared" ] && mkdir "$prepared/.lock" 2>/dev/null; then
   trap 'rmdir "$prepared/.lock" 2>/dev/null || true' EXIT
diff --git a/tools/parity.py b/tools/parity.py
index a5f7f2db1..426c843ca 100644
--- a/tools/parity.py
+++ b/tools/parity.py
@@ -48,6 +48,7 @@ import os
 from pathlib import Path, PurePosixPath
 import re
 import shutil
+import signal
 import socket
 import subprocess
 import sys
@@ -1134,6 +1135,14 @@ def run(selected, state, hasher, environment_digest, executors, reuse_oracles, r
     return results, time.monotonic() - started_all
 
 
+def exit_on_termination():
+    """SIGTERM and SIGHUP (a cancelled CI job, a dropped ssh) end this process through its finally blocks, which stop
+    the running harnesses. Each runs in its own session, so without that they, and the vanilla servers they started,
+    outlive it (orphans of days were found on the Mac mini's runners, 2026-10-26)."""
+    for number in (signal.SIGTERM, signal.SIGHUP):
+        signal.signal(number, lambda received, _frame: sys.exit(128 + received))
+
+
 def worker_main(shared_local):
     """`parity.py --worker SHARED_LOCAL`: run harnesses sent as JSON lines on stdin, answer on stdout."""
     import queue as queues
@@ -1169,13 +1178,20 @@ def worker_main(shared_local):
     built, errors = prebuild(first["prebuild"], default_build_jobs()) if first["prebuild"] else (True, "")
     executor = LocalExecutor(MACHINE_JOBS, int(memory_available() * 0.75), first["timeout"])
     send({"hello": {"jobs": MACHINE_JOBS, "memory": executor.memory_budget, "built": built, "errors": errors[-4000:]}})
+    try:
+        return serve(executor, inbox, queues.Empty, send, state, hasher)
+    finally:
+        executor.stop()
+
+
+def serve(executor, inbox, empty, send, state, hasher):
+    """The worker's loop: start what the coordinating runner sends, report what finished, until its stdin ends."""
     while True:
         try:
             message = inbox.get(timeout=0.2)
-        except queues.Empty:
+        except empty:
             message = False
         if message is None:
-            executor.stop()
             save_state(state)
             return 0
         if message:
@@ -1384,6 +1400,7 @@ def finished_run(failed):
 def main():
     if len(sys.argv) > 1 and sys.argv[1] == "--trace":
         return trace_main(sys.argv[2], sys.argv[3], sys.argv[4:])
+    exit_on_termination()
     if len(sys.argv) > 1 and sys.argv[1] == "--worker":
         return worker_main(sys.argv[2])
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
@@ -1509,6 +1526,7 @@ def main():
         jobs = 1  # harnesses that can only run here still need a slot
     remotes = [RemoteExecutor(host, config["hosts"][host], artifacts, config.get("local_only", {}), args.timeout)
                for host in hosts]
+    local = None
     try:
         if jobs:
             print("Building probes...", flush=True)
@@ -1521,12 +1539,12 @@ def main():
         where = "".join(f", plus {host}" for host in hosts)
         print(f"Running {len(selected)} harnesses, {jobs} at a time here{where}...", flush=True)
         reuse_oracles = not (args.fresh or args.all)
-        executors = [*remotes, LocalExecutor(jobs, int(memory_available() * 0.75), args.timeout,
-                                             REMOTE_LOCAL_PEAK if remotes and args.jobs is None else None)]
-        results, elapsed = run(selected, state, hasher, environment_key(hasher), executors, reuse_oracles, rounds,
-                               known_flaky(config))
+        local = LocalExecutor(jobs, int(memory_available() * 0.75), args.timeout,
+                              REMOTE_LOCAL_PEAK if remotes and args.jobs is None else None)
+        results, elapsed = run(selected, state, hasher, environment_key(hasher), [*remotes, local], reuse_oracles,
+                               rounds, known_flaky(config))
     finally:
-        for executor in remotes:
+        for executor in [*remotes, *([local] if local else [])]:
             executor.stop()
     save_state(state)
     failed = sorted(name for name, record in results.items() if record["status"] != "pass")

From 69bb81312816fc283a3c74c02c365e7391ef6608 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:16:34 +0100
Subject: [PATCH 266/475] game: cut a recipe page's title with an ellipsis

A title wider than the panel ended at its edge mid-word ("Recipes: Oak P");
it now ends with vanilla's "..." (CommonComponents.ELLIPSIS).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/mod_browser_recipes.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/mod_browser_recipes.rs b/crates/horizon-client/src/game/mod_browser_recipes.rs
index 13b3b78e1..557ae9029 100644
--- a/crates/horizon-client/src/game/mod_browser_recipes.rs
+++ b/crates/horizon-client/src/game/mod_browser_recipes.rs
@@ -272,8 +272,14 @@ impl Game<'_> {
         batch.text(atlas, &label, back[0] + 4.0, back[1] + 3.0, u32::MAX, true);
         horizon_client::widgets::record(&label, back, true);
         let room = layout.width() - back[2] - 4.0;
-        let fit = atlas.font.fit(&title, room);
-        let shown: String = title.chars().take(fit).collect();
+        // Cut to the panel with vanilla's ellipsis (CommonComponents.ELLIPSIS).
+        let shown = if atlas.font.fit(&title, room) >= title.chars().count() {
+            title
+        } else {
+            let fit = atlas.font.fit(&title, room - atlas.font.width("..."));
+            let kept: String = title.chars().take(fit).collect();
+            format!("{}...", kept.trim_end())
+        };
         batch.text(
             atlas,
             &shown,

From 67c27701e97559473e133ffe5bcaee4836c0cdb2 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:16:43 +0100
Subject: [PATCH 267/475] Server: new players join around the spawn, not all on
 one spot

The server put every player new to the world exactly on the world spawn.
On the server thread the host's own player joins that way too, so the host
and each new guest stood inside each other: the guest's client targets
the host's player (its eye inside that box, as vanilla's getEntityHitResult
does), so it could open no crafting table, chest or furnace, and Entity.push
never parts two players with the same centre. A dedicated server stacked
its new players the same way.

Vanilla places each new player with ServerPlayer.adjustSpawnLocation:
PlayerSpawnFinder.findSpawn, a free column at a random offset within the
respawn radius. Game::server_player_spawn does it for a server's new
players with the window's own finder, passing over the candidates whose
chunk isn't loaded yet (vanilla waits for them; a server tick can't).

lan_e2e's new check `spawned` asserts that the host and the guest join on
different spots, then has the guest open a crafting table, a chest, a
furnace and a stonecutter where it joined.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../horizon-client/src/game/initial_spawn.rs  | 75 +++++++++++++------
 crates/horizon-client/src/game/lan.rs         | 13 +++-
 tools/lan_e2e.py                              | 40 +++++++++-
 3 files changed, 103 insertions(+), 25 deletions(-)

diff --git a/crates/horizon-client/src/game/initial_spawn.rs b/crates/horizon-client/src/game/initial_spawn.rs
index 3f7a071bb..7ddb9cb90 100644
--- a/crates/horizon-client/src/game/initial_spawn.rs
+++ b/crates/horizon-client/src/game/initial_spawn.rs
@@ -126,28 +126,7 @@ impl Game<'_> {
     pub(super) fn find_player_spawn(&mut self, suggestion: [i32; 3]) -> Result<Option<Vec3>> {
         let mut finder = match self.player_spawn {
             Some(finder) => finder,
-            None if self.level.game_mode == 2 => {
-                // Adventure mode: the suggestion itself.
-                let mut finder = PlayerSpawnFinder::new(suggestion, 0, |_| 0);
-                finder.next_candidate();
-                finder
-            }
-            None => {
-                let mut radius = self.ui.rules.int("respawn_radius").max(0);
-                let to_border = self
-                    .border
-                    .distance(f64::from(suggestion[0]), f64::from(suggestion[2]))
-                    .floor() as i32;
-                if to_border < radius {
-                    radius = to_border;
-                }
-                if to_border <= 1 {
-                    radius = 1;
-                }
-                PlayerSpawnFinder::new(suggestion, radius, |n| {
-                    entity_random().next_int_bound(n).unwrap_or(0)
-                })
-            }
+            None => self.spawn_finder(suggestion),
         };
         let found = loop {
             let Some(candidate) = finder.next_candidate() else {
@@ -176,6 +155,58 @@ impl Game<'_> {
         self.player_spawn = found.is_none().then_some(finder);
         Ok(found)
     }
+    /// A new PlayerSpawnFinder around `suggestion`: the respawn radius, cut
+    /// by the world border; the suggestion itself in adventure mode.
+    fn spawn_finder(&self, suggestion: [i32; 3]) -> PlayerSpawnFinder {
+        if self.level.game_mode == 2 {
+            let mut finder = PlayerSpawnFinder::new(suggestion, 0, |_| 0);
+            finder.next_candidate();
+            return finder;
+        }
+        let mut radius = self.ui.rules.int("respawn_radius").max(0);
+        let to_border = self
+            .border
+            .distance(f64::from(suggestion[0]), f64::from(suggestion[2]))
+            .floor() as i32;
+        if to_border < radius {
+            radius = to_border;
+        }
+        if to_border <= 1 {
+            radius = 1;
+        }
+        PlayerSpawnFinder::new(suggestion, radius, |n| {
+            entity_random().next_int_bound(n).unwrap_or(0)
+        })
+    }
+    /// ServerPlayer.adjustSpawnLocation for a server's new player: where
+    /// PlayerSpawnFinder.findSpawn puts their feet around the world spawn
+    /// (`spawn`, the feet there), so that players new to a world don't all
+    /// stand in one spot. Vanilla waits for each candidate's chunk; a server
+    /// tick can't, so a candidate in a chunk not loaded yet is passed over,
+    /// and `spawn` stays when the search never reaches a loaded column.
+    pub(super) fn server_player_spawn(&self, spawn: [f64; 3]) -> [f64; 3] {
+        let suggestion = spawn.map(|v| v.floor() as i32);
+        let mut finder = self.spawn_finder(suggestion);
+        while let Some(candidate) = finder.next_candidate() {
+            let (x, z) = match candidate {
+                SpawnCandidate::Column(x, z) => (x, z),
+                SpawnCandidate::Suggestion => (suggestion[0], suggestion[2]),
+            };
+            if !self.streaming.is_lit(x >> 4, z >> 4) {
+                continue;
+            }
+            let feet = match candidate {
+                SpawnCandidate::Column(x, z) => level_respawn_pos(&self.spawn_columns(), x, z)
+                    .filter(|&pos| self.player_fits(pos))
+                    .map(bottom_center),
+                SpawnCandidate::Suggestion => Some(self.fixup_spawn_height(suggestion)),
+            };
+            if let Some(feet) = feet {
+                return [feet.x, feet.y, feet.z];
+            }
+        }
+        spawn
+    }
     /// PlayerSpawnFinder.noCollisionNoLiquid: a player's box standing at the
     /// block's bottom centre touches no block or liquid.
     fn player_fits(&self, pos: [i32; 3]) -> bool {
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..ce65c52bc 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -1128,8 +1128,17 @@ impl Game<'_> {
             g.game_mode = default_mode;
         }
         if !known {
-            g.position = spawn;
-            g.previous_position = spawn;
+            // ServerPlayer.adjustSpawnLocation: a player new to the world
+            // stands where PlayerSpawnFinder puts them, not all on one spot
+            // (it reads the loaded level, which holds the spawn when it is
+            // the overworld).
+            let feet = if self.dim == super::Dim::Overworld {
+                self.server_player_spawn(spawn)
+            } else {
+                spawn
+            };
+            g.position = feet;
+            g.previous_position = feet;
             g.health = 20.0;
             g.food = 20;
             g.dimension = super::Dim::Overworld.id().to_owned();
diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index ab3fcde1b..012e8f021 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -14,6 +14,8 @@ address. The script then checks, from both sides, what a guest's game used to ge
              closes on both when the guest closes it; the host keeps playing with its mouse look (#687);
 - crafting:  the guest crafts planks in the inventory's 2x2 grid and opens a crafting table, which
              leaves the host's screen and mouse look alone;
+- spawned:   the host and a guest new to the world join on different spots (PlayerSpawnFinder), and the
+             guest opens a crafting table, a chest, a furnace and a stonecutter where it joined;
 - sign:      a sign the guest places doesn't open a sign editor on the host;
 - damage:    a guest in survival takes fall damage;
 - mobs:      with the host in creative, a zombie and a skeleton go for the guest and hurt them;
@@ -292,7 +294,7 @@ ROOT = Path(__file__).resolve().parents[1]
 GUEST_NAME = 'Guest'
 # Match normal single player; --in-frame is the comparison path.
 SERVER_THREAD = True
-CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp',
+CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'spawned', 'sign', 'damage', 'mobs', 'hazards', 'pvp',
           'arrows', 'kills', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles',
           'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing',
           'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push',
@@ -554,6 +556,39 @@ def check_crafting(host, guest, out):
     return {'planks': planks, 'table': counts}
 
 
+def check_spawned(host, guest, out):
+    """Players new to a world don't share one spot: ServerPlayer.adjustSpawnLocation spreads them over the
+    respawn radius (PlayerSpawnFinder). Two players standing in each other target each other, so a guest
+    left in the host could open nothing it clicked. At its own spot, the guest opens a crafting table, a
+    chest, a furnace and a stonecutter."""
+    joined = {'host': [round(v, 2) for v in host.joined_at], 'guest': [round(v, 2) for v in guest.joined_at]}
+    apart = abs(joined['host'][0] - joined['guest'][0]) + abs(joined['host'][2] - joined['guest'][2]) >= 0.6
+    guest('command', command='gamemode survival')
+    for game in (host, guest):
+        x, y, z = game.joined_at
+        game('command', command=f'tp @s {x} {y} {z}')
+    guest.wait(20)
+    x, y, z = (int(v // 1) for v in pos_of(guest))
+    at = (x, y, z + 2)
+    grab(host)
+    opened = {}
+    for block in ('crafting_table', 'chest', 'furnace', 'stonecutter'):
+        guest('command', command=f'setblock {at[0]} {at[1]} {at[2]} minecraft:{block}')
+        guest.wait(10)
+        guest.raw('interact', *at)
+        guest.wait(10)
+        opened[block] = guest('state').get('screen')
+        guest.shot(out, f'spawned-{block}')
+        back_to_game(guest)
+        guest('command', command=f'setblock {at[0]} {at[1]} {at[2]} minecraft:air')
+    host_unaffected(host, "the guest's stations")
+    face_each_other(host, guest)
+    assert apart, f'the host and the guest joined on one spot: {joined}'
+    want = {'crafting_table': 'inventory', 'chest': 'container', 'furnace': 'container', 'stonecutter': 'station'}
+    assert opened == want, f'where it joined, the guest opened {opened}'
+    return {'joined': joined, 'opened': opened}
+
+
 def check_sign(host, guest, out):
     x, y, z = (int(v // 1) for v in pos_of(guest))
     spot = (x + 2, y, z)
@@ -4669,6 +4704,7 @@ def check_worn(host, guest, out):
 
 CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour,
              'nametags': check_nametags, 'chest': check_chest, 'crafting': check_crafting,
+             'spawned': check_spawned,
              'sign': check_sign, 'damage': check_damage, 'mobs': check_mobs,
              'hazards': check_hazards, 'pvp': check_pvp, 'respawn': check_respawn,
              'containers': check_containers, 'feedback': check_feedback, 'titles': check_titles,
@@ -4727,6 +4763,8 @@ def run(ctl, out, resources, checks):
         guest.raw('connect', f'127.0.0.1:{port}', GUEST_NAME)
         guest.raw('wait-for', 'loaded', '--timeout', 300)
         guest.wait(40)
+        # Where each joined, before anything moves them (check_spawned).
+        host.joined_at, guest.joined_at = pos_of(host), pos_of(guest)
         face_each_other(host, guest)
         host.shot(out, 'joined')
         guest.shot(out, 'joined')

From 3fe301aaa1e610c095e26cb61882140b6419af89 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:17:18 +0100
Subject: [PATCH 268/475] Record the dragon's attacker before the crystal blast
 and only for applied damage

---
 crates/horizon-client/src/game/dragon.rs | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index b2f04d77c..f97070da7 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -48,6 +48,9 @@ pub(super) struct Fight {
     respawn: Option<(Respawn, i32)>,
     /// The four crystals on the exit portal driving the respawn.
     respawn_crystals: Vec<Vec3>,
+    /// The player behind the crystal blast under way, whose `explosion`
+    /// damage source names them (`EndCrystal.hurtServer`).
+    blast_by: Option<FightWho>,
     dirty: bool,
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -899,8 +902,12 @@ impl Game<'_> {
                 .any(|p| p.distance_squared(c.position) < 0.01);
         if damage == CrystalDamage::Direct {
             let at = [c.position.x, c.position.y, c.position.z];
+            // The blast's damage source carries the player, so the dragon
+            // remembers them before the blast can kill it.
+            self.fight.blast_by = by;
             let _ =
                 self.server_explode(at, 6.0, super::explosion::BlockInteraction::Destroy, false);
+            self.fight.blast_by = None;
         }
         if respawn_crystal {
             self.abort_respawn();
@@ -1003,10 +1010,13 @@ impl Game<'_> {
             return Hurt::Refused;
         };
         let was_down = d.down();
+        let (cooldown, last_hurt) = (d.invulnerable, d.last_hurt);
         let hurt = d.hurt(part, damage, counts, arrow);
-        // LivingEntity.hurtServer: a player's hit sets lastHurtByPlayer (100 ticks).
+        // LivingEntity.hurtServer: damage that is applied sets lastHurtByPlayer
+        // (100 ticks); a hit the damage cooldown absorbs returns before that.
         if counts
             && matches!(hurt, Hurt::Landed { .. })
+            && (d.invulnerable != cooldown || d.last_hurt != last_hurt)
             && let Some(who) = by
         {
             d.hurt_by_player = Some((who, d.ticks));
@@ -2787,8 +2797,9 @@ impl Game<'_> {
             let (lo, hi) = (b.min_position(), b.max_position());
             self.seen_percent(center, [lo.x, lo.y, lo.z], [hi.x, hi.y, hi.z])
         });
+        let by = self.fight.blast_by;
         for (part, amount) in hits {
-            self.hurt_dragon(part, amount, true, None, false);
+            self.hurt_dragon(part, amount, true, by, false);
         }
     }
 }

From cdafcd756f1c436a9a41cceaa7fee118982bbe11 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:18:05 +0100
Subject: [PATCH 269/475] Open links and page links in written books

---
 crates/horizon-client/src/component.rs  |   7 ++
 crates/horizon-client/src/game/books.rs | 104 +++++++++++++++++++-----
 crates/horizon-client/src/game/chat.rs  |   5 +-
 crates/horizon-client/src/item_data.rs  |  23 ++++--
 crates/horizon-client/src/lan/guest.rs  |  13 +--
 crates/horizon-client/src/text.rs       |   3 +
 6 files changed, 123 insertions(+), 32 deletions(-)

diff --git a/crates/horizon-client/src/component.rs b/crates/horizon-client/src/component.rs
index 0f0adef57..cfb15bf0d 100644
--- a/crates/horizon-client/src/component.rs
+++ b/crates/horizon-client/src/component.rs
@@ -177,6 +177,13 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
             Some("open_url") => text("url")
                 .filter(|u| u.starts_with("http://") || u.starts_with("https://"))
                 .map(crate::text::ClickEvent::OpenUrl),
+            // ClickEvent.ChangePage.CODEC: ExtraCodecs.POSITIVE_INT.
+            Some("change_page") => e
+                .get("page")
+                .and_then(Value::as_i64)
+                .and_then(|p| i32::try_from(p).ok())
+                .filter(|p| *p >= 1)
+                .map(crate::text::ClickEvent::ChangePage),
             Some("suggest_command") => text("command").map(crate::text::ClickEvent::SuggestCommand),
             Some("copy_to_clipboard") => {
                 text("value").map(crate::text::ClickEvent::CopyToClipboard)
diff --git a/crates/horizon-client/src/game/books.rs b/crates/horizon-client/src/game/books.rs
index 2f38dffd9..610b52265 100644
--- a/crates/horizon-client/src/game/books.rs
+++ b/crates/horizon-client/src/game/books.rs
@@ -8,7 +8,7 @@ use horizon_client::{
     containers::{BlockEntity, Lectern},
     first_person::Hand,
     hud::{HudBatch, rgba},
-    item_data::WrittenBook,
+    item_data::{StackData, WrittenBook},
     items::ItemStack,
     menu::{Kind, Menu},
     text::Text,
@@ -59,14 +59,86 @@ pub(super) enum BookScreen {
         page_edit: ui::EditBox,
     },
     View {
-        pages: Vec<String>,
+        pages: Vec<Text>,
         page: usize,
         lectern: Option<(i32, i32, i32)>,
     },
 }
+/// The pages a book screen reads: a written book's components (so their
+/// click events stay), else a writable book's text.
+fn view_pages(data: Option<&StackData>) -> Vec<Text> {
+    let Some(data) = data else { return Vec::new() };
+    let Some(w) = &data.written else {
+        return data.writable_pages.iter().map(Text::literal).collect();
+    };
+    let tagged = w.page_tags.len() == w.pages.len();
+    w.pages
+        .iter()
+        .enumerate()
+        .map(|(i, page)| match tagged.then(|| &w.page_tags[i]) {
+            Some(tag @ horizon_world::nbt::Tag::Compound(_)) => {
+                horizon_client::entity_nbt::name_text(tag)
+            }
+            _ => Text::literal(page),
+        })
+        .collect()
+}
 impl Game<'_> {
     fn book_lines(&self, page: &str) -> Vec<Text> {
-        self.gui.atlas.font.split(&Text::literal(page), 114.0)
+        self.page_lines(&Text::literal(page))
+    }
+    fn page_lines(&self, page: &Text) -> Vec<Text> {
+        self.gui.atlas.font.split(page, 114.0)
+    }
+    /// `BookViewScreen.mouseClicked`: the click event of the text under the
+    /// cursor on the page.
+    fn book_link_at(&self, page: &Text, left: f32) -> Option<horizon_client::text::ClickEvent> {
+        let (mx, my) = self.cursor;
+        let row = ((my - 32.0) / 9.0).floor();
+        if row < 0.0 || row >= LINES as f32 {
+            return None;
+        }
+        let lines = self.page_lines(page);
+        let line = lines.get(row as usize)?.resolve_legacy();
+        let mut x = mx - (left + 36.0);
+        if x < 0.0 {
+            return None;
+        }
+        for (c, style) in line.chars() {
+            x -= self.gui.atlas.font.advance(c, style);
+            if x < 0.0 {
+                return style.click.clone();
+            }
+        }
+        None
+    }
+    /// `BookViewScreen.handleClickEvent`: a page link turns to its page
+    /// (`forcePage`), a web link goes through the confirm-link flow.
+    fn book_follow_link(
+        &mut self,
+        link: horizon_client::text::ClickEvent,
+        count: usize,
+        lectern: Option<(i32, i32, i32)>,
+    ) {
+        use horizon_client::text::ClickEvent;
+        match link {
+            ClickEvent::ChangePage(target) => {
+                let target = (target - 1).clamp(0, count.saturating_sub(1) as i32);
+                let Some(BookScreen::View { page, .. }) = self.book.as_mut() else {
+                    return;
+                };
+                if let Some(key) = lectern {
+                    // LecternScreen.forcePage: the menu's button 100 + page.
+                    if target != *page as i32 {
+                        self.lectern_button(key, 100 + target);
+                    }
+                } else if target != *page as i32 {
+                    *page = target as usize;
+                }
+            }
+            ClickEvent::OpenUrl(url) => self.click_url(url),
+            _ => {}
+        }
     }
     /// `WritableBookItem.use` / `WrittenBookItem.use` (`Player.openItemGui`).
     /// A server's player writes in its own client's editor
@@ -115,11 +187,7 @@ impl Game<'_> {
                 }
             }
             "minecraft:written_book" => BookScreen::View {
-                pages: stack
-                    .data()
-                    .and_then(|d| d.written.as_ref())
-                    .map(|w| w.pages.clone())
-                    .unwrap_or_default(),
+                pages: view_pages(stack.data()),
                 page: 0,
                 lectern: None,
             },
@@ -215,6 +283,7 @@ impl Game<'_> {
                 author,
                 generation: 0,
                 pages,
+                page_tags: Vec::new(),
             });
             *stack = written;
         } else {
@@ -685,11 +754,7 @@ impl Game<'_> {
             return false;
         };
         let Some(book) = &l.book else { return false };
-        let data = book.data();
-        let pages = data
-            .and_then(|d| d.written.as_ref().map(|w| w.pages.clone()))
-            .or_else(|| data.map(|d| d.writable_pages.clone()))
-            .unwrap_or_default();
+        let pages = view_pages(book.data());
         let page = (l.page.max(0) as usize).min(pages.len().saturating_sub(1));
         self.stats.custom("interact_with_lectern", 1);
         self.open_book(BookScreen::View {
@@ -811,11 +876,7 @@ impl Game<'_> {
             page,
         }) = self.book.as_mut()
         {
-            let data = book.as_ref().and_then(ItemStack::data);
-            *pages = data
-                .and_then(|d| d.written.as_ref().map(|w| w.pages.clone()))
-                .or_else(|| data.map(|d| d.writable_pages.clone()))
-                .unwrap_or_default();
+            *pages = view_pages(book.as_ref().and_then(ItemStack::data));
             *page = (*page).min(pages.len().saturating_sub(1));
         }
     }
@@ -955,7 +1016,10 @@ impl Game<'_> {
                 lectern,
             }) => {
                 let (page, count, lectern) = (*page, pages.len(), *lectern);
-                if page + 1 < count && inside(left + 116.0, 159.0, 23.0, 13.0) {
+                // The text's click event first, then the buttons.
+                if let Some(link) = pages.get(page).and_then(|t| self.book_link_at(t, left)) {
+                    self.book_follow_link(link, count, lectern);
+                } else if page + 1 < count && inside(left + 116.0, 159.0, 23.0, 13.0) {
                     self.turn_page(true);
                 } else if page > 0 && inside(left + 43.0, 159.0, 23.0, 13.0) {
                     self.turn_page(false);
@@ -1195,7 +1259,7 @@ impl Game<'_> {
             } => {
                 indicator(batch, *page, pages.len());
                 if let Some(text) = pages.get(*page) {
-                    for (i, line) in self.book_lines(text).iter().take(LINES).enumerate() {
+                    for (i, line) in self.page_lines(text).iter().take(LINES).enumerate() {
                         batch.text_styled(
                             atlas,
                             line,
diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs
index 29cda8b2c..d9a8f39ae 100644
--- a/crates/horizon-client/src/game/chat.rs
+++ b/crates/horizon-client/src/game/chat.rs
@@ -701,12 +701,13 @@ impl Game<'_> {
                     screen.suggest_command(&m, &c, &command);
                 }
             }
-            None => {}
+            // Screen.defaultHandleClickEvent: a page link means nothing in chat.
+            Some(ClickEvent::ChangePage(_)) | None => {}
         }
     }
     /// `Screen.clickUrlAction`: nothing with Web Links off, else the link
     /// opens, after the confirmation unless Prompt on Links is off.
-    fn click_url(&mut self, url: String) {
+    pub(super) fn click_url(&mut self, url: String) {
         if !self.settings.chat_links {
             return;
         }
diff --git a/crates/horizon-client/src/item_data.rs b/crates/horizon-client/src/item_data.rs
index ac624e85b..856eb2af3 100644
--- a/crates/horizon-client/src/item_data.rs
+++ b/crates/horizon-client/src/item_data.rs
@@ -127,6 +127,9 @@ pub struct WrittenBook {
     pub author: String,
     pub generation: u8,
     pub pages: Vec<String>,
+    /// Each page's component when it is not a plain string, so that its
+    /// click events survive; empty or one per page.
+    pub page_tags: Vec<Tag>,
 }
 impl StackData {
     pub fn is_empty(&self) -> bool {
@@ -522,11 +525,14 @@ pub fn components_tag(damage: u32, data: Option<&StackData>) -> Option<Tag> {
             ));
         }
         if let Some(w) = &d.written {
-            let pages = w
-                .pages
-                .iter()
-                .map(|p| raw(Tag::String(p.as_str().into())))
-                .collect();
+            let pages = if w.page_tags.len() == w.pages.len() {
+                w.page_tags.iter().cloned().map(raw).collect()
+            } else {
+                w.pages
+                    .iter()
+                    .map(|p| raw(Tag::String(p.as_str().into())))
+                    .collect()
+            };
             entries.push((
                 "minecraft:written_book_content",
                 Tag::compound({
@@ -707,6 +713,13 @@ pub fn decode_components(components: Option<&Tag>) -> (u32, Option<Box<StackData
                     Some(Tag::List(pages)) => pages.iter().filter_map(filterable_text).collect(),
                     _ => Vec::new(),
                 },
+                page_tags: match b.get("pages") {
+                    Some(Tag::List(pages)) => pages
+                        .iter()
+                        .map(|p| p.get("raw").unwrap_or(p).clone())
+                        .collect(),
+                    _ => Vec::new(),
+                },
             }),
         fireworks: c
             .get("minecraft:fireworks")
diff --git a/crates/horizon-client/src/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs
index 7e43cf04e..f29ea7048 100644
--- a/crates/horizon-client/src/lan/guest.rs
+++ b/crates/horizon-client/src/lan/guest.rs
@@ -631,11 +631,14 @@ fn network_stack(
                         title: w.title.clone(),
                         author: w.author.clone(),
                         generation: i32::from(w.generation),
-                        pages: w
-                            .pages
-                            .iter()
-                            .map(|p| horizon_protocol::text::literal(p))
-                            .collect(),
+                        pages: if w.page_tags.len() == w.pages.len() {
+                            w.page_tags.clone()
+                        } else {
+                            w.pages
+                                .iter()
+                                .map(|p| horizon_protocol::text::literal(p))
+                                .collect()
+                        },
                         resolved: true,
                     },
                 ),
diff --git a/crates/horizon-client/src/text.rs b/crates/horizon-client/src/text.rs
index 20cbdc65a..78d905622 100644
--- a/crates/horizon-client/src/text.rs
+++ b/crates/horizon-client/src/text.rs
@@ -44,6 +44,8 @@ pub fn named_color(name: &str) -> Option<u32> {
 pub enum ClickEvent {
     /// `ClickEvent.OpenUrl`: an http or https link.
     OpenUrl(String),
+    /// `ClickEvent.ChangePage`: a book's page, counted from 1.
+    ChangePage(i32),
     SuggestCommand(String),
     CopyToClipboard(String),
     /// A local file to open with the system handler.
@@ -532,6 +534,7 @@ fn style_json(style: &Style) -> Vec<(String, Value)> {
     if let Some(click) = &style.click {
         let event = match click {
             ClickEvent::OpenUrl(url) => json!({ "action": "open_url", "url": url }),
+            ClickEvent::ChangePage(page) => json!({ "action": "change_page", "page": page }),
             ClickEvent::SuggestCommand(command) => {
                 json!({ "action": "suggest_command", "command": command })
             }

From f4a235e02792a38530ea9058bc4bbbde2ef771e2 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:20:45 +0100
Subject: [PATCH 270/475] Record a witch potion source only when it deals
 damage

---
 crates/horizon-client/src/game/creatures.rs | 40 ++++++++++++---------
 1 file changed, 23 insertions(+), 17 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index e5d7660da..d266e62c4 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2427,24 +2427,30 @@ impl Game<'_> {
                     if d2 < 16.0 && !self.creative {
                         let scale = 1.0 - d2.sqrt() / 4.0;
                         let t = (f64::from(*ticks) * scale + 0.5) as i32;
-                        // indirectMagic(potion, owner): the thrower, or the
-                        // potion itself when it has none.
-                        let owner = self
-                            .combat
-                            .projectile_owner
-                            .filter(|id| self.mob_display_name(*id).is_some());
-                        match owner {
-                            Some(owner) => self.note_attacker("minecraft:indirect_magic", owner),
-                            None => self.note_direct_entity(
-                                "minecraft:indirect_magic",
-                                Text::translate("entity.minecraft.splash_potion", &[]),
-                            ),
-                        }
                         match *effect {
-                            "minecraft:instant_damage" => self.hurt_player_by(
-                                "minecraft:indirect_magic",
-                                6.0 * (1 << *amplifier) as f32 * scale as f32,
-                            ),
+                            "minecraft:instant_damage" => {
+                                // indirectMagic(potion, owner), built where the
+                                // hurt happens: the thrower, or the potion
+                                // itself when it has none. A status effect
+                                // deals no damage, so it records no source.
+                                let owner = self
+                                    .combat
+                                    .projectile_owner
+                                    .filter(|id| self.mob_display_name(*id).is_some());
+                                match owner {
+                                    Some(owner) => {
+                                        self.note_attacker("minecraft:indirect_magic", owner)
+                                    }
+                                    None => self.note_direct_entity(
+                                        "minecraft:indirect_magic",
+                                        Text::translate("entity.minecraft.splash_potion", &[]),
+                                    ),
+                                }
+                                self.hurt_player_by(
+                                    "minecraft:indirect_magic",
+                                    6.0 * (1 << *amplifier) as f32 * scale as f32,
+                                )
+                            }
                             e if t > 20 => self.give_player_effect(e, t, *amplifier),
                             _ => {}
                         }

From 0e96fb6d2a87ba22b6a640ac27d6a075b8626214 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:21:06 +0100
Subject: [PATCH 271/475] Disable unavailable options in the Graphics Advanced
 screen

---
 crates/horizon-client/src/graphics_style.rs |  3 +-
 crates/horizon-client/src/graphics_ui.rs    | 33 ++++++++++++++++++++-
 2 files changed, 34 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/graphics_style.rs b/crates/horizon-client/src/graphics_style.rs
index e02a0e1d9..62979903b 100644
--- a/crates/horizon-client/src/graphics_style.rs
+++ b/crates/horizon-client/src/graphics_style.rs
@@ -118,8 +118,9 @@ impl Style {
         (x, y, w): (f32, f32, f32),
         label: &Text,
         hover: bool,
+        active: bool,
     ) {
-        ui::button(batch, atlas, x, y, w, 20.0, label, true, hover);
+        ui::button(batch, atlas, x, y, w, 20.0, label, active, hover);
     }
     pub fn slider(
         &self,
diff --git a/crates/horizon-client/src/graphics_ui.rs b/crates/horizon-client/src/graphics_ui.rs
index 3c7a40e02..d55e44d99 100644
--- a/crates/horizon-client/src/graphics_ui.rs
+++ b/crates/horizon-client/src/graphics_ui.rs
@@ -468,6 +468,10 @@ fn max_workers() -> u32 {
 }
 
 impl Item {
+    /// False for a setting whose system is not in Horizon yet (`Opt::available`).
+    fn available(self) -> bool {
+        !matches!(self, Item::Vanilla(o) if !o.available())
+    }
     /// On/off settings and their value.
     pub fn switch(self, s: &Settings) -> Option<bool> {
         let g = &s.horizon;
@@ -510,6 +514,9 @@ impl Item {
         }
     }
     pub fn set_slider(self, s: &mut Settings, v: f32) {
+        if !self.available() {
+            return;
+        }
         match self {
             Item::Vanilla(o) => o.set_slider(s, v),
             Item::Horizon(h) => h.set_slider(s, v),
@@ -517,6 +524,9 @@ impl Item {
         self.touched(s);
     }
     pub fn cycle(self, s: &mut Settings, back: bool, framebuffer: [i32; 2]) {
+        if !self.available() {
+            return;
+        }
         match self {
             Item::Vanilla(o) => o.cycle(s, back, framebuffer),
             Item::Horizon(h) => h.cycle(s, back),
@@ -689,6 +699,7 @@ impl GraphicsUi {
             })
             .collect();
         let mut index = 0;
+        let mut tooltip = None;
         for wd in &widgets {
             let hover = ui::hovered(cursor, wd.x, wd.y, wd.w, 20.0)
                 && (!wd.list || (cursor.1 >= top && cursor.1 < bottom));
@@ -700,6 +711,13 @@ impl GraphicsUi {
                         continue;
                     }
                     let label = item.label(s);
+                    let live = item.available();
+                    if hover && !live {
+                        tooltip = Some(atlas.font.split(
+                            &Text::literal("This feature is not yet available in Horizon."),
+                            170.0,
+                        ));
+                    }
                     match item.slider(s) {
                         Some(value) => STYLE.slider(
                             batch,
@@ -709,7 +727,14 @@ impl GraphicsUi {
                             value,
                             hover || self.dragging == Some(item),
                         ),
-                        None => STYLE.button(batch, atlas, (wd.x, wd.y, wd.w), &label, hover),
+                        None => STYLE.button(
+                            batch,
+                            atlas,
+                            (wd.x, wd.y, wd.w),
+                            &label,
+                            hover && live,
+                            live,
+                        ),
                     }
                     STYLE.description(
                         batch,
@@ -732,6 +757,7 @@ impl GraphicsUi {
                         (wd.x, wd.y, wd.w),
                         &Text::literal(label),
                         hover,
+                        true,
                     );
                 }
             }
@@ -751,6 +777,9 @@ impl GraphicsUi {
             Level::Advanced => "Graphics: Advanced",
         };
         STYLE.title(batch, atlas, &Text::literal(title));
+        if let Some(lines) = tooltip {
+            ui::tooltip(batch, atlas, &lines, cursor);
+        }
     }
     /// A press (or a drag with `drag`) at `(x, y)`.
     pub fn click(
@@ -788,6 +817,8 @@ impl GraphicsUi {
             }
             return match wd.target {
                 Target::Button(action) => vec![Action::ButtonClick, action],
+                // A disabled control does nothing: no sound, no preset change.
+                Target::Item(item) if !item.available() => Vec::new(),
                 Target::Item(item) => {
                     if item.slider(s).is_some() {
                         self.dragging = Some(item);

From abb4e7b5cd6a22fce0aa543e4266fbff8ae275ac Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:21:40 +0100
Subject: [PATCH 272/475] Record the thrower of guest drops and the player
 behind a lead

---
 crates/horizon-client/src/game.rs                  | 11 +++++++++--
 crates/horizon-client/src/game/commands/execute.rs | 10 +++++++---
 crates/horizon-client/src/game/leads.rs            |  5 +++++
 crates/horizon-client/src/mobs.rs                  |  2 ++
 4 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 20f6e01bc..48c182d10 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2320,11 +2320,18 @@ impl Game<'_> {
             yaw.cos() * pitch.cos() * 0.3 + spread.sin() * strength,
         ];
         self.spawn_item(thrown, [eye[0], eye[1] - 0.3, eye[2]], v, 40);
-        if thrown_from_hand && self.lan_acting.is_none() {
-            let uuid = self.level.ensure_player_uuid();
+        if thrown_from_hand {
+            let uuid = self.acting_player_uuid();
             self.dropped.last_mut().unwrap().thrower = Some(uuid);
         }
     }
+    /// The UUID of the player acting: the guest whose turn it is, else the host.
+    pub(super) fn acting_player_uuid(&mut self) -> [i32; 4] {
+        match self.lan_acting_uuid {
+            Some(guest) => horizon_client::lan::playerdata::uuid_ints(guest),
+            None => self.level.ensure_player_uuid(),
+        }
+    }
     fn tick_items(&mut self) {
         let mut items = std::mem::take(&mut self.dropped);
         // ServerLevel.tick: only entities in entity-ticking chunks tick.
diff --git a/crates/horizon-client/src/game/commands/execute.rs b/crates/horizon-client/src/game/commands/execute.rs
index 88d24e9bc..6635fc457 100644
--- a/crates/horizon-client/src/game/commands/execute.rs
+++ b/crates/horizon-client/src/game/commands/execute.rs
@@ -612,9 +612,13 @@ impl Game<'_> {
                     .mobs
                     .iter()
                     .find(|m| m.id == id)
-                    .and_then(|m| m.extra.leash)
-                    .and_then(|holder| match holder {
-                        horizon_client::mobs::leash::Holder::Player => Some(Target::Player),
+                    .and_then(|m| m.extra.leash.map(|holder| (holder, m.extra.leash_player)))
+                    .and_then(|(holder, player)| match holder {
+                        // The player who tied it (the host's when unrecorded).
+                        horizon_client::mobs::leash::Holder::Player => {
+                            let uuid = player.or(self.level.player_uuid)?;
+                            self.target_by_uuid(horizon_client::lan::playerdata::ints_uuid(uuid))
+                        }
                         horizon_client::mobs::leash::Holder::Mob(i) => Some(Target::Mob(i)),
                         horizon_client::mobs::leash::Holder::Knot(_) => None,
                     })
diff --git a/crates/horizon-client/src/game/leads.rs b/crates/horizon-client/src/game/leads.rs
index 8867157ee..ca70351c6 100644
--- a/crates/horizon-client/src/game/leads.rs
+++ b/crates/horizon-client/src/game/leads.rs
@@ -104,6 +104,9 @@ impl Game<'_> {
             };
             let m = &mut self.mobs[i];
             if let Some(h) = holder {
+                if h == Holder::Player {
+                    m.extra.leash_player = Some(player_uuid);
+                }
                 m.extra.leash = Some(h);
                 m.extra.leash_pending = None;
             } else if m.age > 100 {
@@ -201,7 +204,9 @@ impl Game<'_> {
                 if self.mobs[index].extra.leash.is_some() {
                     self.break_leash(id, true, false);
                 }
+                let holder = self.acting_player_uuid();
                 self.mobs[index].extra.leash = Some(Holder::Player);
+                self.mobs[index].extra.leash_player = Some(holder);
                 self.lead_sound("tied", at);
                 // The lead is always used up.
                 if let Some(stack) = self.held_mut().as_mut() {
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 512339976..624c89f58 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -728,6 +728,8 @@ pub struct Extra {
     /// the spin the rope's torque gives it.
     pub leash: Option<leash::Holder>,
     pub leash_pending: Option<leash::Pending>,
+    /// The UUID of the player behind `Holder::Player` (host or guest).
+    pub leash_player: Option<[i32; 4]>,
     pub leash_spin: f64,
     /// More species scratch values.
     pub scratch: [i32; 4],

From 4afd517c2213fad4476e0b3442d16893a720f4f1 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:22:46 +0100
Subject: [PATCH 273/475] tools/remote.sh: run a command on playhorizon at a
 worktree's commit

The host fetches the commit from GitHub (nothing else is sent), keeps one
checkout and target per worktree, runs the command niced in its CI slice on
CPUs 4-7 with scratch homes, prepares vanilla data for harness commands as
CI does, and streams the output back. One run per name at a time; no lock
leaks into daemons the run starts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/parity-workflow.md |  11 +++++
 tools/remote.sh         | 104 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 115 insertions(+)
 create mode 100755 tools/remote.sh

diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md
index c0cf3aec5..7419eef26 100644
--- a/docs/parity-workflow.md
+++ b/docs/parity-workflow.md
@@ -44,6 +44,17 @@ Harnesses can also run on the Mac mini, the desktop and playhorizon (`tools/pari
 
 Harnesses a host can't run are listed in the file: `local_only` (`save_roundtrip` runs the game on a virtual screen) and each host's `exclude`. The Mac excludes nothing: vanilla's `Math.sin`, `pow`, `log` and the like don't round the same on an Apple silicon Mac as on Linux (HotSpot uses fdlibm there, Intel's stubs on x86-64), and Rust's float functions round like neither (they call the platform libm), so code that mirrors a vanilla `Math` call uses `horizon_core::jmath`, which computes what HotSpot computes on the host architecture. The ThinkPad no longer runs harnesses (2026-10-26): playhorizon is the Linux host that is always on.
 
+### Any command on playhorizon: `tools/remote.sh`
+
+For Linux work that doesn't need a whole parity run (a crate's tests, a few harnesses, a server build), `tools/remote.sh <worktree> <command...>` runs the command on playhorizon at the worktree's commit and streams its output back; its exit status is the command's. Commit and push first: the host fetches the commit from GitHub, and nothing else leaves this machine (no files, no credentials, no environment). Each worktree keeps one checkout there, `~/remote-work/<name>` with its own `target/`, so the next run only rebuilds what changed, and one run per name goes at a time. The command runs niced in the host's CI slice, pinned to CPUs 4-7 (`--cpus`; 0-3 stay free for benchmarks), with scratch game and launcher homes and the vanilla data linked as CI links it; a command naming `parity`, `lan_e2e` or `horizon-prepare` also gets `.local/horizon-client`, prepared as CI prepares it. Logs stay in `~/remote-work/<name>.logs/`; `--list` shows the checkouts, `--gc [DAYS]` removes old ones.
+
+```sh
+tools/remote.sh .claude/worktrees/my-fix cargo test -p horizon-world --lib   # 33 s, warm
+tools/remote.sh . python3 tools/parity.py food                               # 19 s warm (4 min the first time); here: 188 s, 229 CPU-seconds
+```
+
+The host is lent by a partner who keeps hypervisor access: send it no secret, token or credential, and never take a result from it as a CI result.
+
 ### Shards and Rust scopes
 
 A harness can declare, at the top level of its script:
diff --git a/tools/remote.sh b/tools/remote.sh
new file mode 100755
index 000000000..1df21c560
--- /dev/null
+++ b/tools/remote.sh
@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+# Run a command on a Linux build host (default playhorizon) at a worktree's commit, and get its output back.
+#
+#   tools/remote.sh [--host H] [--name N] [--cpus LIST] [--jobs J] <worktree> <command...>
+#   tools/remote.sh .claude/worktrees/my-fix cargo test -p horizon-world --lib
+#   tools/remote.sh . python3 tools/parity.py food light
+#   tools/remote.sh --list                          # checkouts on the host, their size and last use
+#   tools/remote.sh --gc [DAYS]                     # remove checkouts unused for DAYS (default 2)
+#
+# The host fetches the commit from GitHub itself: commit and push first (uncommitted changes are not sent, and
+# nothing else leaves this machine: no files, no credentials, no environment). Each name (default: the worktree's
+# folder) keeps one checkout there, ~/remote-work/<name>, with its own target/: the next run checks out the new
+# commit over it, so only what changed rebuilds (sccache shares the registry crates between names). One run per
+# name at a time. The command runs in bash at the checkout's root, niced in the host's CI slice, with the host's
+# toolchains, a virtual screen and scratch homes for the game and launcher. .local/ links to the host's vanilla
+# data; a command that runs harnesses (it names parity, lan_e2e or horizon-prepare) also gets .local/horizon-client,
+# prepared as CI prepares it (tools/ci/vanilla-data.sh). Output streams back and is kept in ~/remote-work/<name>.logs/.
+# The exit status is the command's.
+#
+# The host is lent by a partner who keeps hypervisor access: never send secrets, tokens or credentials there,
+# and never treat a result from it as a CI result.
+set -euo pipefail
+
+# CPUs 0-3 stay free for benchmarks (perf-world-entry measures on playhorizon pinned to them); --cpus all for every one.
+host=playhorizon name="" jobs="" cpus=4-7
+usage() { sed -n '2,8s/^# \{0,1\}//p' "$0" >&2; exit 2; }
+while [ $# -gt 0 ]; do
+  case $1 in
+    --host) host=$2; shift 2;;
+    --name) name=$2; shift 2;;
+    --jobs) jobs=$2; shift 2;;
+    --cpus) cpus=$2; shift 2;;
+    --list) exec ssh "ludovic@$host" 'cd ~/remote-work 2>/dev/null && for d in */; do d=${d%/};
+      printf "%-32s %8s  last used %s\n" "$d" "$(du -sh "$d" 2>/dev/null | cut -f1)" "$(stat -c %y "$d.logs" 2>/dev/null | cut -c1-16)"; done';;
+    --gc) days=${2:-2}; exec ssh "ludovic@$host" "cd ~/remote-work 2>/dev/null || exit 0
+      find . -maxdepth 1 -name '*.logs' -mtime +$days | while read -r logs; do d=\${logs%.logs};
+        flock -n \"\$d.lock\" rm -rf \"\$d\" \"\$logs\" \"\$d.lock\" && echo \"removed \${d#./}\"; done";;
+    -h|--help) usage;;
+    *) break;;
+  esac
+done
+[ $# -ge 2 ] || usage
+tree=$(cd "$1" && git rev-parse --show-toplevel); shift
+sha=$(git -C "$tree" rev-parse HEAD)
+name=${name:-$(basename "$tree")}
+[[ $name =~ ^[A-Za-z0-9._-]+$ ]] || { echo "remote.sh: name '$name' must be letters, digits, . _ -" >&2; exit 2; }
+if ! git -C "$tree" diff --quiet HEAD -- 2>/dev/null; then
+  echo "remote.sh: uncommitted changes in $tree are not sent: the host runs ${sha:0:9}" >&2
+fi
+if [ -z "$(git -C "$tree" branch -r --contains "$sha" 2>/dev/null)" ]; then
+  git -C "$tree" fetch -q origin 2>/dev/null || true
+  [ -n "$(git -C "$tree" branch -r --contains "$sha" 2>/dev/null)" ] ||
+    { echo "remote.sh: ${sha:0:9} is not on GitHub yet: push it first (the host fetches from GitHub)" >&2; exit 2; }
+fi
+command=$(printf '%q ' "$@")
+
+# The host side reads its script and these four values on stdin (nothing is re-split by a remote shell); its
+# own environment comes from the runner's files there.
+{
+printf 'name=%q sha=%q jobs=%q cpus=%q command=%q\n' "$name" "$sha" "$jobs" "$cpus" "$command"
+cat <<'REMOTE'
+set -euo pipefail
+if [ "$cpus" = all ]; then pin=(); jobs=${jobs:-$(nproc)}; else pin=(taskset -c "$cpus"); jobs=${jobs:-$(taskset -c "$cpus" nproc)}; fi
+runner=~/.actions-runners/horizon
+if [ -e "$runner/paused" ]; then echo "remote.sh: this host is paused ($runner/paused)" >&2; exit 75; fi
+set -a; . "$runner/.env"; set +a
+export PATH="$(cat "$runner/.path")" DISPLAY=":$(cat "$runner/display")" RUSTC_WRAPPER="$(command -v sccache || true)"
+export CARGO_BUILD_JOBS=$jobs FLEET_LOAD_JOBS=$jobs PARITY_LOCAL_JOBS=$(( jobs > 1 ? jobs / 2 : 1 ))
+unset WAYLAND_DISPLAY
+mkdir -p ~/remote-work && cd ~/remote-work
+exec 9> "$name.lock"
+flock -n 9 || { echo "remote.sh: $name is busy with another run" >&2; exit 75; }
+if [ ! -d "$name/.git" ]; then
+  git clone -q --filter=blob:none --no-checkout https://github.com/ludovic111/horizon "$name" 9>&-
+fi
+cd "$name"
+# The lock's descriptor stays out of everything started here (9>&-): a daemon one of them starts (sccache's server,
+# from the preparer's build or the command's) would hold the lock after the run.
+git fetch -q --no-tags origin "$sha" 9>&-
+git checkout -q --force --detach "$sha"
+git clean -qfd -e /target -e /.local
+# The host's vanilla data, linked as CI's runner links it; for harnesses also .local/horizon-client, prepared by
+# this commit's own preparer (once per preparer version, kept beside the data and shared by every name).
+if [[ $command =~ parity|lan_e2e|horizon-prepare ]]; then
+  RUNNER_WORKSPACE=$(dirname "$HORIZON_SHARED_SOURCE") RUNNER_TEMP=$(mktemp -d) bash tools/ci/vanilla-data.sh >&2 9>&-
+else
+  mkdir -p .local
+  for d in minecraft tools datagen; do
+    if [ -e "$HORIZON_SHARED_SOURCE/$d" ]; then ln -sfn "$HORIZON_SHARED_SOURCE/$d" ".local/$d"; fi
+  done
+fi
+scratch=$(mktemp -d)
+trap 'rm -rf "$scratch"' EXIT
+export HORIZON_HOME=$scratch/game HORIZON_LAUNCHER_HOME=$scratch/launcher XDG_DATA_HOME=$scratch/data \
+  XDG_CONFIG_HOME=$scratch/config HORIZON_NO_AUDIO=1 HORIZON_LAUNCHER_NO_SELF_UPDATE=1 HORIZON_TELEMETRY_URL=off
+mkdir -p "$HORIZON_HOME" "$HORIZON_LAUNCHER_HOME" "$XDG_DATA_HOME" "$XDG_CONFIG_HOME" ../"$name.logs"
+log=../"$name.logs/$(date -u +%Y%m%dT%H%M%SZ)-${sha:0:9}.log"
+echo "remote.sh: $(hostname) at ${sha:0:9} in ~/remote-work/$name, CPUs $cpus, -j $jobs; log ~/remote-work/${log#../}" >&2
+status=0
+systemd-run --user --scope --quiet --slice=horizon-ci.slice --unit="remote-$name-$$" \
+  "${pin[@]}" nice -n 10 bash -c "$command" 2>&1 < /dev/null 9>&- | tee "$log" || status=${PIPESTATUS[0]}
+exit "$status"
+REMOTE
+} | ssh -o BatchMode=yes "ludovic@$host" bash -s

From 56bf45cee512556c8c0a01eea04371876a117606 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:23:03 +0100
Subject: [PATCH 274/475] Keep the pack screen selection in step with High
 Contrast

---
 crates/horizon-client/src/options_ui.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs
index b6a3a0f3e..9170fd66e 100644
--- a/crates/horizon-client/src/options_ui.rs
+++ b/crates/horizon-client/src/options_ui.rs
@@ -2541,6 +2541,10 @@ impl OptionsUi {
                                     if s.high_contrast {
                                         s.resource_packs.push("high_contrast".into());
                                     }
+                                    // PackSelectionScreen reads the repository each time it
+                                    // opens: the next one starts from this selection.
+                                    self.pack_selection = s.resource_packs.clone();
+                                    self.pack_screen = None;
                                     events.push(Event::Packs(s.resource_packs.clone()));
                                 }
                             }
@@ -2712,6 +2716,7 @@ impl OptionsUi {
                 {
                     let ids = p.commit();
                     s.resource_packs = ids.clone();
+                    self.pack_selection = ids.clone();
                     events.push(Event::Packs(ids));
                 }
             }

From 65c60ab996f596a020f614fa3f8e1f8ab1a83b7f Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:23:38 +0100
Subject: [PATCH 275/475] Play remote sounds in the category the packet names

---
 crates/horizon-client/src/game/remote.rs | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..e2c0be9c3 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -1741,7 +1741,17 @@ impl Game<'_> {
                         f64::from(p.y) / 8.0,
                         f64::from(p.z) / 8.0,
                     ];
-                    self.audio.play(&name, Some(at), p.volume, p.pitch);
+                    // ClientPacketListener.handleSoundEvent plays with packet.getSource().
+                    match usize::try_from(p.source)
+                        .ok()
+                        .filter(|s| *s < horizon_client::settings::SOUND_SOURCES.len())
+                    {
+                        Some(source) => {
+                            self.audio
+                                .play_on(source, &name, Some(at), p.volume, p.pitch)
+                        }
+                        None => self.audio.play(&name, Some(at), p.volume, p.pitch),
+                    }
                 }
             }
             C::StopSound(p) => self

From 26561d315c5d187c4d1f70af4f92455d030f9967 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:26:47 +0100
Subject: [PATCH 276/475] Preload the world data while the player chooses a
 world

The worldgen bundle, the loot tables and the registries a server sends are
read on a helper thread from the moment the player opens Singleplayer or
Create World, so a world opening finds them ready. A world opened meanwhile
waits for the part being read. If the player goes back to the title or to
Multiplayer and opens no world for a minute, the preload is dropped: the three
caches can now let go of what they hold.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game.rs             | 12 +++
 crates/horizon-client/src/game/lan.rs         | 22 ++++--
 .../horizon-client/src/game/world_loading.rs  | 75 +++++++++++++++++++
 crates/horizon-client/src/structure_blocks.rs | 19 ++++-
 crates/horizon-client/src/vanillagen.rs       | 14 +++-
 5 files changed, 129 insertions(+), 13 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index f9edd98bb..5acacd05c 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -8069,6 +8069,7 @@ impl Game<'_> {
         creative: bool,
         create: Option<&horizon_client::title::WorldOptions>,
     ) -> Result<()> {
+        world_loading::world_data_used();
         if self.defer_world_entry(PendingWorldEntry::Local {
             folder: folder.to_owned(),
             name: name.map(str::to_owned),
@@ -13025,6 +13026,17 @@ impl Game<'_> {
         if self.rest_loader.is_some() {
             return Ok(());
         }
+        let on_world_screens = self.title.as_ref().is_some_and(|title| {
+            !matches!(
+                title.mode,
+                horizon_client::title::Mode::Main | horizon_client::title::Mode::Multiplayer(_)
+            )
+        });
+        world_loading::preload_world_data(
+            on_world_screens,
+            &self.options.resources,
+            self.pack.assets.registry,
+        );
         if std::mem::take(&mut self.pending_pack_reload) {
             self.reload_packs();
         }
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..3ec2cca47 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -24,11 +24,24 @@ use horizon_protocol::{
 };
 use std::{
     collections::HashMap,
-    sync::{Arc, OnceLock},
+    sync::{Arc, Mutex},
 };
 
 /// The registries and tags are the same for every world: load them once.
-static SYNC: OnceLock<std::result::Result<Arc<SyncData>, String>> = OnceLock::new();
+static SYNC: Mutex<Option<std::result::Result<Arc<SyncData>, String>>> = Mutex::new(None);
+
+/// The registries and tags a server sends, loaded from `root` the first time.
+pub(super) fn sync_data(root: &std::path::Path) -> std::result::Result<Arc<SyncData>, String> {
+    let mut sync = SYNC.lock().unwrap_or_else(|e| e.into_inner());
+    sync.get_or_insert_with(|| SyncData::load(root).map(Arc::new))
+        .clone()
+}
+
+/// Let go of what `sync_data` loaded: for a preload no world used
+/// (game/world_loading.rs).
+pub(super) fn forget_sync_data() {
+    *SYNC.lock().unwrap_or_else(|e| e.into_inner()) = None;
+}
 
 /// The settings of the open world (WorldOptionsScreen's multiplayer section).
 #[derive(Clone, Copy, Debug)]
@@ -562,10 +575,7 @@ impl Game<'_> {
         config: HubConfig,
         host: Option<u128>,
     ) -> Result<()> {
-        let root = self.options.resources.clone();
-        let sync = SYNC
-            .get_or_init(|| SyncData::load(&root).map(Arc::new))
-            .clone()?;
+        let sync = sync_data(&self.options.resources)?;
         let biome_names: Vec<String> = self
             .res
             .biomes()
diff --git a/crates/horizon-client/src/game/world_loading.rs b/crates/horizon-client/src/game/world_loading.rs
index e9ee8e3e8..b16bcffb6 100644
--- a/crates/horizon-client/src/game/world_loading.rs
+++ b/crates/horizon-client/src/game/world_loading.rs
@@ -196,6 +196,81 @@ impl WorldLoader {
     }
 }
 
+/// How long the preloaded world data outlives the world screens: a player
+/// who goes back to the title or to Multiplayer and opens no world for this
+/// long gets the memory back.
+const PRELOAD_KEPT: std::time::Duration = std::time::Duration::from_secs(60);
+
+enum Preload {
+    Idle,
+    /// Read, or being read, on the "World data preload" thread. `left`: when
+    /// the player last left the world screens.
+    Started {
+        thread: std::thread::JoinHandle<()>,
+        left: Option<std::time::Instant>,
+    },
+    /// A world opened: the data is the world's now, and stays.
+    Used,
+}
+
+static PRELOAD: std::sync::Mutex<Preload> = std::sync::Mutex::new(Preload::Idle);
+
+/// Each frame of the title: read what every world opening loads and keeps
+/// for the rest of the process (the worldgen bundle, the loot tables and the
+/// registries the server sends) on a helper thread while the player is on the
+/// world screens (`on_world_screens`: Singleplayer, Create World and their
+/// dialogs), so it overlaps the time spent choosing a world. A world opened
+/// meanwhile waits for the part being read instead of reading it again. Not
+/// at the title screen itself: many players only go to Multiplayer, and
+/// small machines need the memory. Dropped after `PRELOAD_KEPT` away from
+/// the world screens without a world opening.
+pub(super) fn preload_world_data(
+    on_world_screens: bool,
+    resources: &std::path::Path,
+    registry: &'static horizon_world::registry::BlockRegistry,
+) {
+    let mut preload = PRELOAD.lock().unwrap_or_else(|e| e.into_inner());
+    match &mut *preload {
+        Preload::Used => {}
+        Preload::Idle if on_world_screens => {
+            let resources = resources.to_owned();
+            let spawned = std::thread::Builder::new()
+                .name("World data preload".into())
+                .spawn(move || {
+                    horizon_threads::behind_server();
+                    // Errors are left for the world opening to report.
+                    let _ = horizon_client::vanillagen::shared_data(
+                        &resources.join("worldgen"),
+                        registry,
+                    );
+                    let _ = horizon_client::structure_blocks::loot_data(&resources);
+                    let _ = super::lan::sync_data(&resources);
+                });
+            match spawned {
+                Ok(thread) => *preload = Preload::Started { thread, left: None },
+                Err(e) => log::warn!("Horizon: world data preload: {e}"),
+            }
+        }
+        Preload::Idle => {}
+        Preload::Started { left, .. } if on_world_screens => *left = None,
+        Preload::Started { thread, left } => {
+            let left = *left.get_or_insert_with(std::time::Instant::now);
+            if left.elapsed() >= PRELOAD_KEPT && thread.is_finished() {
+                horizon_client::vanillagen::forget_shared_data();
+                horizon_client::structure_blocks::forget_loot_data();
+                super::lan::forget_sync_data();
+                *preload = Preload::Idle;
+                log::info!("Horizon: preloaded world data dropped, no world opened");
+            }
+        }
+    }
+}
+
+/// A world opens: what `preload_world_data` read is the world's from now on.
+pub(super) fn world_data_used() {
+    *PRELOAD.lock().unwrap_or_else(|e| e.into_inner()) = Preload::Used;
+}
+
 pub(super) fn make_streaming(
     res: &Resources,
     pack: &PackResources,
diff --git a/crates/horizon-client/src/structure_blocks.rs b/crates/horizon-client/src/structure_blocks.rs
index 604cf7925..01c60ed71 100644
--- a/crates/horizon-client/src/structure_blocks.rs
+++ b/crates/horizon-client/src/structure_blocks.rs
@@ -9,7 +9,7 @@ use horizon_world::{
 };
 use std::{
     path::Path,
-    sync::{Arc, OnceLock},
+    sync::{Arc, Mutex},
 };
 
 /// The `custom_data` key holding an exploration map's search until the game
@@ -114,11 +114,13 @@ pub fn has_pending_map(item: &ItemStack) -> bool {
     })
 }
 
-static LOOT: OnceLock<Option<Arc<LootData>>> = OnceLock::new();
+/// None until `loot_data` runs; `Some(None)` when the tables failed to load.
+static LOOT: Mutex<Option<Option<Arc<LootData>>>> = Mutex::new(None);
 
 /// Loot data of the resource root, loaded once per process.
 pub fn loot_data(root: &Path) -> Option<Arc<LootData>> {
-    LOOT.get_or_init(|| match LootData::load(root) {
+    let mut loot = LOOT.lock().unwrap_or_else(|e| e.into_inner());
+    loot.get_or_insert_with(|| match LootData::load(root) {
         Ok(data) => Some(Arc::new(data)),
         Err(e) => {
             log::warn!("Horizon: loot tables unavailable, structure containers stay empty: {e}");
@@ -130,7 +132,16 @@ pub fn loot_data(root: &Path) -> Option<Arc<LootData>> {
 
 /// The loot data `loot_data` loaded, if it ran.
 pub fn loaded_loot_data() -> Option<Arc<LootData>> {
-    LOOT.get().cloned().flatten()
+    LOOT.lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .clone()
+        .flatten()
+}
+
+/// Let go of the loot data: for a preload no world used
+/// (game/world_loading.rs). The next `loot_data` loads it again.
+pub fn forget_loot_data() {
+    *LOOT.lock().unwrap_or_else(|e| e.into_inner()) = None;
 }
 
 /// `RandomizableContainer.unpackLootTable` of a container at `pos`: `table`
diff --git a/crates/horizon-client/src/vanillagen.rs b/crates/horizon-client/src/vanillagen.rs
index 923818a08..79d316969 100644
--- a/crates/horizon-client/src/vanillagen.rs
+++ b/crates/horizon-client/src/vanillagen.rs
@@ -333,15 +333,23 @@ impl VanillaTerrain {
         u64::try_from(self.created.elapsed().as_millis()).unwrap_or(u64::MAX)
     }
 }
+static SHARED_DATA: std::sync::Mutex<Vec<(std::path::PathBuf, Arc<GeneratorData>)>> =
+    std::sync::Mutex::new(Vec::new());
+/// Let go of the bundles `shared_data` loaded: for a preload no world used
+/// (game/world_loading.rs). A generator that holds one keeps it.
+pub fn forget_shared_data() {
+    SHARED_DATA
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .clear();
+}
 /// The worldgen bundle at `dir`, loaded once and shared by every generator
 /// and by live feature placement (sapling growth, bone meal).
 pub fn shared_data(
     dir: &Path,
     registry: &'static BlockRegistry,
 ) -> crate::Result<Arc<GeneratorData>> {
-    static CACHE: std::sync::Mutex<Vec<(std::path::PathBuf, Arc<GeneratorData>)>> =
-        std::sync::Mutex::new(Vec::new());
-    let mut cache = CACHE.lock().unwrap_or_else(|e| e.into_inner());
+    let mut cache = SHARED_DATA.lock().unwrap_or_else(|e| e.into_inner());
     if let Some((_, data)) = cache.iter().find(|(path, _)| path == dir) {
         return Ok(data.clone());
     }

From 9958fe0e49b49e0a933c65d32309e1d362f18674 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:29:26 +0100
Subject: [PATCH 277/475] Light redstone ore when an entity stands on it

---
 crates/horizon-client/src/game/sculk.rs | 26 +++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/crates/horizon-client/src/game/sculk.rs b/crates/horizon-client/src/game/sculk.rs
index 7916c46a1..9b066a710 100644
--- a/crates/horizon-client/src/game/sculk.rs
+++ b/crates/horizon-client/src/game/sculk.rs
@@ -1530,6 +1530,9 @@ impl Game<'_> {
         });
         if let Some((at, on_ground, health, flying)) = player {
             let crouch = self.keys.contains(&KeyCode::ShiftLeft);
+            if on_ground && !self.spectator() {
+                self.step_on_redstone_ore(at, crouch);
+            }
             let in_water = self.in_water_at(at);
             self.entity_motion_events(
                 Who::Player,
@@ -1548,6 +1551,26 @@ impl Game<'_> {
         }
     }
 
+    /// `RedStoneOreBlock.stepOn`: standing on the ore lights it, unless the
+    /// entity is stepping carefully (`attack_block` only lights an unlit ore).
+    fn step_on_redstone_ore(&mut self, at: [f64; 3], carefully: bool) {
+        if carefully {
+            return;
+        }
+        // getOnPosLegacy: 0.2 below the feet.
+        let pos = [
+            at[0].floor() as i32,
+            (at[1] - 0.2).floor() as i32,
+            at[2].floor() as i32,
+        ];
+        if matches!(
+            &*self.block_name(pos),
+            "minecraft:redstone_ore" | "minecraft:deepslate_redstone_ore"
+        ) {
+            let _ = self.attack_block(pos);
+        }
+    }
+
     fn tick_mob_sculk_events(&mut self) {
         let snapshot: Vec<(u32, [f64; 3], bool, bool, Species, Option<i64>)> = self
             .mobs
@@ -1565,6 +1588,9 @@ impl Game<'_> {
             })
             .collect();
         for (id, at, on_ground, in_water, species, damaged) in snapshot {
+            if on_ground {
+                self.step_on_redstone_ore(at, false);
+            }
             let emits = !matches!(species, Species::Shulker);
             if emits {
                 self.entity_motion_events(Who::Mob(id), at, on_ground, in_water, false, false);

From da736d56d64aade0b9b95978358515a8c9b40b36 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:30:42 +0100
Subject: [PATCH 278/475] Lingering clouds skip mobs none of their effects can
 affect

---
 crates/horizon-client/src/game/potions.rs | 64 ++++++++++++++++++-----
 1 file changed, 52 insertions(+), 12 deletions(-)

diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index bfffff5ee..6a3f08ac5 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -79,6 +79,39 @@ fn mob_effect_id(id: &str) -> Option<&'static str> {
     .get(id)
     .copied()
 }
+/// `LivingEntity.canBeAffected` with the mob overrides (`WitherBoss` and
+/// `WitherSkeleton` shrug off wither, `Spider` and `AbstractNautilus` poison,
+/// `Parched` weakness): the immune-to-infested and immune-to-oozing tags
+/// decide first, then the tag of mobs that ignore poison and regeneration.
+fn mob_can_be_affected(
+    tags: &std::collections::HashMap<String, std::collections::HashSet<String>>,
+    kind: &str,
+    effect: &str,
+) -> bool {
+    let effect = effect.trim_start_matches("minecraft:");
+    let kind = kind.trim_start_matches("minecraft:");
+    let overridden = match kind {
+        "wither" | "wither_skeleton" => effect == "wither",
+        "spider" | "cave_spider" | "nautilus" | "zombie_nautilus" => effect == "poison",
+        "parched" => effect == "weakness",
+        _ => false,
+    };
+    if overridden {
+        return false;
+    }
+    let in_tag = |tag: &str| {
+        tags.get(tag)
+            .is_some_and(|t| t.contains(&format!("minecraft:{kind}")))
+    };
+    if in_tag("minecraft:immune_to_infested") {
+        effect != "infested"
+    } else if in_tag("minecraft:immune_to_oozing") {
+        effect != "oozing"
+    } else {
+        !in_tag("minecraft:ignores_poison_and_regen")
+            || (effect != "regeneration" && effect != "poison")
+    }
+}
 impl Game<'_> {
     /// A splash potion, lingering potion or experience bottle in flight (the
     /// player's throws and dispensers both end up here).
@@ -632,14 +665,20 @@ impl Game<'_> {
         for p in players.iter().filter(|p| p.bounds.intersects(area)) {
             inside.push((Victim::Player(p.who), p.position.x, p.position.z));
         }
-        for m in self
-            .mobs
-            .iter()
-            .filter(|m| m.alive() && m.bounds().intersects(area))
-        {
+        let effects = potion.effects;
+        let tags = &self.res.stations().enchantments.entity_tags;
+        // Only mobs that at least one of the cloud's effects can affect are
+        // taken (`allEffects.stream().anyMatch(entity::canBeAffected)`), so
+        // the others neither become victims nor use up its radius.
+        for m in self.mobs.iter().filter(|m| {
+            m.alive()
+                && m.bounds().intersects(area)
+                && effects
+                    .iter()
+                    .any(|(id, ..)| mob_can_be_affected(tags, &m.kind.id, id))
+        }) {
             inside.push((Victim::Mob(m.id), m.position.x, m.position.z));
         }
-        let effects = potion.effects;
         for (victim, x, z) in inside {
             let (dx, dz) = (x - c.at[0], z - c.at[2]);
             if potion.victims.iter().any(|(v, _)| *v == victim)
@@ -687,11 +726,8 @@ impl Game<'_> {
                     return;
                 };
                 // Undead invert healing and harming.
-                let inverted = self
-                    .res
-                    .stations()
-                    .enchantments
-                    .entity_tags
+                let tags = &self.res.stations().enchantments.entity_tags;
+                let inverted = tags
                     .get("minecraft:inverted_healing_and_harm")
                     .is_some_and(|t| t.contains(&self.mobs[i].kind.id));
                 for (id, duration, amp) in effects {
@@ -707,7 +743,11 @@ impl Game<'_> {
                             }
                         }
                         _ => {
-                            if let Some(name) = mob_effect_id(id) {
+                            // `LivingEntity.addEffect` refuses what the mob
+                            // cannot be affected by.
+                            if mob_can_be_affected(tags, &m.kind.id, id)
+                                && let Some(name) = mob_effect_id(id)
+                            {
                                 m.add_effect(name, scaled(*duration), *amp);
                             }
                         }

From 414a2b82a8b9855da62e94467c3352c208376ce4 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:30:57 +0100
Subject: [PATCH 279/475] Do not rebuild the End exit podium once the fight has
 its location

---
 crates/horizon-client/src/game/end.rs | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs
index 32d5113b0..749680cd7 100644
--- a/crates/horizon-client/src/game/end.rs
+++ b/crates/horizon-client/src/game/end.rs
@@ -599,7 +599,9 @@ impl Game<'_> {
 
     /// EnderDragonFight without a dragon: once the centre of the main island
     /// is loaded, place the active exit portal (EndPodiumFeature) and the
-    /// first gateway (spawnNewGateway) if the portal is not there yet.
+    /// first gateway (spawnNewGateway) if the portal is not there yet. Like
+    /// scanState and spawnExitPortal, only while the fight has no exit portal
+    /// location: a podium that is later broken stays broken.
     fn ensure_exit_portal(&mut self) -> Result<()> {
         if self.travelling.is_some()
             || !(-1..=0).all(|cz| (-1..=0).all(|cx| self.streaming.is_lit(cx, cz)))
@@ -609,8 +611,15 @@ impl Game<'_> {
         }
         let won = self.fight.previously_killed;
         let gateway = self.first_gateway();
-        if (0..256).any(|y| &*self.block_name([0, y, 0]) == "minecraft:bedrock") {
-            // The podium exists; the gateway may have been out of range when it was placed.
+        let bedrock_top = (0..256)
+            .rev()
+            .find(|&y| &*self.block_name([0, y, 0]) == "minecraft:bedrock");
+        if bedrock_top.is_some() || self.exit_portal().is_some() {
+            if let Some(top) = bedrock_top {
+                // findExitPortal remembers the location of a podium that is already there.
+                self.set_exit_portal([0, top - 3, 0]);
+            }
+            // The gateway may have been out of range when it was placed.
             if won
                 && self.world.loaded(gateway[0], gateway[2])
                 && &*self.block_name(gateway) != "minecraft:end_gateway"

From d75ef5e4f72426551c5aa9b68099037300e26e93 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:31:51 +0100
Subject: [PATCH 280/475] Draw translucent item quads without depth writes so
 water shows through glass items

---
 crates/horizon-client/src/gfx.rs              | 45 ++++++++++++++++---
 crates/horizon-client/src/gfx/entity_batch.rs |  9 +++-
 crates/horizon-client/src/item_render.rs      | 41 ++++++++++++++++-
 crates/horizon-client/src/item_render/gui.rs  |  1 +
 .../horizon-client/src/item_render/special.rs |  1 +
 5 files changed, 88 insertions(+), 9 deletions(-)

diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index 70d882a98..b1afa4105 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -37,7 +37,9 @@ mod crumbling_tests;
 mod entity_batch;
 mod weather;
 use entity_batch::EntityBatch;
-pub use entity_batch::{SHADOW_OVERLAY, TRANSLUCENT_PARTICLE_OVERLAY, WATER_MASK_OVERLAY};
+pub use entity_batch::{
+    SHADOW_OVERLAY, TRANSLUCENT_ITEM_OVERLAY, TRANSLUCENT_PARTICLE_OVERLAY, WATER_MASK_OVERLAY,
+};
 
 /// Window.getAppropriateLineWidth, in framebuffer pixels.
 pub fn outline_width(width: u32) -> f32 {
@@ -391,6 +393,7 @@ pub struct Renderer {
     weather: weather::Weather,
     crumbling_pipeline: wgpu::RenderPipeline,
     shadow_blob_pipeline: wgpu::RenderPipeline,
+    translucent_item_pipeline: wgpu::RenderPipeline,
     /// `RenderPipelines.WATER_MASK`: depth writes only, no colour.
     water_mask_pipeline: wgpu::RenderPipeline,
     cloud_pipeline: wgpu::RenderPipeline,
@@ -1837,6 +1840,19 @@ impl Renderer {
             alpha_blend,
             false,
         );
+        // RenderPipelines.ITEM_TRANSLUCENT: blended, depth tested. Drawn before
+        // translucent terrain, it cannot write depth: the water behind a
+        // glass item would fail the test and vanish (vanilla sorts these in
+        // its order independent transparency pass instead).
+        let translucent_item_pipeline = entity_pipeline(
+            "Translucent items",
+            None,
+            false,
+            wgpu::CompareFunction::GreaterEqual,
+            Default::default(),
+            alpha_blend,
+            false,
+        );
         let cloud_pipeline = entity_pipeline(
             "Clouds",
             Some(wgpu::Face::Back),
@@ -2371,6 +2387,7 @@ impl Renderer {
             weather,
             crumbling_pipeline,
             shadow_blob_pipeline,
+            translucent_item_pipeline,
             water_mask_pipeline,
             cloud_pipeline,
             cloud_mesh: Default::default(),
@@ -3981,6 +3998,7 @@ impl Renderer {
             water_mask_quads,
             shadow_quads,
             translucent_particle_quads,
+            translucent_item_quads,
         ] = self
             .entity_batch
             .update(entities, frame.additive, frame.hand, frame.see_through);
@@ -3990,7 +4008,8 @@ impl Renderer {
             + translucent_crumbling_quads
             + water_mask_quads
             + shadow_quads
-            + translucent_particle_quads;
+            + translucent_particle_quads
+            + translucent_item_quads;
         let cloud_quads = if let Some(input) = &frame.clouds {
             let (rebuilt, uniform) =
                 crate::spans::time("clouds", || self.cloud_mesh.prepare(input));
@@ -4513,6 +4532,17 @@ impl Renderer {
                 pass.draw_indexed(0..entity_quads * 6, 0, 0..1);
                 pass.set_bind_group(0, &self.group, &[]);
             }
+            if translucent_item_quads > 0 {
+                pass.set_pipeline(&self.translucent_item_pipeline);
+                pass.set_bind_group(0, &self.entity_group, &[]);
+                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
+                pass.draw_indexed(
+                    0..translucent_item_quads * 6,
+                    ((world_quads - translucent_item_quads) * 4) as i32,
+                    0..1,
+                );
+                pass.set_bind_group(0, &self.group, &[]);
+            }
             if !pack_draws_weather {
                 self.weather.draw(&mut pass, &self.entity_group);
             }
@@ -4530,7 +4560,11 @@ impl Renderer {
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
                 pass.draw_indexed(
                     0..shadow_quads * 6,
-                    ((world_quads - translucent_particle_quads - shadow_quads) * 4) as i32,
+                    ((world_quads
+                        - translucent_item_quads
+                        - translucent_particle_quads
+                        - shadow_quads)
+                        * 4) as i32,
                     0..1,
                 );
                 pass.set_bind_group(0, &self.group, &[]);
@@ -4611,7 +4645,8 @@ impl Renderer {
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
                 pass.draw_indexed(
                     0..translucent_particle_quads * 6,
-                    ((world_quads - translucent_particle_quads) * 4) as i32,
+                    ((world_quads - translucent_item_quads - translucent_particle_quads) * 4)
+                        as i32,
                     0..1,
                 );
                 pass.set_bind_group(0, &self.group, &[]);
@@ -5240,7 +5275,7 @@ mod tests {
         let mut batch = super::EntityBatch::default();
         let counts = batch.update(&entities, &quad(3, 5), &quad(0, 6), &quad(0, 8));
         let vertices = &batch.combined;
-        assert_eq!(counts, [4, 1, 1, 0, 1, 1]);
+        assert_eq!(counts, [4, 1, 1, 0, 1, 1, 0]);
         assert_eq!(
             vertices
                 .as_chunks::<4>()
diff --git a/crates/horizon-client/src/gfx/entity_batch.rs b/crates/horizon-client/src/gfx/entity_batch.rs
index 8153699fc..9d5e27a82 100644
--- a/crates/horizon-client/src/gfx/entity_batch.rs
+++ b/crates/horizon-client/src/gfx/entity_batch.rs
@@ -5,14 +5,18 @@ use super::Vertex;
 /// ordinary entities, breaking cracks (11), translucent breaking cracks (12),
 /// the boat water mask (13, `RenderPipelines.WATER_MASK`), entity shadows
 /// (14, `RenderPipelines.ENTITY_SHADOW`) and translucent-layer particles (15,
-/// drawn after translucent terrain: `SubmitNodeCollection.submitQuadParticleGroup`).
-const MATERIALS: usize = 6;
+/// drawn after translucent terrain: `SubmitNodeCollection.submitQuadParticleGroup`)
+/// and translucent item quads (32, drawn without depth writes).
+const MATERIALS: usize = 7;
 /// The overlay of depth-only quads that hide water (`RenderTypes.waterMask`).
 pub const WATER_MASK_OVERLAY: u32 = 13;
 /// The overlay of entity shadow quads (`RenderTypes.entityShadow`).
 pub const SHADOW_OVERLAY: u32 = 14;
 /// The overlay of translucent-layer particles (`SingleQuadParticle.Layer.translucent`).
 pub const TRANSLUCENT_PARTICLE_OVERLAY: u32 = 15;
+/// The overlay of item quads with translucent pixels (`Sheets.translucentItemSheet`,
+/// `RenderPipelines.ITEM_TRANSLUCENT`); past the creeper swell range (16 to 31).
+pub const TRANSLUCENT_ITEM_OVERLAY: u32 = 32;
 
 #[derive(Default)]
 pub(super) struct EntityBatch {
@@ -45,6 +49,7 @@ impl EntityBatch {
                 WATER_MASK_OVERLAY => 3,
                 SHADOW_OVERLAY => 4,
                 TRANSLUCENT_PARTICLE_OVERLAY => 5,
+                TRANSLUCENT_ITEM_OVERLAY => 6,
                 _ => 0,
             };
             self.buckets[material][counts[material]] = index;
diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs
index 4f981b874..e098b31d7 100644
--- a/crates/horizon-client/src/item_render.rs
+++ b/crates/horizon-client/src/item_render.rs
@@ -46,6 +46,9 @@ pub struct ItemQuad {
     pub foil: Foil,
     /// `MaterialInfo.lightEmission` (block light floor).
     pub light_emission: u8,
+    /// The quad's sprite has translucent pixels (`MaterialInfo.itemRenderType`
+    /// is a translucent sheet): drawn with the translucent entities.
+    pub translucent: bool,
 }
 /// Which glint render type a quad uses.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -159,7 +162,7 @@ impl ItemRenderState {
             let m = pose * layer.matrix;
             match &layer.geometry {
                 LayerGeometry::Quads(baked) => {
-                    submit_quads(baked, layer, self.display, m, sprites, sink);
+                    submit_quads(renderer, baked, layer, self.display, m, sprites, sink);
                 }
                 LayerGeometry::Special { model, argument } => special::submit(
                     renderer,
@@ -203,6 +206,7 @@ pub fn argb(color: i32) -> u32 {
 
 /// `ItemFeatureRenderer.prepareMainSubmit` for one cuboid layer.
 fn submit_quads(
+    renderer: &ItemRenderer,
     baked: &BakedItemModel,
     layer: &LayerRender,
     display: DisplayContext,
@@ -216,6 +220,8 @@ fn submit_quads(
         FoilType::Special => Foil::Special,
     };
     let _ = display;
+    // Quads of one layer mostly share a sprite: look its translucency up once.
+    let mut last: Option<(&str, bool)> = None;
     for q in &baked.quads {
         let Some(r) = sprites
             .get(sprite_name(&q.material.sprite))
@@ -239,6 +245,17 @@ fn submit_quads(
         let pos = q.positions.map(|p| m.transform_point3(Vec3::from(p)));
         let uv =
             q.uv.map(|[u, v]| [r.u0 + (r.u1 - r.u0) * u, r.v0 + (r.v1 - r.v0) * v]);
+        let translucent = match last {
+            Some((sprite, translucent)) if sprite == q.material.sprite => translucent,
+            _ => {
+                let translucent = q.material.force_translucent
+                    || renderer
+                        .sprites
+                        .translucent(sprite_name(&q.material.sprite));
+                last = Some((&q.material.sprite, translucent));
+                translucent
+            }
+        };
         sink.quad(ItemQuad {
             pos,
             uv,
@@ -246,6 +263,7 @@ fn submit_quads(
             color: argb(color),
             foil,
             light_emission: q.light_emission,
+            translucent,
         });
     }
 }
@@ -260,6 +278,9 @@ struct FileSprites {
     root: PathBuf,
     permutations: Vec<PalettedPermutations>,
     cache: Mutex<HashMap<String, Option<SpriteMask>>>,
+    /// Sprites with a pixel that is neither fully transparent nor opaque
+    /// (`Transparency.hasTranslucent`), filled in as sprites load.
+    translucent: Mutex<HashMap<String, bool>>,
 }
 impl SpriteLookup for FileSprites {
     fn mask(&self, sprite: &str) -> Option<SpriteMask> {
@@ -283,6 +304,13 @@ fn argb_pixels(rgba: &[u8]) -> Vec<u32> {
         .collect()
 }
 impl FileSprites {
+    fn translucent(&self, sprite: &str) -> bool {
+        let known = |this: &Self| this.translucent.lock().ok()?.get(sprite).copied();
+        known(self).unwrap_or_else(|| {
+            self.mask(sprite);
+            known(self).unwrap_or(false)
+        })
+    }
     fn png(&self, sprite: &str, directory: &str) -> PathBuf {
         crate::atlas_sources::texture_path(&self.root, sprite, directory)
     }
@@ -303,6 +331,10 @@ impl FileSprites {
                 (w, h, pixels)
             }
         };
+        let translucent = argb.iter().any(|p| matches!(p >> 24, 1..=254));
+        if let Ok(mut cache) = self.translucent.lock() {
+            cache.insert(sprite.to_owned(), translucent);
+        }
         let alpha: Vec<u8> = argb.iter().map(|p| (p >> 24) as u8).collect();
         let animation = fs::read_to_string(png.with_extension("png.mcmeta"))
             .ok()
@@ -452,6 +484,7 @@ impl ItemRenderer {
                 root: root.to_path_buf(),
                 permutations,
                 cache: Mutex::default(),
+                translucent: Mutex::default(),
             },
             baked: Mutex::default(),
             extents: Mutex::default(),
@@ -693,7 +726,11 @@ impl ItemSink for WorldSink<'_> {
         } else {
             self.light
         };
-        let overlay = if q.foil == Foil::None { 0 } else { 7 };
+        let overlay = match (q.foil, q.translucent) {
+            (Foil::None, true) => crate::gfx::TRANSLUCENT_ITEM_OVERLAY,
+            (Foil::None, false) => 0,
+            _ => 7,
+        };
         for (p, uv) in q.pos.iter().zip(q.uv) {
             self.out.push(Vertex {
                 normal: [0; 4],
diff --git a/crates/horizon-client/src/item_render/gui.rs b/crates/horizon-client/src/item_render/gui.rs
index ff25fff1d..e0c901c0e 100644
--- a/crates/horizon-client/src/item_render/gui.rs
+++ b/crates/horizon-client/src/item_render/gui.rs
@@ -358,6 +358,7 @@ mod tests {
             color,
             foil: Foil::None,
             light_emission: 0,
+            translucent: false,
         }
     }
 
diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs
index d42378db1..dc023f756 100644
--- a/crates/horizon-client/src/item_render/special.rs
+++ b/crates/horizon-client/src/item_render/special.rs
@@ -119,6 +119,7 @@ fn draw(
             color,
             foil,
             light_emission: 0,
+            translucent: false,
         });
     }
     for (child_name, child) in &part.children {

From 951b88a3c299c1221cbd317481e6bbf1c9d1b8f1 Mon Sep 17 00:00:00 2001
From: Carlos Nunez <carlosnunez01010@gmail.com>
Date: Mon, 26 Oct 2026 16:36:53 -0400
Subject: [PATCH 281/475] Read an End gateway's exit from its block entity

Horizon had no End gateway block entity: game/end.rs kept each gateway's
exit in its own side file and gateway_job only looked there, so a
gateway set with /setblock end_gateway{exit_portal:[I;..],ExactTeleport:1b}
(or the exit worldgen writes) was ignored, and /data get block said the
block was not a block entity.

TheEndGatewayBlockEntity stores Age, exit_portal and ExactTeleport.
BlockEntity::EndGateway now holds them with vanilla's NBT and the
spawnable-bounds check. gateway_job reads the block entity's exit first
and keeps the side file and the 512-block End-spawn rule as fallbacks,
so older saves and gateways without data behave as before. The exits
Horizon creates are stored in the block entity as well, a new exit keeps
the gateway's own ExactTeleport (setExitPosition), and a command that
only changes a block entity's NBT now marks its chunk modified so the
change is saved.

Fixes #1517.

Implementation by Codex (GPT-6.1 Sol), reviewed and extended by Claude.

Co-Authored-By: Codex (GPT-6.1 Sol) <noreply@openai.com>
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/block_entity_nbt.rs |  15 +-
 crates/horizon-client/src/containers.rs       |  16 ++
 crates/horizon-client/src/game.rs             |   2 +
 crates/horizon-client/src/game/commands.rs    |   3 +-
 crates/horizon-client/src/game/end.rs         | 177 +++++++++++++++---
 crates/horizon-client/src/save.rs             |  97 ++++++++++
 crates/horizon-client/src/structure_blocks.rs |  20 ++
 7 files changed, 302 insertions(+), 28 deletions(-)

diff --git a/crates/horizon-client/src/block_entity_nbt.rs b/crates/horizon-client/src/block_entity_nbt.rs
index a4c02ba3b..67cd3591f 100644
--- a/crates/horizon-client/src/block_entity_nbt.rs
+++ b/crates/horizon-client/src/block_entity_nbt.rs
@@ -61,6 +61,16 @@ fn f32_tag(v: f32) -> Tag {
     Tag::Float(v.to_bits())
 }
 
+/// `TheEndGatewayBlockEntity.loadAdditional`: BlockPos.CODEC and Level.isInSpawnableBounds.
+pub(crate) fn gateway_exit(tag: &Tag) -> Option<[i32; 3]> {
+    let Tag::IntArray(v) = tag else { return None };
+    let p: [i32; 3] = v.as_slice().try_into().ok()?;
+    ((-30_000_000..30_000_000).contains(&p[0])
+        && (-20_000_000..20_000_000).contains(&p[1])
+        && (-30_000_000..30_000_000).contains(&p[2]))
+    .then_some(p)
+}
+
 /// What a block entity reads and writes, in `saveAdditional` order.
 struct Fields<'a> {
     input: &'a Tag,
@@ -424,10 +434,7 @@ pub fn canonical(tag: &Tag) -> Option<Tag> {
         }
         "minecraft:end_gateway" => {
             f.long("Age", 0);
-            f.keep("exit_portal", |t| {
-                is_pos(t)
-                    && matches!(t, Tag::IntArray(v) if v[1].abs() <= 30_000_000 && v[0].abs() <= 30_000_000 && v[2].abs() <= 30_000_000)
-            });
+            f.keep("exit_portal", |t| gateway_exit(t).is_some());
             if flag(tag.get("ExactTeleport")) == Some(true) {
                 f.put("ExactTeleport", boolean(true));
             }
diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs
index 8ca9af0ad..81c453f32 100644
--- a/crates/horizon-client/src/containers.rs
+++ b/crates/horizon-client/src/containers.rs
@@ -98,10 +98,19 @@ pub enum BlockEntity {
     Campfire(Box<Campfire>),
     /// `SkullBlockEntity` of every skull and head block.
     Skull(Skull),
+    /// `TheEndGatewayBlockEntity`: its age and configured destination.
+    EndGateway(EndGateway),
     /// `DaylightDetectorBlockEntity`: no data, only the ticker
     /// (`DaylightDetectorBlock.tickEntity`).
     DaylightDetector,
 }
+/// `TheEndGatewayBlockEntity`.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct EndGateway {
+    pub age: i64,
+    pub exit_portal: Option<[i32; 3]>,
+    pub exact_teleport: bool,
+}
 /// `CampfireBlockEntity`: four cooking slots, each with its
 /// `cookingProgress` and `cookingTime` (the recipe's).
 #[derive(Clone, Debug, Default, PartialEq)]
@@ -366,6 +375,9 @@ impl BlockEntity {
         if is_skull(name) {
             return Some(Self::Skull(Skull::default()));
         }
+        if name == "minecraft:end_gateway" {
+            return Some(Self::EndGateway(EndGateway::default()));
+        }
         if name == "minecraft:daylight_detector" {
             return Some(Self::DaylightDetector);
         }
@@ -418,6 +430,7 @@ impl BlockEntity {
             Self::Beehive(_) => "minecraft:beehive",
             Self::CommandBlock(_) => "minecraft:command_block",
             Self::Skull(_) => "minecraft:skull",
+            Self::EndGateway(_) => "minecraft:end_gateway",
             Self::DaylightDetector => "minecraft:daylight_detector",
             Self::Campfire(_) => "minecraft:campfire",
         }
@@ -436,6 +449,7 @@ impl BlockEntity {
             | Self::Vault(_)
             | Self::Beehive(_)
             | Self::CommandBlock(_)
+            | Self::EndGateway(_)
             | Self::Skull(_)
             | Self::DaylightDetector => Vec::new(),
             Self::Lectern(l) => l.book.iter().cloned().collect(),
@@ -456,6 +470,7 @@ impl BlockEntity {
             | Self::Lectern(_)
             | Self::Sculk(_)
             | Self::Banner(_)
+            | Self::EndGateway(_)
             | Self::Skull(_)
             | Self::DaylightDetector => &[],
             Self::Crafter(c) => &c.items,
@@ -480,6 +495,7 @@ impl BlockEntity {
             | Self::Lectern(_)
             | Self::Sculk(_)
             | Self::Banner(_)
+            | Self::EndGateway(_)
             | Self::Skull(_)
             | Self::DaylightDetector => &mut [],
             Self::Crafter(c) => &mut c.items,
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 20f6e01bc..145e55554 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -5455,6 +5455,7 @@ impl Game<'_> {
                 | BlockEntity::Vault(_)
                 | BlockEntity::Beehive(_)
                 | BlockEntity::CommandBlock(_)
+                | BlockEntity::EndGateway(_)
                 | BlockEntity::Skull(_)
                 | BlockEntity::DaylightDetector
                 | BlockEntity::Campfire(_),
@@ -5727,6 +5728,7 @@ impl Game<'_> {
                     | BlockEntity::Vault(_)
                     | BlockEntity::Beehive(_)
                     | BlockEntity::CommandBlock(_)
+                    | BlockEntity::EndGateway(_)
                     | BlockEntity::Skull(_)
                     | BlockEntity::DaylightDetector
                     | BlockEntity::Campfire(_),
diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs
index 22041c3b2..b9a462d87 100644
--- a/crates/horizon-client/src/game/commands.rs
+++ b/crates/horizon-client/src/game/commands.rs
@@ -1896,8 +1896,7 @@ impl Game<'_> {
             return false;
         }
         self.world.block_entities.insert(key, new);
-        let state = self.world.block(pos[0], pos[1], pos[2]);
-        let _ = self.world.set(pos[0], pos[1], pos[2], state);
+        self.world.modified.insert((pos[0] >> 4, pos[2] >> 4));
         true
     }
     /// RandomizableContainer.tryLoadLootTable for a tag a command gives a
diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs
index 32d5113b0..e8b9a96e3 100644
--- a/crates/horizon-client/src/game/end.rs
+++ b/crates/horizon-client/src/game/end.rs
@@ -5,6 +5,7 @@
 use super::{Dim, Game};
 use horizon_client::{
     Result,
+    containers::BlockEntity,
     environment::Environment,
     items::ItemStack,
     mesher::Vertex,
@@ -27,14 +28,53 @@ const GATEWAY_Y: i32 = 75;
 const GATEWAY_FILE: &str = "horizon-end-gateways.json";
 
 /// A gateway teleport waiting for its destination chunks.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub(super) enum GatewayJob {
     /// TheEndGatewayBlockEntity.findOrCreateValidTeleportPos from this gateway.
-    Find { gateway: [i32; 3] },
+    /// `exact` is the gateway's own `ExactTeleport`, read while its chunk is loaded.
+    Find { gateway: [i32; 3], exact: bool },
     /// A known exit (exact, or findExitPosition around it).
     Known { exit: [i32; 3], exact: bool },
 }
 
+impl GatewayJob {
+    /// TheEndGatewayBlockEntity.getPortalPosition, with legacy save fallbacks.
+    fn for_gateway(
+        gateway: [i32; 3],
+        entity: Option<&BlockEntity>,
+        legacy: Option<([i32; 3], bool)>,
+    ) -> Self {
+        let configured = match entity {
+            Some(BlockEntity::EndGateway(g)) => g.exit_portal.map(|exit| (exit, g.exact_teleport)),
+            _ => None,
+        };
+        match configured.or(legacy) {
+            Some((exit, exact)) => Self::Known { exit, exact },
+            // Worldgen return gateways (end_gateway_return) lead exactly to the End spawn.
+            None if f64::from(gateway[0]).hypot(f64::from(gateway[2])) > 512.0 => Self::Known {
+                exit: END_SPAWN,
+                exact: true,
+            },
+            None => Self::Find {
+                gateway,
+                exact: exact_teleport(entity),
+            },
+        }
+    }
+}
+
+/// `TheEndGatewayBlockEntity.exactTeleport` of the block entity at a gateway
+/// (false without one).
+fn exact_teleport(entity: Option<&BlockEntity>) -> bool {
+    matches!(entity, Some(BlockEntity::EndGateway(g)) if g.exact_teleport)
+}
+
+/// The end of `getPortalPosition`: the exit itself when the teleport is exact,
+/// else the spot [`Game::resolve_gateway`] finds around it (`findExitPosition`).
+fn exit_target(exit: [i32; 3], exact: bool, find: impl FnOnce([i32; 3]) -> [i32; 3]) -> [i32; 3] {
+    if exact { exit } else { find(exit) }
+}
+
 #[derive(Default)]
 pub(super) struct EndState {
     /// Gateway position -> (exit, exact teleport); loaded lazily from the save.
@@ -754,6 +794,11 @@ impl Game<'_> {
                 }
             }
         }
+        self.world
+            .block_entities
+            .get_or_insert_with((origin[0], origin[1], origin[2]), || {
+                BlockEntity::EndGateway(Default::default())
+            });
         Ok(())
     }
 
@@ -776,6 +821,21 @@ impl Game<'_> {
     }
 
     fn set_gateway_exit(&mut self, gateway: [i32; 3], exit: [i32; 3], exact: bool) -> Result<()> {
+        // TheEndGatewayBlockEntity.setExitPosition (also EndGatewayFeature.knownExit).
+        let key = (gateway[0], gateway[1], gateway[2]);
+        let chunk = (gateway[0] >> 4, gateway[2] >> 4);
+        // The gateway's chunk can be unloaded by now (travel waits for the destination): the
+        // side map below still records the exit.
+        if self.world.chunks.contains_key(&chunk)
+            && let BlockEntity::EndGateway(g) = self
+                .world
+                .block_entities
+                .get_or_insert_with(key, || BlockEntity::EndGateway(Default::default()))
+        {
+            g.exit_portal = Some(exit);
+            g.exact_teleport = exact;
+            self.world.modified.insert(chunk);
+        }
         self.gateway_exits().insert(gateway, (exit, exact));
         let list: Vec<_> = self
             .gateway_exits()
@@ -808,24 +868,20 @@ impl Game<'_> {
     /// is resolved ([`Game::resolve_gateway`]).
     pub(super) fn gateway_job(&mut self, gateway: [i32; 3]) -> (GatewayJob, Vec3) {
         let known = self.gateway_exits().get(&gateway).copied();
-        let job = match known {
-            Some((exit, exact)) => GatewayJob::Known { exit, exact },
-            // Worldgen return gateways (end_gateway_return) lead exactly to the End spawn.
-            None if f64::from(gateway[0]).hypot(f64::from(gateway[2])) > 512.0 => {
-                GatewayJob::Known {
-                    exit: END_SPAWN,
-                    exact: true,
-                }
-            }
-            None => GatewayJob::Find { gateway },
-        };
+        let job = GatewayJob::for_gateway(
+            gateway,
+            self.world
+                .block_entities
+                .get(&(gateway[0], gateway[1], gateway[2])),
+            known,
+        );
         let destination = match job {
             GatewayJob::Known { exit, .. } => Vec3::new(
                 f64::from(exit[0]) + 0.5,
                 f64::from(exit[1]),
                 f64::from(exit[2]) + 0.5,
             ),
-            GatewayJob::Find { gateway } => {
+            GatewayJob::Find { gateway, .. } => {
                 let d = glam::DVec2::new(f64::from(gateway[0]), f64::from(gateway[2]))
                     .normalize_or_zero()
                     * 1024.0;
@@ -882,12 +938,10 @@ impl Game<'_> {
             [p[0], p[1] + 1, p[2]]
         };
         match job {
-            GatewayJob::Known { exit, exact } => Ok(bottom_center(if exact {
-                exit
-            } else {
-                find_exit(self, exit)
-            })),
-            GatewayJob::Find { gateway } => {
+            GatewayJob::Known { exit, exact } => Ok(bottom_center(exit_target(exit, exact, |e| {
+                find_exit(self, e)
+            }))),
+            GatewayJob::Find { gateway, exact } => {
                 // findExitPortalXZPosTentative over the loaded chunks.
                 let dir = glam::DVec2::new(f64::from(gateway[0]), f64::from(gateway[2]))
                     .normalize_or_zero();
@@ -947,8 +1001,11 @@ impl Game<'_> {
                 let exit = [tallest[0], tallest[1] + 10, tallest[2]];
                 self.place_gateway(exit)?;
                 self.set_gateway_exit(exit, gateway, false)?;
-                self.set_gateway_exit(gateway, exit, false)?;
-                Ok(bottom_center(find_exit(self, exit)))
+                // setExitPosition keeps the gateway's own exactTeleport.
+                self.set_gateway_exit(gateway, exit, exact)?;
+                Ok(bottom_center(exit_target(exit, exact, |e| {
+                    find_exit(self, e)
+                })))
             }
         }
     }
@@ -1245,3 +1302,79 @@ impl Game<'_> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_client::containers::EndGateway;
+
+    #[test]
+    fn a_new_exit_keeps_the_gateways_exact_teleport() {
+        let exact = BlockEntity::EndGateway(EndGateway {
+            exact_teleport: true,
+            ..Default::default()
+        });
+        let plain = BlockEntity::EndGateway(EndGateway::default());
+        assert!(exact_teleport(Some(&exact)));
+        assert!(!exact_teleport(Some(&plain)));
+        assert!(!exact_teleport(None));
+        assert!(!exact_teleport(Some(&BlockEntity::DaylightDetector)));
+        let exit = [8, 100, 0];
+        // Exact: the exit itself, nothing is searched for.
+        assert_eq!(exit_target(exit, true, |_| panic!("searched")), exit);
+        assert_eq!(
+            exit_target(exit, false, |e| [e[0], e[1] + 11, e[2]]),
+            [8, 111, 0]
+        );
+    }
+
+    #[test]
+    fn end_gateway_job_prefers_block_entity_then_legacy_then_heuristic() {
+        let gateway = [702, 100, 0];
+        let exit = [8, 100, 0];
+        for exact in [true, false] {
+            let entity = BlockEntity::EndGateway(EndGateway {
+                exit_portal: Some(exit),
+                exact_teleport: exact,
+                ..Default::default()
+            });
+            assert_eq!(
+                GatewayJob::for_gateway(gateway, Some(&entity), Some((END_SPAWN, !exact))),
+                GatewayJob::Known { exit, exact },
+            );
+        }
+        let empty = BlockEntity::EndGateway(EndGateway::default());
+        for entity in [None, Some(&empty)] {
+            assert_eq!(
+                GatewayJob::for_gateway(gateway, entity, Some((exit, false))),
+                GatewayJob::Known { exit, exact: false }
+            );
+            assert_eq!(
+                GatewayJob::for_gateway(gateway, entity, None),
+                GatewayJob::Known {
+                    exit: END_SPAWN,
+                    exact: true
+                }
+            );
+            let nearby = [96, 75, 0];
+            let exact = BlockEntity::EndGateway(EndGateway {
+                exact_teleport: true,
+                ..Default::default()
+            });
+            assert_eq!(
+                GatewayJob::for_gateway(nearby, Some(&exact), None),
+                GatewayJob::Find {
+                    gateway: nearby,
+                    exact: true
+                }
+            );
+            assert_eq!(
+                GatewayJob::for_gateway(nearby, entity, None),
+                GatewayJob::Find {
+                    gateway: nearby,
+                    exact: false
+                }
+            );
+        }
+    }
+}
diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs
index 5431adcd6..d398a2ac1 100644
--- a/crates/horizon-client/src/save.rs
+++ b/crates/horizon-client/src/save.rs
@@ -643,6 +643,16 @@ pub fn encode_block_entity(
                 entries.push(("custom_name", name.clone()));
             }
         }
+        // TheEndGatewayBlockEntity.saveAdditional.
+        BlockEntity::EndGateway(g) => {
+            entries.push(("Age", Tag::Long(g.age)));
+            if let Some(exit) = g.exit_portal {
+                entries.push(("exit_portal", Tag::IntArray(exit.to_vec())));
+            }
+            if g.exact_teleport {
+                entries.push(("ExactTeleport", Tag::Byte(1)));
+            }
+        }
         BlockEntity::Spawner(s) => entries.extend(s.save()),
         BlockEntity::TrialSpawner(s) => entries.extend(s.save()),
         BlockEntity::Vault(v) => entries.extend(v.save()),
@@ -702,11 +712,24 @@ fn roll_loaded_loot(
         biome,
     ))
 }
+/// `TheEndGatewayBlockEntity.loadAdditional`.
+pub fn decode_end_gateway(tag: &Tag) -> crate::containers::EndGateway {
+    crate::containers::EndGateway {
+        age: number(tag.get("Age")).unwrap_or(0),
+        exit_portal: tag
+            .get("exit_portal")
+            .and_then(crate::block_entity_nbt::gateway_exit),
+        exact_teleport: number(tag.get("ExactTeleport")).unwrap_or(0) != 0,
+    }
+}
 pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::containers::BlockEntity)> {
     use crate::containers::BlockEntity;
     let int = |k: &str| number(tag.get(k)).map(|v| v as i32);
     let id = text(tag.get("id"))?;
     let pos = (int("x")?, int("y")?, int("z")?);
+    if id == "minecraft:end_gateway" {
+        return Some((pos, BlockEntity::EndGateway(decode_end_gateway(tag))));
+    }
     if id == "minecraft:jukebox" {
         let record = tag.get("RecordItem").and_then(item_from_nbt);
         let ticks = number(tag.get("ticks_since_song_started")).unwrap_or(0);
@@ -846,6 +869,7 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain
         | BlockEntity::Lectern(_)
         | BlockEntity::Banner(_)
         | BlockEntity::CreakingHeart(_)
+        | BlockEntity::EndGateway(_)
         | BlockEntity::Skull(_)
         | BlockEntity::DaylightDetector => {}
         BlockEntity::Spawner(s) => **s = crate::mobs::spawner::Spawner::load(tag),
@@ -4660,6 +4684,79 @@ mod tests {
     }
     use super::*;
 
+    #[test]
+    fn end_gateway_block_entity_round_trips() {
+        use crate::containers::{BlockEntity, EndGateway};
+        let plain = BlockEntity::for_block("minecraft:end_gateway").expect("gateway");
+        assert!(matches!(&plain, BlockEntity::EndGateway(g) if *g == EndGateway::default()));
+        for exit in [None, Some([8, 100, 0])] {
+            for exact in [false, true] {
+                let gateway = EndGateway {
+                    age: 201,
+                    exit_portal: exit,
+                    exact_teleport: exact,
+                };
+                let tag = encode_block_entity(
+                    (702, 100, 0),
+                    &BlockEntity::EndGateway(gateway.clone()),
+                    "minecraft:end_gateway",
+                );
+                assert_eq!(
+                    text(tag.get("id")).as_deref(),
+                    Some("minecraft:end_gateway")
+                );
+                assert_eq!(tag.get("Age"), Some(&Tag::Long(201)));
+                assert_eq!(
+                    tag.get("exit_portal"),
+                    exit.map(|p| Tag::IntArray(p.to_vec())).as_ref()
+                );
+                assert_eq!(
+                    tag.get("ExactTeleport"),
+                    exact.then_some(Tag::Byte(1)).as_ref()
+                );
+                let (pos, back) = decode_block_entity(&tag).expect("gateway");
+                assert_eq!(pos, (702, 100, 0));
+                assert!(matches!(back, BlockEntity::EndGateway(g) if g == gateway));
+            }
+        }
+    }
+
+    #[test]
+    fn end_gateway_exit_requires_spawnable_bounds() {
+        for (exit, valid) in [
+            (vec![-30_000_000, -20_000_000, -30_000_000], true),
+            (vec![29_999_999, 19_999_999, 29_999_999], true),
+            (vec![30_000_000, 0, 0], false),
+            (vec![0, 0, 30_000_000], false),
+            (vec![-30_000_001, 0, 0], false),
+            (vec![0, 0, -30_000_001], false),
+            (vec![0, 20_000_000, 0], false),
+            (vec![0, -20_000_001, 0], false),
+            (vec![i32::MIN, 0, 0], false),
+            (vec![0, 100], false),
+        ] {
+            let tag = Tag::compound([
+                ("id", string("minecraft:end_gateway")),
+                ("x", Tag::Int(702)),
+                ("y", Tag::Int(100)),
+                ("z", Tag::Int(0)),
+                ("exit_portal", Tag::IntArray(exit)),
+            ]);
+            let (_, crate::containers::BlockEntity::EndGateway(g)) =
+                decode_block_entity(&tag).unwrap()
+            else {
+                panic!("gateway");
+            };
+            assert_eq!(g.exit_portal.is_some(), valid);
+            let canonical = crate::block_entity_nbt::canonical(&tag).expect("gateway NBT");
+            assert_eq!(canonical.get("exit_portal").is_some(), valid);
+        }
+        assert_eq!(
+            decode_end_gateway(&Tag::Compound(Compound::new())),
+            crate::containers::EndGateway::default()
+        );
+    }
+
     #[test]
     fn skull_block_entity_keeps_its_profile() {
         // A placed `player_head` as vanilla saves it: the owning player's
diff --git a/crates/horizon-client/src/structure_blocks.rs b/crates/horizon-client/src/structure_blocks.rs
index 604cf7925..45eccbac7 100644
--- a/crates/horizon-client/src/structure_blocks.rs
+++ b/crates/horizon-client/src/structure_blocks.rs
@@ -199,6 +199,9 @@ fn generated_block_entity(block: &str, nbt: &Compound) -> Option<BlockEntity> {
         BlockEntity::Vault(v) => **v = crate::vault::Vault::load(&Tag::Compound(nbt.clone())),
         // BannerBlockEntity.loadAdditional: the End cities' black triangles.
         BlockEntity::Banner(b) => *b = crate::save::decode_banner(&Tag::Compound(nbt.clone())),
+        BlockEntity::EndGateway(g) => {
+            *g = crate::save::decode_end_gateway(&Tag::Compound(nbt.clone()))
+        }
         _ => {}
     }
     Some(entity)
@@ -242,6 +245,23 @@ mod tests {
     use super::*;
     use horizon_world::loot::{ExplorationMap, LootStack};
 
+    #[test]
+    fn generated_end_gateway_keeps_its_exit() {
+        let Tag::Compound(nbt) = Tag::compound([
+            ("exit_portal", Tag::IntArray(vec![100, 50, 0])),
+            ("ExactTeleport", Tag::Byte(1)),
+        ]) else {
+            unreachable!()
+        };
+        let Some(BlockEntity::EndGateway(g)) =
+            generated_block_entity("minecraft:end_gateway", &nbt)
+        else {
+            panic!("gateway");
+        };
+        assert_eq!(g.exit_portal, Some([100, 50, 0]));
+        assert!(g.exact_teleport);
+    }
+
     #[test]
     fn placed_chest_loot_keeps_its_enchantments_and_potions() {
         let stack =

From c808fae288d36c682b143edb4e1283438437e165 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:37:30 +0100
Subject: [PATCH 282/475] Keep a stronger active effect when a weaker one is
 added

---
 crates/horizon-client/src/mobs.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 6b1e16f5c..330c2901c 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1879,8 +1879,15 @@ impl Mob {
     }
     pub fn add_effect(&mut self, effect: &'static str, ticks: i32, amplifier: i32) {
         if let Some(e) = self.extra.effects.iter_mut().find(|e| e.0 == effect) {
-            e.1 = e.1.max(ticks);
-            e.2 = e.2.max(amplifier);
+            // MobEffectInstance.update: a stronger effect replaces the old one
+            // with its own duration, an equal one keeps the longer duration,
+            // and a weaker one never changes the active effect.
+            if amplifier > e.2 {
+                e.1 = ticks;
+                e.2 = amplifier;
+            } else if amplifier == e.2 {
+                e.1 = e.1.max(ticks);
+            }
         } else {
             self.extra.effects.push((effect, ticks, amplifier));
         }

From 9eb913affea478d58d127e08f39fcacf379103f0 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:37:33 +0100
Subject: [PATCH 283/475] Show the crouching pose of a guest who is not holding
 sneak

---
 crates/horizon-client/src/game/lan.rs | 1 +
 crates/horizon-client/src/lan/hub.rs  | 5 ++++-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 4ccbb0ec8..2d7302e61 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -839,6 +839,7 @@ impl Game<'_> {
                 gliding: p.fall_flying,
                 swimming: p.swimming,
                 crawling: p.pose == horizon_client::pose::Pose::Swimming && !p.swimming,
+                crouching: p.pose == horizon_client::pose::Pose::Crouching,
                 spin_attack: p.auto_spin_attack_ticks > 0,
                 on_fire: p.fire_ticks > 0,
                 invisible: self.potions.effects.get("invisibility").is_some(),
diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs
index c3a18ee86..ba21bdee1 100644
--- a/crates/horizon-client/src/lan/hub.rs
+++ b/crates/horizon-client/src/lan/hub.rs
@@ -100,6 +100,8 @@ pub struct BodyFlags {
     pub swimming: bool,
     /// The swimming pose of a player crawling under a block.
     pub crawling: bool,
+    /// The crouching pose, held without sneaking under a low ceiling.
+    pub crouching: bool,
     /// `LivingEntity.isAutoSpinAttack`: Riptide's spin.
     pub spin_attack: bool,
     /// `Entity.isOnFire`.
@@ -1549,7 +1551,7 @@ impl Hub {
             1
         } else if body.spin_attack {
             4
-        } else if sneaking {
+        } else if sneaking || body.crouching {
             5
         } else {
             0
@@ -2615,6 +2617,7 @@ fn guest_body(g: &Guest) -> BodyFlags {
         gliding: g.fall_flying,
         swimming: m.is_some_and(|m| m.swimming),
         crawling: m.is_some_and(|m| m.pose == crate::pose::Pose::Swimming && !m.swimming),
+        crouching: m.is_some_and(|m| m.pose == crate::pose::Pose::Crouching),
         spin_attack: m.is_some_and(|m| m.auto_spin_attack_ticks > 0),
         on_fire: m.is_some_and(|m| m.fire_ticks > 0),
         invisible: g.effects.get("invisibility").is_some(),

From bab42517154cead302186e24fd9dfd1b62b98ae3 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:37:47 +0100
Subject: [PATCH 284/475] Give armor stands, frames, paintings, boats, carts
 and other entities a scoreboard name

---
 crates/horizon-client/src/game/scoreboard.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/scoreboard.rs b/crates/horizon-client/src/game/scoreboard.rs
index 81c03e288..72b3ab000 100644
--- a/crates/horizon-client/src/game/scoreboard.rs
+++ b/crates/horizon-client/src/game/scoreboard.rs
@@ -132,8 +132,16 @@ impl Game<'_> {
         match t {
             Target::Player => Some(self.acting_player_name().to_owned()),
             Target::Guest(conn) => self.command_guest(conn).map(|g| g.name.clone()),
-            Target::Mob(id) | Target::Item(id) => Some(uuid_text(self.uuid_for(id))),
-            _ => None,
+            Target::Mob(id)
+            | Target::Item(id)
+            | Target::Stand(id)
+            | Target::Frame(id)
+            | Target::Painting(id)
+            | Target::Boat(id)
+            | Target::Cart(id)
+            | Target::Other(id) => Some(uuid_text(self.uuid_for(id))),
+            // Orbs and projectiles are addressed by index and have no UUID here.
+            Target::Orb(_) | Target::Projectile(_) => None,
         }
     }
     fn holder_for(&mut self, t: Target) -> Option<Holder> {

From a529be89156d129a359fdfc1004390ecc3f82045 Mon Sep 17 00:00:00 2001
From: Kacpherek <kacperpapiez255@gmail.com>
Date: Mon, 26 Oct 2026 21:40:21 +0100
Subject: [PATCH 285/475] Keep translucent item rendering with enchantment
 glint

---
 crates/horizon-client/src/entity.wgsl         |  2 +-
 crates/horizon-client/src/gfx.rs              |  3 ++-
 crates/horizon-client/src/gfx/entity_batch.rs |  4 +++-
 crates/horizon-client/src/item_render.rs      | 12 ++++++------
 4 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl
index 79e11719f..7d3f06040 100644
--- a/crates/horizon-client/src/entity.wgsl
+++ b/crates/horizon-client/src/entity.wgsl
@@ -203,7 +203,7 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
     // lit texture, then the lightmap, then the glint and fog.
     color = vec4(mix(in.overlay_color.rgb, color.rgb, in.overlay_color.a), color.a);
     color *= in.light_color;
-    if in.overlay == 7u || in.overlay == 8u {
+    if in.overlay == 7u || in.overlay == 8u || in.overlay == 33u {
         // Enchantment glint (overlay 7, 8 with the hurt tint): the purple
         // enchanted_glint sheen drifting diagonally over the item's shape.
         let px = in.uv * vec2<f32>(textureDimensions(atlas));
diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index b1afa4105..580e8493a 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -38,7 +38,8 @@ mod entity_batch;
 mod weather;
 use entity_batch::EntityBatch;
 pub use entity_batch::{
-    SHADOW_OVERLAY, TRANSLUCENT_ITEM_OVERLAY, TRANSLUCENT_PARTICLE_OVERLAY, WATER_MASK_OVERLAY,
+    SHADOW_OVERLAY, TRANSLUCENT_GLINT_ITEM_OVERLAY, TRANSLUCENT_ITEM_OVERLAY,
+    TRANSLUCENT_PARTICLE_OVERLAY, WATER_MASK_OVERLAY,
 };
 
 /// Window.getAppropriateLineWidth, in framebuffer pixels.
diff --git a/crates/horizon-client/src/gfx/entity_batch.rs b/crates/horizon-client/src/gfx/entity_batch.rs
index 9d5e27a82..08d749b54 100644
--- a/crates/horizon-client/src/gfx/entity_batch.rs
+++ b/crates/horizon-client/src/gfx/entity_batch.rs
@@ -17,6 +17,8 @@ pub const TRANSLUCENT_PARTICLE_OVERLAY: u32 = 15;
 /// The overlay of item quads with translucent pixels (`Sheets.translucentItemSheet`,
 /// `RenderPipelines.ITEM_TRANSLUCENT`); past the creeper swell range (16 to 31).
 pub const TRANSLUCENT_ITEM_OVERLAY: u32 = 32;
+/// A translucent item with an enchantment glint.
+pub const TRANSLUCENT_GLINT_ITEM_OVERLAY: u32 = 33;
 
 #[derive(Default)]
 pub(super) struct EntityBatch {
@@ -49,7 +51,7 @@ impl EntityBatch {
                 WATER_MASK_OVERLAY => 3,
                 SHADOW_OVERLAY => 4,
                 TRANSLUCENT_PARTICLE_OVERLAY => 5,
-                TRANSLUCENT_ITEM_OVERLAY => 6,
+                TRANSLUCENT_ITEM_OVERLAY | TRANSLUCENT_GLINT_ITEM_OVERLAY => 6,
                 _ => 0,
             };
             self.buckets[material][counts[material]] = index;
diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs
index e098b31d7..75f947eec 100644
--- a/crates/horizon-client/src/item_render.rs
+++ b/crates/horizon-client/src/item_render.rs
@@ -248,10 +248,9 @@ fn submit_quads(
         let translucent = match last {
             Some((sprite, translucent)) if sprite == q.material.sprite => translucent,
             _ => {
-                let translucent = q.material.force_translucent
-                    || renderer
-                        .sprites
-                        .translucent(sprite_name(&q.material.sprite));
+                let translucent = renderer
+                    .sprites
+                    .translucent(sprite_name(&q.material.sprite));
                 last = Some((&q.material.sprite, translucent));
                 translucent
             }
@@ -263,7 +262,7 @@ fn submit_quads(
             color: argb(color),
             foil,
             light_emission: q.light_emission,
-            translucent,
+            translucent: translucent || q.material.force_translucent,
         });
     }
 }
@@ -729,7 +728,8 @@ impl ItemSink for WorldSink<'_> {
         let overlay = match (q.foil, q.translucent) {
             (Foil::None, true) => crate::gfx::TRANSLUCENT_ITEM_OVERLAY,
             (Foil::None, false) => 0,
-            _ => 7,
+            (_, true) => crate::gfx::TRANSLUCENT_GLINT_ITEM_OVERLAY,
+            (_, false) => 7,
         };
         for (p, uv) in q.pos.iter().zip(q.uv) {
             self.out.push(Vertex {

From d7fece582525719a905729232904b3d566090751 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:42:52 +0100
Subject: [PATCH 286/475] Keep hideParticles of mob effects: no swirls drawn or
 sent for them

---
 crates/horizon-client/src/game/client_ambient.rs   |  1 +
 crates/horizon-client/src/game/commands/effects.rs | 11 ++++++++++-
 crates/horizon-client/src/game/lan.rs              |  8 +++++++-
 crates/horizon-client/src/mobs.rs                  |  2 ++
 crates/horizon-client/src/mobs/ai.rs               |  3 +++
 5 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/client_ambient.rs b/crates/horizon-client/src/game/client_ambient.rs
index 48bfc663c..3ea8f922a 100644
--- a/crates/horizon-client/src/game/client_ambient.rs
+++ b/crates/horizon-client/src/game/client_ambient.rs
@@ -81,6 +81,7 @@ impl Game<'_> {
                     .extra
                     .effects
                     .iter()
+                    .filter(|e| !m.extra.hidden_effects.contains(&e.0))
                     .filter_map(|e| effect_particle(e.0, false))
                     .collect();
                 swirl(
diff --git a/crates/horizon-client/src/game/commands/effects.rs b/crates/horizon-client/src/game/commands/effects.rs
index 65d6592f7..6516bfe6c 100644
--- a/crates/horizon-client/src/game/commands/effects.rs
+++ b/crates/horizon-client/src/game/commands/effects.rs
@@ -91,7 +91,12 @@ impl Game<'_> {
                 }
                 Target::Mob(id) => match self.mobs.iter_mut().find(|m| m.id == id) {
                     Some(m) => {
-                        m.add_effect(namespaced(effect.id), duration, amplifier);
+                        let name = namespaced(effect.id);
+                        m.add_effect(name, duration, amplifier);
+                        m.extra.hidden_effects.retain(|h| *h != name);
+                        if !particles {
+                            m.extra.hidden_effects.push(name);
+                        }
                         true
                     }
                     None => false,
@@ -154,6 +159,10 @@ impl Game<'_> {
                         m.extra
                             .effects
                             .retain(|x| e.is_some_and(|e| x.0 != namespaced(e.id)));
+                        let left = &m.extra.effects;
+                        m.extra
+                            .hidden_effects
+                            .retain(|h| left.iter().any(|x| x.0 == *h));
                         m.extra.effects.len() != before
                     }
                     None => false,
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index a48c30656..f1298e589 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -180,7 +180,13 @@ fn mob_meta(
     defaults.push((9, serializer::FLOAT, Value::Float(1.0)));
     // LivingEntity.DATA_EFFECT_PARTICLES and DATA_EFFECT_AMBIENCE_ID: the
     // swirls of its effects (the ones a mob has are visible, not ambient).
-    meta.extend(hub.effect_meta(m.extra.effects.iter().map(|e| (e.0, false))));
+    meta.extend(
+        hub.effect_meta(
+            (m.extra.effects.iter())
+                .filter(|e| !m.extra.hidden_effects.contains(&e.0))
+                .map(|e| (e.0, false)),
+        ),
+    );
     defaults.push((10, serializer::PARTICLES, Value::Particles(Vec::new())));
     defaults.push((11, serializer::BOOLEAN, Value::Bool(false)));
     // Mob.DATA_MOB_FLAGS_ID: no AI 1, left-handed 2, aggressive 4 (what
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 0bc37bcc7..b02eb111a 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -715,6 +715,8 @@ pub struct Extra {
     pub vector: [f64; 3],
     /// Active status effects: (effect id, ticks left, amplifier).
     pub effects: Vec<(&'static str, i32, i32)>,
+    /// The effects above given with `hideParticles`: no swirls for them.
+    pub hidden_effects: Vec<&'static str>,
     /// `LivingEntity.DATA_EFFECT_PARTICLES` and `DATA_EFFECT_AMBIENCE_ID` as a
     /// server gave them: the swirls around it, and whether they are all faint.
     pub effect_particles: Vec<crate::particles::ParticleOptions>,
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 2676c3a37..014032280 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -1488,6 +1488,9 @@ fn tick_effects(m: &mut Mob) {
         *ticks -= 1;
     }
     effects.retain(|e| e.1 > 0);
+    m.extra
+        .hidden_effects
+        .retain(|h| effects.iter().any(|e| e.0 == *h));
     m.extra.effects = effects;
 }
 

From b33ae69938eda922d839b881fbce082ade1f3956 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:43:08 +0100
Subject: [PATCH 287/475] Find the End podium level from its rim so a broken
 centre column is fine

---
 crates/horizon-client/src/game/end.rs | 48 +++++++++++++++++++--------
 1 file changed, 35 insertions(+), 13 deletions(-)

diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs
index 749680cd7..4f05c4a5b 100644
--- a/crates/horizon-client/src/game/end.rs
+++ b/crates/horizon-client/src/game/end.rs
@@ -611,14 +611,13 @@ impl Game<'_> {
         }
         let won = self.fight.previously_killed;
         let gateway = self.first_gateway();
-        let bedrock_top = (0..256)
-            .rev()
-            .find(|&y| &*self.block_name([0, y, 0]) == "minecraft:bedrock");
-        if bedrock_top.is_some() || self.exit_portal().is_some() {
-            if let Some(top) = bedrock_top {
-                // findExitPortal remembers the location of a podium that is already there.
-                self.set_exit_portal([0, top - 3, 0]);
+        if self.exit_portal().is_none() {
+            // findExitPortal remembers the location of a podium that is already there.
+            if let Some(level) = self.podium_level() {
+                self.set_exit_portal([0, level, 0]);
             }
+        }
+        if self.exit_portal().is_some() {
             // The gateway may have been out of range when it was placed.
             if won
                 && self.world.loaded(gateway[0], gateway[2])
@@ -650,17 +649,40 @@ impl Game<'_> {
         }
         Ok(())
     }
+    /// The portal level of the podium around the centre column, read from the
+    /// bedrock that EndPodiumFeature places (rim at the portal level, disc
+    /// below it, the torch column) so a broken column does not hide it.
+    fn podium_level(&self) -> Option<i32> {
+        let mut offsets: Vec<[i32; 3]> = (0..4).map(|dy| [0, dy, 0]).collect();
+        for z in -4..=4i32 {
+            for x in -4..=4i32 {
+                let flat = f64::from(x * x + z * z);
+                if (6.25..12.25).contains(&flat) {
+                    offsets.push([x, 0, z]);
+                } else if flat + 1.0 < 6.25 {
+                    offsets.push([x, -1, z]);
+                }
+            }
+        }
+        (1..253)
+            .map(|y| {
+                let score = offsets
+                    .iter()
+                    .filter(|o| &*self.block_name([o[0], y + o[1], o[2]]) == "minecraft:bedrock")
+                    .count();
+                (score, y)
+            })
+            .filter(|&(score, _)| score >= 3)
+            .max()
+            .map(|(_, y)| y)
+    }
     /// `spawnExitPortal(true)` after the dragon dies.
     pub(super) fn activate_exit_portal(&mut self) -> Result<()> {
         let origin = match self.exit_portal() {
             Some(o) => o,
             None => {
-                // The rim's level: the top of the bedrock column minus three.
-                let top = (0..256)
-                    .rev()
-                    .find(|&y| &*self.block_name([0, y, 0]) == "minecraft:bedrock")
-                    .unwrap_or(64);
-                [0, top - 3, 0]
+                // The rim's level, found without assuming the centre column is intact.
+                [0, self.podium_level().unwrap_or(61), 0]
             }
         };
         self.place_podium(origin, true)

From eab8d0f91120e6f9732196a01e2b2a9fb03bf0bf Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:45:02 +0100
Subject: [PATCH 288/475] Slide on honey for the server's player and show the
 slide effects to multiplayer clients

---
 crates/horizon-client/src/game.rs             | 51 ++++++++++++-------
 crates/horizon-client/src/game/lan_actions.rs | 21 ++++++++
 crates/horizon-client/src/game/remote.rs      | 24 +++++++++
 crates/horizon-client/src/motion.rs           | 12 +++--
 4 files changed, 87 insertions(+), 21 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index ab63124d6..e9c81348d 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2097,6 +2097,33 @@ impl Game<'_> {
     }
     /// `TerrainParticle` at `pos`: the model's particle sprite and tint source
     /// 0's `colorAsTerrainParticle` (white when the block has none).
+    /// `HoneyBlock.showSlideParticles` (entity event 53): five honey block
+    /// particles at the entity.
+    fn honey_slide_particles(&mut self, at: [f64; 3]) {
+        use horizon_client::particles::{ParticleOptions, ParticleType};
+        let Some(honey) = self
+            .pack
+            .assets
+            .registry
+            .default_state("minecraft:honey_block")
+        else {
+            return;
+        };
+        let block = [
+            at[0].floor() as i32,
+            at[1].floor() as i32,
+            at[2].floor() as i32,
+        ];
+        if let Some((sprite, tint)) = self.particle_sprite(honey, block) {
+            for _ in 0..5 {
+                self.particles.add(
+                    &ParticleOptions::block(ParticleType::Block, sprite.clone(), tint),
+                    at,
+                    [0.0; 3],
+                );
+            }
+        }
+    }
     fn particle_sprite(&self, state: BlockStateId, pos: [i32; 3]) -> Option<(String, u32)> {
         let sprite = Self::block_particle_sprite(&self.pack, state)?;
         let chunks = &self.world.chunks;
@@ -4545,28 +4572,18 @@ impl Game<'_> {
                 MotionEvent::Snowflake { position, velocity } => self.snowflake(position, velocity),
                 MotionEvent::EnterBlock { state } => self.trigger_enter_block(state),
                 MotionEvent::HoneySlide {
-                    pos,
-                    sound,
-                    particles,
+                    sound, particles, ..
                 } => {
                     if sound {
                         self.audio
                             .play("minecraft:block.honey_block.slide", Some(feet), 1.0, 1.0);
                     }
-                    // HoneyBlock.showSlideParticles: five block particles.
-                    if particles
-                        && let Some((sprite, tint)) = self.particle_sprite(
-                            self.world.block(pos.x, pos.y, pos.z),
-                            [pos.x, pos.y, pos.z],
-                        )
-                    {
-                        use horizon_client::particles::{ParticleOptions, ParticleType};
-                        for _ in 0..5 {
-                            self.particles.add(
-                                &ParticleOptions::block(ParticleType::Block, sprite.clone(), tint),
-                                feet,
-                                [0.0; 3],
-                            );
+                    if particles {
+                        self.honey_slide_particles(feet);
+                        // The server's event 53 reaches the guests too.
+                        let id = self.lan.as_ref().map(|h| h.host_entity);
+                        if let Some(id) = id {
+                            self.lan_entity_event(id, 53, feet);
                         }
                     }
                 }
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 43bb573dc..fb484f94d 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -2311,6 +2311,27 @@ impl Game<'_> {
             match event {
                 MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, at),
                 MotionEvent::Fall(event) => self.landing_block_updates(&event),
+                // HoneyBlock.maybeDoSlideEffects: the sound reaches the
+                // others (Player.playSound excludes the player, whose client
+                // plays it), the entity event 53 everyone around.
+                MotionEvent::HoneySlide {
+                    sound, particles, ..
+                } => {
+                    let Some((id, at)) = host.hub.guest(conn).map(|g| (g.entity_id, g.position))
+                    else {
+                        continue;
+                    };
+                    if sound {
+                        let name = "minecraft:block.honey_block.slide";
+                        let source = horizon_client::settings::sound_source(name) as i32;
+                        self.audio.play_unshared(name, Some(at), 1.0, 1.0);
+                        host.hub.sound(name, at, 1.0, 1.0, source, Some(conn));
+                    }
+                    if particles {
+                        self.honey_slide_particles(at);
+                        host.hub.entity_event(id, 53, at);
+                    }
+                }
                 _ => {}
             }
         }
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 3cfbd15e3..a290d6e1a 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -2133,6 +2133,23 @@ impl Game<'_> {
                 if p.event == super::totem::TOTEM_EVENT {
                     self.remote_totem(p.id);
                 }
+                // Entity event 53: the honey slide particles of a player
+                // sliding down a honey block (HoneyBlock.showSlideParticles).
+                if p.event == 53 {
+                    let at = if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) {
+                        self.player
+                            .as_ref()
+                            .map(|q| [q.position.x, q.position.y, q.position.z])
+                    } else {
+                        self.mobs
+                            .iter()
+                            .find(|m| m.id == p.id as u32)
+                            .map(|m| [m.position.x, m.position.y, m.position.z])
+                    };
+                    if let Some(at) = at {
+                        self.honey_slide_particles(at);
+                    }
+                }
             }
             C::Animate(p) => self.remote_animate(p.id, p.action),
             // ClientPacketListener.handleSwingAnimation: the entity swings
@@ -3326,6 +3343,13 @@ impl Game<'_> {
                 horizon_client::motion::MotionEvent::InsidePortal { .. } => {
                     self.client_inside_nether_portal();
                 }
+                // HoneyBlock.maybeDoSlideEffects on the client's own level:
+                // the slide sound, heard here (LocalPlayer.playSound); the
+                // particles come from the server's event 53.
+                horizon_client::motion::MotionEvent::HoneySlide { sound: true, .. } => {
+                    self.audio
+                        .play("minecraft:block.honey_block.slide", Some(feet), 1.0, 1.0);
+                }
                 _ => {}
             }
         }
diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index 04341b66f..2ff68093c 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -204,8 +204,8 @@ pub enum MotionEvent {
         position: Vec3,
     },
     /// `HoneyBlock.maybeDoSlideEffects` for a player sliding down the side of
-    /// the honey block at `pos`: its slide sound, and the client's five
-    /// block particles (entity event 53) at the player.
+    /// the honey block at `pos`: its slide sound, and the server's entity
+    /// event 53 (the five block particles at the player).
     HoneySlide {
         pos: BlockPos,
         sound: bool,
@@ -1381,6 +1381,9 @@ impl MotionWorld<'_, '_, '_> {
                     "minecraft:sweet_berry_bush" if damage_only => {
                         self.sweet_berry_bush_damage(state)?;
                     }
+                    // HoneyBlock.entityInside: a server's player slides too, so
+                    // its fall distance resets (its client moves it).
+                    "minecraft:honey_block" => self.honey_block_inside(p)?,
                     // PowderSnowBlock.entityInside's FREEZE.
                     "minecraft:powder_snow" if damage_only => entered.push((step, p)),
                     _ => {}
@@ -1394,7 +1397,6 @@ impl MotionWorld<'_, '_, '_> {
                         entered.push((step, p));
                     }
                     "minecraft:cobweb" => self.web_inside(),
-                    "minecraft:honey_block" => self.honey_block_inside(p)?,
                     "minecraft:sweet_berry_bush" => self.sweet_berry_bush_inside(state)?,
                     "minecraft:bubble_column" => {
                         let precise = moved_far || deflated.intersects(Aabb::block(p));
@@ -1444,7 +1446,9 @@ impl MotionWorld<'_, '_, '_> {
         // maybeDoSlideEffects: the sound, then the server's event 53.
         let random = &mut self.scene.random;
         let sound = random.next_int_bound(5).map_err(|e| format!("{e:?}"))? == 0;
-        let particles = random.next_int_bound(5).map_err(|e| format!("{e:?}"))? == 0;
+        // Only the server broadcasts event 53 (`!level.isClientSide()`).
+        let particles = !self.player.client_side
+            && random.next_int_bound(5).map_err(|e| format!("{e:?}"))? == 0;
         if sound || particles {
             self.player.events.push(MotionEvent::HoneySlide {
                 pos,

From e41c602359730f1a7b34f333df6d0f12b369a04f Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:46:00 +0100
Subject: [PATCH 289/475] Keep picking up a banner next to a raider even when
 its path was cached as unreachable

---
 crates/horizon-client/src/game/raids.rs | 36 +++++++++++++++----------
 1 file changed, 22 insertions(+), 14 deletions(-)

diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs
index e34d9feed..dd3f3f29e 100644
--- a/crates/horizon-client/src/game/raids.rs
+++ b/crates/horizon-client/src/game/raids.rs
@@ -856,23 +856,31 @@ impl Game<'_> {
                 && raids.get(id).is_some_and(|r| r.leader(s.wave).is_none())
                 && !leaders.contains(&(id, s.wave))
             {
+                let in_reach = |(i, _, p): &&(usize, u32, Vec3)| {
+                    !taken.contains(i)
+                        && (p.x - position.x).abs() <= range
+                        && (p.z - position.z).abs() <= range
+                        && (p.y - position.y).abs() <= 8.0
+                };
+                let by_distance = |a: &&(usize, u32, Vec3), b: &&(usize, u32, Vec3)| {
+                    a.2.distance_squared(position)
+                        .total_cmp(&b.2.distance_squared(position))
+                };
+                // The unreachable cache only picks the navigation target;
+                // a banner next to the raider is still picked up.
                 let near = banners
                     .iter()
-                    .filter(|(i, item, p)| {
-                        !taken.contains(i)
-                            && !s
-                                .unreachable_banners
-                                .iter()
-                                .any(|&(b, until)| b == *item && now < until)
-                            && (p.x - position.x).abs() <= range
-                            && (p.z - position.z).abs() <= range
-                            && (p.y - position.y).abs() <= 8.0
+                    .filter(in_reach)
+                    .filter(|(_, item, _)| {
+                        !s.unreachable_banners
+                            .iter()
+                            .any(|&(b, until)| b == *item && now < until)
                     })
-                    .min_by(|a, b| {
-                        a.2.distance_squared(position)
-                            .total_cmp(&b.2.distance_squared(position))
-                    });
-                if let Some((i, item, p)) = near {
+                    .min_by(by_distance);
+                let nearest = banners.iter().filter(in_reach).min_by(by_distance);
+                let adjacent =
+                    nearest.filter(|(_, _, p)| p.distance_squared(position) < 1.414 * 1.414);
+                if let Some((i, item, p)) = adjacent.or(near) {
                     s.banner_at = Some([p.x, p.y, p.z]);
                     s.banner_item = *item;
                     if p.distance_squared(position) < 1.414 * 1.414 {

From db985f717ce34b63566922b7e3d79cc6559d2c73 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:46:04 +0100
Subject: [PATCH 290/475] Spectator crosshair also checks the other half of a
 double chest

---
 crates/horizon-client/src/game/hand.rs | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/game/hand.rs b/crates/horizon-client/src/game/hand.rs
index c3fd78310..60869952f 100644
--- a/crates/horizon-client/src/game/hand.rs
+++ b/crates/horizon-client/src/game/hand.rs
@@ -333,12 +333,16 @@ impl Game<'_> {
             | "dispenser" | "dropper" | "crafter" | "lectern" | "beacon" | "nether_portal"
             | "end_portal" | "end_gateway" => true,
             // ChestBlock.getMenuProvider: none while a redstone conductor
-            // sits on top (a sitting cat aside).
+            // sits on top of either half (a sitting cat aside).
             "chest" | "trapped_chest" => {
-                let above = self.world.block(hit.pos[0], hit.pos[1] + 1, hit.pos[2]);
-                self.res.behaviours().facts(above).flags
-                    & horizon_world::level::data::state_flags::CONDUCTOR
-                    == 0
+                let key = (hit.pos[0], hit.pos[1], hit.pos[2]);
+                let blocked = |p: (i32, i32, i32)| {
+                    let above = self.world.block(p.0, p.1 + 1, p.2);
+                    self.res.behaviours().facts(above).flags
+                        & horizon_world::level::data::state_flags::CONDUCTOR
+                        != 0
+                };
+                !blocked(key) && self.chest_other_half(key).is_none_or(|o| !blocked(o))
             }
             _ => name.ends_with("shulker_box"),
         }

From 3bb6e4030479493f15e366b3ad0081aa178bb7b6 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:46:13 +0100
Subject: [PATCH 291/475] Clear a bundle's selection when the cursor leaves it
 on a server's client too

---
 crates/horizon-client/src/game/remote.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 32f5f6093..3a04019d2 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3136,6 +3136,8 @@ impl Game<'_> {
         // server says the entry ended. `onCooldownEnded` is the plain
         // ItemCooldowns' no-op on a client.
         self.cooldowns.tick();
+        // Leaving a slot clears its bundle's selection here and on the server.
+        self.tick_bundle_hover();
         // Options.broadcastOptions: a changed render distance or Chat option
         // is sent again.
         let view = client_view_distance(self.settings.render_distance);

From 35a02c79a8d433e86e5b1aa1a8f5afdbbfa268fb Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:46:18 +0100
Subject: [PATCH 292/475] Cats also skip chests a copper golem has open

---
 crates/horizon-client/src/mobs/tame.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs
index 30ac762b9..0049e7f98 100644
--- a/crates/horizon-client/src/mobs/tame.rs
+++ b/crates/horizon-client/src/mobs/tame.rs
@@ -846,8 +846,13 @@ fn can_sit_on(w: &MobWorld, p: [i32; 3]) -> bool {
     match f.name.as_ref() {
         // The lit state is the only light source a furnace has.
         "minecraft:furnace" => f.emission > 0,
-        // `ChestBlockEntity.getOpenCount(level, pos) < 1`.
-        "minecraft:chest" => !w.lid_openers.contains_key(&(p[0], p[1], p[2])),
+        // `ChestBlockEntity.getOpenCount(level, pos) < 1`: players' openers
+        // and the copper golems' own count.
+        "minecraft:chest" => {
+            let key = (p[0], p[1], p[2]);
+            !w.lid_openers.contains_key(&key)
+                && w.world.chest_openers.get(&key).is_none_or(|o| o.0 < 1)
+        }
         // A bed's foot only (`BedBlock.PART != HEAD`).
         _ => w.prop(p[0], p[1], p[2], "part") != Some("head"),
     }

From d8b8246622bbbbb0cb1479dfff79536cf7318587 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:46:31 +0100
Subject: [PATCH 293/475] Light redstone ore under dropped items too

---
 crates/horizon-client/src/game/sculk.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/crates/horizon-client/src/game/sculk.rs b/crates/horizon-client/src/game/sculk.rs
index 9b066a710..23c3c2acf 100644
--- a/crates/horizon-client/src/game/sculk.rs
+++ b/crates/horizon-client/src/game/sculk.rs
@@ -1515,6 +1515,16 @@ impl Game<'_> {
     fn tick_entity_events(&mut self) {
         self.tick_player_sculk_events();
         self.tick_mob_sculk_events();
+        // Dropped items are entities too: Entity.applyEffectsFromBlocks.
+        let items: Vec<[f64; 3]> = self
+            .dropped
+            .iter()
+            .filter(|i| i.on_ground)
+            .map(|i| [i.position.x, i.position.y, i.position.z])
+            .collect();
+        for at in items {
+            self.step_on_redstone_ore(at, false);
+        }
     }
 
     /// Entity.move emits on the authoritative server too, for each ServerPlayer.

From 77fe538e09b0b8677634083d6fdca88d9f543b45 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:48:05 +0100
Subject: [PATCH 294/475] Let only the owner command a tame wolf or cat, and
 make pets follow their owner

Sitting, standing, dyeing and healing a cat or wolf now check the saved
owner. The follow, teleport and owner-hurt goals use the owner, not the
nearest player, and a new tame wolf or cat is owned by whoever tamed it.
---
 crates/horizon-client/src/game/creatures.rs | 22 ++++++++++++++-----
 crates/horizon-client/src/game/lan_mobs.rs  | 15 ++++++++++++-
 crates/horizon-client/src/mobs/tame.rs      | 24 +++++++++++++--------
 3 files changed, 46 insertions(+), 15 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index f6961ab13..68964a3fd 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2739,6 +2739,7 @@ impl Game<'_> {
             .items()
             .get(&item)
             .is_some_and(|i| i.max_damage > 0);
+        let acting = self.acting_uuid();
         let m = &mut self.mobs[index];
         if !m.alive() {
             return Ok(false);
@@ -2833,6 +2834,7 @@ impl Game<'_> {
             }
             Species::Wolf
                 if m.extra.tame
+                    && m.extra.owner == Some(acting)
                     && item.ends_with("_dye")
                     && horizon_client::mobs::render::DYE_NAMES
                         .iter()
@@ -2855,7 +2857,9 @@ impl Game<'_> {
                 consume = true;
             }
             Species::Wolf
-                if m.extra.tame && !(is_food && m.extra.age == 0 && m.extra.in_love <= 0) =>
+                if m.extra.tame
+                    && m.extra.owner == Some(acting)
+                    && !(is_food && m.extra.age == 0 && m.extra.in_love <= 0) =>
             {
                 m.extra.sitting = !m.extra.sitting;
                 m.ai.jumping = false;
@@ -2875,7 +2879,7 @@ impl Game<'_> {
                 let tamed = m.random.next_int_bound(3).unwrap_or(1) == 0;
                 if tamed {
                     horizon_client::mobs::tame::set_tame(m, true);
-                    m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1]));
+                    m.extra.owner = Some(acting);
                     m.persistent = true;
                     m.nav_stop();
                     m.ai.target = None;
@@ -2902,6 +2906,7 @@ impl Game<'_> {
             // Cat.mobInteract: dye, heal or sit when tame; fish may tame a wild one.
             Species::Cat
                 if m.extra.tame
+                    && m.extra.owner == Some(acting)
                     && item.ends_with("_dye")
                     && horizon_client::mobs::render::DYE_NAMES
                         .iter()
@@ -2924,7 +2929,12 @@ impl Game<'_> {
                 m.persistent = true;
                 consume = true;
             }
-            Species::Cat if m.extra.tame && is_food && m.health < m.attrs.max_health => {
+            Species::Cat
+                if m.extra.tame
+                    && m.extra.owner == Some(acting)
+                    && is_food
+                    && m.health < m.attrs.max_health =>
+            {
                 let heal = self
                     .res
                     .items()
@@ -2937,7 +2947,9 @@ impl Game<'_> {
                 eat = eating_sound(m, &mut self.world.random);
             }
             Species::Cat
-                if m.extra.tame && !(is_food && m.extra.age == 0 && m.extra.in_love <= 0) =>
+                if m.extra.tame
+                    && m.extra.owner == Some(acting)
+                    && !(is_food && m.extra.age == 0 && m.extra.in_love <= 0) =>
             {
                 m.extra.sitting = !m.extra.sitting;
                 self.world.modified.insert((
@@ -2951,7 +2963,7 @@ impl Game<'_> {
                 let tamed = m.random.next_int_bound(3).unwrap_or(1) == 0;
                 if tamed {
                     m.extra.tame = true;
-                    m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1]));
+                    m.extra.owner = Some(acting);
                     m.extra.sitting = true;
                 }
                 eat = eating_sound(m, &mut self.world.random);
diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs
index 6527f1015..f0e7cb4f9 100644
--- a/crates/horizon-client/src/game/lan_mobs.rs
+++ b/crates/horizon-client/src/game/lan_mobs.rs
@@ -5,7 +5,7 @@
 //! (hits, pushes, fire, its projectiles) runs with that guest swapped in.
 use super::{Game, lan::LanHost};
 use horizon_client::{
-    mobs::{Mob, MobEvent, PlayerView, Who},
+    mobs::{Mob, MobEvent, PlayerView, Species, Who},
     projectiles::{Hit, Projectile},
 };
 use horizon_core::geometry::{Aabb, Vec3};
@@ -26,6 +26,19 @@ pub(super) fn player_for(
     guests: &GuestViews,
     bound: Option<u32>,
 ) -> Option<u32> {
+    // A tame wolf or cat sees its owner (`TamableAnimal.getOwner`), while they
+    // are in play, whoever is nearer.
+    if matches!(m.species(), Species::Wolf | Species::Cat)
+        && m.extra.tame
+        && let Some(owner) = m.extra.owner
+    {
+        if host.is_some_and(|v| v.alive && v.uuid == owner) {
+            return None;
+        }
+        if let Some((conn, _)) = guests.iter().find(|(_, v)| v.alive && v.uuid == owner) {
+            return Some(*conn);
+        }
+    }
     let targeting = m.ai.target == Some(Who::Player)
         || m.ai.last_hurt_by == Some(Who::Player) && m.age as i32 - m.ai.last_hurt_by_time <= 100;
     choose(m.position, targeting, host, guests, bound)
diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs
index 1e725df80..85d8a3cd0 100644
--- a/crates/horizon-client/src/mobs/tame.rs
+++ b/crates/horizon-client/src/mobs/tame.rs
@@ -2,7 +2,7 @@
 //! sitting, following and defending the owner, begging, anger and shaking
 //! off water (`Wolf`, `WolfModel`).
 use super::{
-    Damage, Mob, MobEvent, MobWorld, Species, Who,
+    Damage, Mob, MobEvent, MobWorld, PlayerView, Species, Who,
     anim::{Poses, State},
     goals::{
         Breed, Cx, Float, Goal, HurtByTarget, JUMP, LOOK, LeapAtTarget, LookAtPlayer, MOVE,
@@ -124,17 +124,23 @@ pub fn set_tame(m: &mut Mob, tame: bool) {
         m.attrs.max_health = 8.0;
     }
 }
-/// The owner (the local player) when tame.
-fn owner(m: &Mob, w: &MobWorld) -> Option<(Vec3, f64, bool)> {
+/// `TamableAnimal.getOwner`: the player the saved owner UUID names, when it
+/// is the one this mob sees; anyone else nearby is not its owner.
+fn owner_view<'a>(m: &Mob, w: &'a MobWorld) -> Option<&'a PlayerView> {
     if !m.extra.tame {
         return None;
     }
     let p = w.player.as_ref()?;
+    (m.extra.owner == Some(p.uuid)).then_some(p)
+}
+/// The owner's position, eye height and spectator flag when tame.
+fn owner(m: &Mob, w: &MobWorld) -> Option<(Vec3, f64, bool)> {
+    let p = owner_view(m, w)?;
     Some((p.position, p.eye[1], p.spectator))
 }
 /// `TamableAnimal.unableToMoveToOwner`.
 fn unable_to_move_to_owner(m: &Mob, w: &MobWorld) -> bool {
-    m.extra.sitting || w.player.as_ref().is_some_and(|p| p.spectator)
+    m.extra.sitting || owner_view(m, w).is_some_and(|p| p.spectator)
 }
 /// `TamableAnimal.tryToTeleportToOwner`: ten tries around the owner.
 fn teleport_to_owner(m: &mut Mob, w: &MobWorld) {
@@ -240,7 +246,7 @@ impl Goal for SitWhenOrdered {
         match owner_distance_sqr(m, cx.w) {
             None => true,
             Some(d) => {
-                let attacked = cx.w.player.as_ref().is_some_and(|p| p.hurt_by.is_some());
+                let attacked = owner_view(m, cx.w).is_some_and(|p| p.hurt_by.is_some());
                 !(d < 144.0 && attacked) && m.extra.sitting
             }
         }
@@ -388,7 +394,7 @@ impl Goal for OwnerHurtBy {
         if !m.extra.tame || m.extra.sitting {
             return false;
         }
-        let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.hurt_by) else {
+        let Some((who, at)) = owner_view(m, cx.w).and_then(|p| p.hurt_by) else {
             return false;
         };
         at != self.timestamp && wants_to_attack(m, cx.w, who)
@@ -399,7 +405,7 @@ impl Goal for OwnerHurtBy {
             .is_some_and(|t| t.alive)
     }
     fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
-        if let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.hurt_by) {
+        if let Some((who, at)) = owner_view(m, cx.w).and_then(|p| p.hurt_by) {
             m.ai.target = Some(who);
             self.timestamp = at;
         }
@@ -422,7 +428,7 @@ impl Goal for OwnerHurt {
         if !m.extra.tame || m.extra.sitting {
             return false;
         }
-        let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.last_hurt) else {
+        let Some((who, at)) = owner_view(m, cx.w).and_then(|p| p.last_hurt) else {
             return false;
         };
         at != self.timestamp && wants_to_attack(m, cx.w, who)
@@ -433,7 +439,7 @@ impl Goal for OwnerHurt {
             .is_some_and(|t| t.alive)
     }
     fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
-        if let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.last_hurt) {
+        if let Some((who, at)) = owner_view(m, cx.w).and_then(|p| p.last_hurt) {
             m.ai.target = Some(who);
             self.timestamp = at;
         }

From 331e3a7202a9f8c667ce46e3d53cba966a55b964 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:49:24 +0100
Subject: [PATCH 295/475] dedicated_server: steps wait for the server's reply,
 not a 1.5 s timer

The parity client's chat, villager and furnace steps went on 1.5 s after
sending, so a busy server's late reply landed in the next step (or a click
carried a stale state id). Each step now waits until the server answered:
its chat line, both slot packets of a shift-click, and the furnace totals
the click changes (up to the same 30 s patience). The respawn window keeps
only the player's own entity packets: a squid's swim event or a mob coming
into view falls into it as each server's ticks fall.

Off the known-flaky list: it passes under 2.5 s server stalls every 5 s,
where main's client fails.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../parity/VanillaProtocolClient.java         | 64 +++++++++++++++++--
 tools/parity_hosts.json                       |  1 -
 2 files changed, 57 insertions(+), 8 deletions(-)

diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaProtocolClient.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaProtocolClient.java
index e37e898a3..fbb8ed2b0 100644
--- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaProtocolClient.java
+++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaProtocolClient.java
@@ -487,6 +487,17 @@ public final class VanillaProtocolClient {
         long deadCommandAt = 0;
         // When the client last sent where it is.
         long positionAt = 0;
+        // Chat lines and furnace slot changes received, and how many there were when the current step sent
+        // its command or click: a step goes on once the server answered, not after a fixed time (a busy
+        // server answers seconds late, and a click sent before the last one's reply carries a stale state id).
+        int replies = 0;
+        int repliesBefore = 0;
+        // A shift-click changes two slots, each its own packet, which a busy server can send ticks apart: a furnace
+        // step waits for both. A full resend of the menu counts as both.
+        int furnaceReplies = 0;
+        int furnaceBefore = 0;
+        // The furnace's lit and cooking totals received: the server sends them a tick after what changed them.
+        int furnaceData = 0;
         while (System.currentTimeMillis() < deadline) {
             Received r;
             try {
@@ -501,7 +512,7 @@ public final class VanillaProtocolClient {
                 if (entities != null && !entities.acceptSelf(packet) && step >= ENTITIES) entities.accept(packet);
                 if (r.type.equals("minecraft:chunk_batch_start")) ordered = false;
                 if (respawning && !respawned) {
-                    String line = respawnLine(r);
+                    String line = respawnLine(r, playerId);
                     // PlayerList.respawn ends with initInventoryMenu: what follows is the
                     // next ticks' (health, entity data, chunks), in each server's own order.
                     respawned = r.type.equals("minecraft:container_set_content") && respawnAt != null;
@@ -558,15 +569,18 @@ public final class VanillaProtocolClient {
                 } else if (packet instanceof net.minecraft.network.protocol.game.ClientboundContainerSetContentPacket p
                     && furnaceWindow > 0 && p.containerId() == furnaceWindow) {
                     furnaceState = p.stateId();
+                    furnaceReplies += 2;
                     record("play-furnace", "content " + p.items() + " carried " + p.carriedItem());
                 } else if (packet instanceof net.minecraft.network.protocol.game.ClientboundContainerSetSlotPacket p
                     && furnaceWindow > 0 && p.getContainerId() == furnaceWindow) {
                     furnaceState = p.getStateId();
+                    furnaceReplies++;
                     record("play-furnace", "slot " + p.getSlot() + " " + p.getItem());
                     if (p.getSlot() == 2 && !p.getItem().isEmpty() && smeltedAt == 0) smeltedAt = now;
                 } else if (packet instanceof net.minecraft.network.protocol.game.ClientboundContainerSetDataPacket p
                     && furnaceWindow > 0 && p.getContainerId() == furnaceWindow && (p.getId() == 1 || p.getId() == 3)) {
                     // Lit total and cooking total; the time left and the cooking timer follow the ticks.
+                    furnaceData++;
                     record("play-furnace", "data " + p.getId() + " " + p.getValue());
                 } else if (packet instanceof net.minecraft.network.protocol.game.ClientboundEntityEventPacket p
                     && step == 5 + REPLIES.length && (int) (byte) field(p, "eventId") == 28) {
@@ -583,13 +597,16 @@ public final class VanillaProtocolClient {
                     record("play-death", "command reply " + json(p.content()));
                     respawning = respawn();
                 } else if (packet instanceof ClientboundSystemChatPacket p && step > 0 && step < 5 + REPLIES.length) {
+                    replies++;
                     record("play-chat", "system " + p.overlay() + " " + json(p.content()));
                 } else if (packet instanceof ClientboundPlayerChatPacket p && step > 0 && step < 5 + REPLIES.length) {
+                    replies++;
                     record("play-chat", "player " + p.sender() + " " + p.index() + " " + p.body().content() + " " + p.signature().isPresent()
                         + " " + p.unsignedContent().map(VanillaProtocolClient::json) + " " + text(p.filterMask()) + " "
                         + p.chatType().chatType().getRegisteredName() + " " + json(p.chatType().name()) + " "
                         + p.chatType().targetName().map(VanillaProtocolClient::json));
                 } else if (packet instanceof ClientboundDisguisedChatPacket p && step > 0 && step < 5 + REPLIES.length) {
+                    replies++;
                     record("play-chat", "disguised " + json(p.message()) + " " + p.chatType().chatType().getRegisteredName());
                 } else if (packet instanceof net.minecraft.network.protocol.game.ClientboundAddEntityPacket p
                     && p.getType() == net.minecraft.world.entity.EntityTypes.SNOWBALL) {
@@ -679,20 +696,24 @@ public final class VanillaProtocolClient {
                 record("play-light-layers", inner.size() + " " + inner);
                 step = 1;
                 stepAt = now;
+                repliesBefore = replies;
                 send(new ServerboundChatPacket("hello from the parity client", Instant.now(), 0L, Optional.empty(),
                     new LastSeenMessages.Update(0, new BitSet(), (byte) 0)));
-            } else if (step == 1 && now - stepAt > 1500) {
+            } else if (step == 1 && answered(replies, repliesBefore, stepAt, now)) {
                 step = 2;
                 stepAt = now;
+                repliesBefore = replies;
                 send(new ServerboundChatCommandPacket("list"));
-            } else if (step >= 2 && step < 2 + REPLIES.length && now - stepAt > 1500) {
+            } else if (step >= 2 && step < 2 + REPLIES.length && answered(replies, repliesBefore, stepAt, now)) {
                 // Commands a player without operator rights may run, whose
                 // replies (a failure, a syntax error with its context, a
                 // failure with an argument) are compared component by component.
                 send(new ServerboundChatCommandPacket(REPLIES[step - 2]));
                 step++;
                 stepAt = now;
-            } else if (step == 2 + REPLIES.length && now - stepAt > 1500 && (villager >= 0 || now - stepAt > PATIENCE)) {
+                repliesBefore = replies;
+            } else if (step == 2 + REPLIES.length && answered(replies, repliesBefore, stepAt, now)
+                && (villager >= 0 || now - stepAt > PATIENCE)) {
                 // Right-click the villager (once the server sent it): the trading screen and its offers.
                 record("play-trade", "villager " + (villager >= 0));
                 if (villager >= 0) {
@@ -739,9 +760,13 @@ public final class VanillaProtocolClient {
                 send(new net.minecraft.network.protocol.game.ServerboundUseItemOnPacket(net.minecraft.world.InteractionHand.MAIN_HAND,
                     new net.minecraft.world.phys.BlockHitResult(net.minecraft.world.phys.Vec3.atCenterOf(furnace),
                         net.minecraft.core.Direction.NORTH, furnace, false), 1));
+                furnaceBefore = furnaceReplies;
                 step++;
                 stepAt = now;
-            } else if (step >= 8 + REPLIES.length && step <= 10 + REPLIES.length && furnaceWindow > 0 && now - stepAt > 1500
+            } else if (step >= 8 + REPLIES.length && step <= 10 + REPLIES.length && furnaceWindow > 0
+                && answered(furnaceReplies, furnaceBefore + 1, stepAt, now)
+                // Both totals with the window, then the cooking total the ore set, then the lit total the coal set.
+                && (furnaceData >= step - 6 - REPLIES.length || now - stepAt > PATIENCE)
                 // The ingot out once the furnace made it (200 ticks), and its tick's other changes came.
                 && (step < 10 + REPLIES.length || smeltedAt > 0 && now - smeltedAt > 1000 || now - stepAt > 10_000 + PATIENCE)) {
                 // Shift-click the ore (hotbar 0) into the input, the coal (hotbar 1) into the
@@ -752,9 +777,10 @@ public final class VanillaProtocolClient {
                 send(new net.minecraft.network.protocol.game.ServerboundContainerClickPacket(furnaceWindow, furnaceState, (short) slot,
                     (byte) 0, net.minecraft.world.inventory.ContainerInput.QUICK_MOVE,
                     new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>(), net.minecraft.network.HashedStack.EMPTY));
+                furnaceBefore = furnaceReplies;
                 step++;
                 stepAt = now;
-            } else if (step == 11 + REPLIES.length && now - stepAt > 1500) {
+            } else if (step == 11 + REPLIES.length && answered(furnaceReplies, furnaceBefore + 1, stepAt, now)) {
                 send(new net.minecraft.network.protocol.game.ServerboundContainerClosePacket(furnaceWindow));
                 record("play-furnace", "closed");
                 step++;
@@ -816,6 +842,11 @@ public final class VanillaProtocolClient {
         record("error", "timed out in play, step " + step + ", chunks " + chunks.size());
     }
 
+    /** The server answered the step's command or click (at least 1.5 s after it, as before), or had all the time. */
+    private static boolean answered(int count, int before, long sent, long now) {
+        return now - sent > 1500 && (count > before || now - sent > PATIENCE);
+    }
+
     /**
      * A right click's snowballs are counted: once the first came and a second could have come with it
      * (the server spawns each in the tick it handles the click), or once the server had all the time.
@@ -857,8 +888,12 @@ public final class VanillaProtocolClient {
      * packets (time, keep-alive, chunk data and light, whose batching follows each server's
      * timing) left out; null to skip it.
      */
-    private String respawnLine(Received r) {
+    private String respawnLine(Received r, int playerId) {
         String t = r.type;
+        // Other entities (a squid's swim event, a mob coming into view) land in the window as each server's
+        // ticks fall: only the player's own are PlayerList.respawn's.
+        Integer entity = entityOf(r.packet);
+        if (entity != null && entity != playerId) return null;
         // Entities moving, blocks the world's ticks change (a lava fall flows again once the game
         // runs) and the dead player's health land in the window between the death and the respawn
         // as each server's ticks fall: left out.
@@ -891,6 +926,21 @@ public final class VanillaProtocolClient {
         return t;
     }
 
+    /** The entity a packet is about, for the packets that name one; null for the rest. */
+    private static Integer entityOf(Packet<?> packet) {
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundAddEntityPacket p) return p.getId();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundUpdateAttributesPacket p) return p.getEntityId();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundEntityEventPacket p) return (int) field(p, "entityId");
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket p) return p.getEntity();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundAnimatePacket p) return p.getId();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundHurtAnimationPacket p) return p.id();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundDamageEventPacket p) return p.entityId();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundUpdateMobEffectPacket p) return p.getEntityId();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundRemoveMobEffectPacket p) return p.entityId();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundSoundEntityPacket p) return p.getId();
+        return null;
+    }
+
     /**
      * A chunk's blocks, biomes, heightmaps and block entities (its
      * ClientboundLevelChunkPacketData bytes). The light is left out: both servers relight around chunks
diff --git a/tools/parity_hosts.json b/tools/parity_hosts.json
index 42b9a46fd..29027f87f 100644
--- a/tools/parity_hosts.json
+++ b/tools/parity_hosts.json
@@ -44,7 +44,6 @@
   "lan_integration": "the whole lan_e2e suite: ~40 min a run on a loaded runner, and single checks flake under load; run it by name, or tools/lan_e2e.py"
  },
  "known_flaky": {
-  "dedicated_server": "its Java client moves to the next step on a 1.5 s timer, not on the server's reply: under load a respawn's add_entity/update_attributes or entity_event 19 lands in the wrong step (failed, then passed at the same head, 10-26)",
   "remote_fireball": "samples the fireball on the wall clock, so a slow host sees it in too few samples (desktop runner, 3 times on 10-26)",
   "world_reopen": "counted 4 minecarts instead of 3 once on a loaded Mac mini runner, then passed at the same head (10-26)"
  }

From 1258c2473b806540ea3fb31496af859e0958f1f0 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:54:53 +0100
Subject: [PATCH 296/475] Multiply the particle speed and delta as floats, as
 handleParticleEvent does

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/commands/world_cmds.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs
index d58b477b0..90abc5e71 100644
--- a/crates/horizon-client/src/game/commands/world_cmds.rs
+++ b/crates/horizon-client/src/game/commands/world_cmds.rs
@@ -606,10 +606,9 @@ impl Game<'_> {
         if !local {
         } else if count <= 0 {
             // handleParticleEvent, count 0: one particle, the speed times
-            // the delta as velocity (both sent as floats).
-            let speed = f64::from(speed);
+            // the delta as velocity (both sent as floats, multiplied as floats).
             self.particles
-                .create(&options, pos, delta.map(|d| speed * f64::from(d as f32)));
+                .create(&options, pos, delta.map(|d| f64::from(speed * d as f32)));
         } else {
             for _ in 0..count {
                 let r = self.particles.random();

From c4d0cb1ec0c686b4efba990964055795af0f2576 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:55:51 +0100
Subject: [PATCH 297/475] A small armor stand's eyes are at 0.9875, and eye
 heights are floats

ArmorStand.BABY_DIMENSIONS keeps its own eye height rather than half the
type's, and EntityDimensions.eyeHeight is a float widened by getEyeY.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/game/commands/execute.rs              | 24 +++++++++----------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/crates/horizon-client/src/game/commands/execute.rs b/crates/horizon-client/src/game/commands/execute.rs
index c48cd8adf..d715ce0ab 100644
--- a/crates/horizon-client/src/game/commands/execute.rs
+++ b/crates/horizon-client/src/game/commands/execute.rs
@@ -145,23 +145,19 @@ impl Game<'_> {
                 .iter()
                 .find(|m| m.id == id)
                 .map_or(0.0, |m| m.eye_y() - m.position.y),
-            // An armor stand's dimensions are halved when small and empty
-            // when a marker (ArmorStand.getDefaultDimensions).
-            Target::Stand(id) => {
-                let stand = self.armor_stands.iter().find(|a| a.id == id);
-                let scale = match stand {
-                    Some(a) if a.marker => 0.0,
-                    Some(a) if a.small => 0.5,
-                    _ => 1.0,
-                };
-                scale * self.type_eye_height(&self.target_type(t))
-            }
+            // ArmorStand.getDefaultDimensions: a marker's are empty, a small
+            // stand's are BABY_DIMENSIONS, whose eye height is 0.9875F.
+            Target::Stand(id) => match self.armor_stands.iter().find(|a| a.id == id) {
+                Some(a) if a.marker => 0.0,
+                Some(a) if a.small => f64::from(0.9875f32),
+                _ => self.type_eye_height(&self.target_type(t)),
+            },
             // Entity.getEyeHeight: the type's dimensions.
             _ => self.type_eye_height(&self.target_type(t)),
         }
     }
     /// `EntityType.getDimensions().eyeHeight()` from `entity-types.json`,
-    /// read once.
+    /// read once: a float, widened as `Entity.getEyeY` does.
     fn type_eye_height(&self, ty: &str) -> f64 {
         static EYE_HEIGHTS: std::sync::OnceLock<std::collections::HashMap<String, f64>> =
             std::sync::OnceLock::new();
@@ -173,7 +169,9 @@ impl Game<'_> {
                     .and_then(|v| {
                         v.as_object().map(|o| {
                             o.iter()
-                                .filter_map(|(k, t)| Some((k.clone(), t["eye_height"].as_f64()?)))
+                                .filter_map(|(k, t)| {
+                                    Some((k.clone(), f64::from(t["eye_height"].as_f64()? as f32)))
+                                })
                                 .collect()
                         })
                     })

From b90f9ec1efc6ed34d815ad8652c5accab5600c73 Mon Sep 17 00:00:00 2001
From: Carlos Nunez <carlosnunez01010@gmail.com>
Date: Mon, 26 Oct 2026 16:57:07 -0400
Subject: [PATCH 298/475] Make an End gateway's block entity the source of its
 exit

The side file kept an entry for a gateway after Horizon created its exit,
so removing the exit with /data remove block ... exit_portal, or placing
a different gateway there, sent the player to the old exit again.

Once the gateway's chunk is loaded, gateway_job moves an entry the side
file still holds into the block entity (unless the block entity has an
exit of its own) and drops the entry. set_gateway_exit writes only the
block entity when the chunk is loaded, and leaves an entry in the side
file only when the chunk is already unloaded.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/end.rs | 97 +++++++++++++++++++++------
 1 file changed, 78 insertions(+), 19 deletions(-)

diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs
index e8b9a96e3..687ba6bb4 100644
--- a/crates/horizon-client/src/game/end.rs
+++ b/crates/horizon-client/src/game/end.rs
@@ -5,7 +5,7 @@
 use super::{Dim, Game};
 use horizon_client::{
     Result,
-    containers::BlockEntity,
+    containers::{BlockEntity, EndGateway},
     environment::Environment,
     items::ItemStack,
     mesher::Vertex,
@@ -69,6 +69,17 @@ fn exact_teleport(entity: Option<&BlockEntity>) -> bool {
     matches!(entity, Some(BlockEntity::EndGateway(g)) if g.exact_teleport)
 }
 
+/// Moves an exit that only the side file knew into the gateway's block entity, unless the block
+/// entity has its own; true when it took the saved one.
+fn adopt_saved_exit(entity: &mut EndGateway, (exit, exact): ([i32; 3], bool)) -> bool {
+    if entity.exit_portal.is_some() {
+        return false;
+    }
+    entity.exit_portal = Some(exit);
+    entity.exact_teleport = exact;
+    true
+}
+
 /// The end of `getPortalPosition`: the exit itself when the teleport is exact,
 /// else the spot [`Game::resolve_gateway`] finds around it (`findExitPosition`).
 fn exit_target(exit: [i32; 3], exact: bool, find: impl FnOnce([i32; 3]) -> [i32; 3]) -> [i32; 3] {
@@ -820,23 +831,7 @@ impl Game<'_> {
         self.end.exits.as_mut().expect("loaded exits")
     }
 
-    fn set_gateway_exit(&mut self, gateway: [i32; 3], exit: [i32; 3], exact: bool) -> Result<()> {
-        // TheEndGatewayBlockEntity.setExitPosition (also EndGatewayFeature.knownExit).
-        let key = (gateway[0], gateway[1], gateway[2]);
-        let chunk = (gateway[0] >> 4, gateway[2] >> 4);
-        // The gateway's chunk can be unloaded by now (travel waits for the destination): the
-        // side map below still records the exit.
-        if self.world.chunks.contains_key(&chunk)
-            && let BlockEntity::EndGateway(g) = self
-                .world
-                .block_entities
-                .get_or_insert_with(key, || BlockEntity::EndGateway(Default::default()))
-        {
-            g.exit_portal = Some(exit);
-            g.exact_teleport = exact;
-            self.world.modified.insert(chunk);
-        }
-        self.gateway_exits().insert(gateway, (exit, exact));
+    fn save_gateway_exits(&mut self) -> Result<()> {
         let list: Vec<_> = self
             .gateway_exits()
             .iter()
@@ -848,6 +843,35 @@ impl Game<'_> {
         Ok(())
     }
 
+    /// Drops a gateway's entry from the side file: its block entity is the source of truth.
+    fn forget_gateway_exit(&mut self, gateway: [i32; 3]) -> Result<()> {
+        if self.gateway_exits().remove(&gateway).is_some() {
+            self.save_gateway_exits()?;
+        }
+        Ok(())
+    }
+
+    fn set_gateway_exit(&mut self, gateway: [i32; 3], exit: [i32; 3], exact: bool) -> Result<()> {
+        // TheEndGatewayBlockEntity.setExitPosition (also EndGatewayFeature.knownExit).
+        let key = (gateway[0], gateway[1], gateway[2]);
+        let chunk = (gateway[0] >> 4, gateway[2] >> 4);
+        // The gateway's chunk can be unloaded by now (travel waits for the destination): the
+        // exit then waits in the side file until the gateway is used again (`gateway_job`).
+        if self.world.chunks.contains_key(&chunk)
+            && let BlockEntity::EndGateway(g) = self
+                .world
+                .block_entities
+                .get_or_insert_with(key, || BlockEntity::EndGateway(Default::default()))
+        {
+            g.exit_portal = Some(exit);
+            g.exact_teleport = exact;
+            self.world.modified.insert(chunk);
+            return self.forget_gateway_exit(gateway);
+        }
+        self.gateway_exits().insert(gateway, (exit, exact));
+        self.save_gateway_exits()
+    }
+
     /// EndGatewayBlock.entityInside and TheEndGatewayBlockEntity.getPortalPosition:
     /// travel within the End, waiting for the destination chunks to load.
     fn enter_gateway(&mut self, gateway: [i32; 3]) -> Result<()> {
@@ -867,7 +891,25 @@ impl Game<'_> {
     /// its exit, or the search for one, and the spot to load before either
     /// is resolved ([`Game::resolve_gateway`]).
     pub(super) fn gateway_job(&mut self, gateway: [i32; 3]) -> (GatewayJob, Vec3) {
-        let known = self.gateway_exits().get(&gateway).copied();
+        let mut known = self.gateway_exits().get(&gateway).copied();
+        // Once the gateway's chunk is loaded its block entity is the source of truth: an exit the
+        // side file kept for it moves there, and the entry is dropped, so removing or replacing
+        // the exit (`/data remove block`) is not undone by an old entry.
+        let key = (gateway[0], gateway[1], gateway[2]);
+        let chunk = (gateway[0] >> 4, gateway[2] >> 4);
+        if let Some(saved) = known
+            && self.world.chunks.contains_key(&chunk)
+            && let BlockEntity::EndGateway(g) = self
+                .world
+                .block_entities
+                .get_or_insert_with(key, || BlockEntity::EndGateway(Default::default()))
+        {
+            if adopt_saved_exit(g, saved) {
+                self.world.modified.insert(chunk);
+            }
+            known = None;
+            let _ = self.forget_gateway_exit(gateway);
+        }
         let job = GatewayJob::for_gateway(
             gateway,
             self.world
@@ -1308,6 +1350,23 @@ mod tests {
     use super::*;
     use horizon_client::containers::EndGateway;
 
+    #[test]
+    fn a_saved_exit_moves_into_a_gateway_without_one() {
+        let saved = ([8, 100, 0], true);
+        let mut bare = EndGateway::default();
+        assert!(adopt_saved_exit(&mut bare, saved));
+        assert_eq!(bare.exit_portal, Some([8, 100, 0]));
+        assert!(bare.exact_teleport);
+        // The block entity's own exit wins over a stale entry.
+        let mut own = EndGateway {
+            exit_portal: Some([1, 2, 3]),
+            ..Default::default()
+        };
+        assert!(!adopt_saved_exit(&mut own, saved));
+        assert_eq!(own.exit_portal, Some([1, 2, 3]));
+        assert!(!own.exact_teleport);
+    }
+
     #[test]
     fn a_new_exit_keeps_the_gateways_exact_teleport() {
         let exact = BlockEntity::EndGateway(EndGateway {

From 83b544f04fe5f89d4835b59daa41f2bc4b1967d8 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:57:31 +0100
Subject: [PATCH 299/475] Bonus chest: draw from the level random and set
 blocks with UPDATE_CLIENTS

MinecraftServer.setInitialSpawn passes level.getRandom() to
BonusChestFeature.place, which sets the chest and torches with flags 2.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../horizon-client/src/game/initial_spawn.rs  | 26 ++++++++++++++-----
 1 file changed, 20 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/game/initial_spawn.rs b/crates/horizon-client/src/game/initial_spawn.rs
index bbd0a766c..68e754dfc 100644
--- a/crates/horizon-client/src/game/initial_spawn.rs
+++ b/crates/horizon-client/src/game/initial_spawn.rs
@@ -20,7 +20,8 @@ use horizon_core::{
 };
 use horizon_world::{
     block_collision::BlockCollisionRegistry, collision_context::CollisionContext,
-    heightmap::HeightmapType, worldgen::terrain::TerrainBlockStates,
+    heightmap::HeightmapType, level::flags::UPDATE_CLIENTS, registry::BlockStateId,
+    worldgen::terrain::TerrainBlockStates,
 };
 
 /// The loaded world as the spawn searches query it.
@@ -138,8 +139,8 @@ impl Game<'_> {
         if !self.streaming.is_lit(cx, cz) {
             return Ok(());
         }
-        let mut random = entity_random();
-        // Util.toShuffledList of the chunk's x and z.
+        // `level.getRandom()`. Util.toShuffledList of the chunk's x and z.
+        let random = &mut self.world.random;
         let mut shuffled = |min: i32| -> [i32; 16] {
             let mut values: [i32; 16] = std::array::from_fn(|i| min + i as i32);
             for end in (2..=16usize).rev() {
@@ -157,8 +158,8 @@ impl Game<'_> {
                 if self.world.block(x, y, z) != self.world.air && !self.collision_empty([x, y, z]) {
                     continue;
                 }
-                self.level_set([x, y, z], chest)?;
-                let seed = random.next_long();
+                self.set_block_clients([x, y, z], chest)?;
+                let seed = self.world.random.next_long();
                 self.world
                     .block_entities
                     .insert((x, y, z), BlockEntity::Chest(Vec::new()));
@@ -174,7 +175,7 @@ impl Game<'_> {
                         b.can_survive(level, ticks, BlockPos::new(at[0], at[1], at[2]), torch)
                     });
                     if survives {
-                        self.level_set(at, torch)?;
+                        self.set_block_clients(at, torch)?;
                     }
                 }
                 return Ok(());
@@ -182,6 +183,19 @@ impl Game<'_> {
         }
         Ok(())
     }
+    /// `Level.setBlock(pos, state, UPDATE_CLIENTS)`: no neighbour updates.
+    fn set_block_clients(&mut self, pos: [i32; 3], state: BlockStateId) -> Result<()> {
+        self.with_level(|b, level, ticks| {
+            b.set_block(
+                level,
+                ticks,
+                BlockPos::new(pos[0], pos[1], pos[2]),
+                state,
+                UPDATE_CLIENTS,
+            );
+        });
+        self.process_level_events()
+    }
     /// The block at `pos` has no collision shape.
     fn collision_empty(&self, pos: [i32; 3]) -> bool {
         let mut scene = SceneCollisions {

From 462787aee13d6fc6c7c9c7d50ceaac8e993fe7a9 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 21:58:25 +0100
Subject: [PATCH 300/475] Keep the Infested event when a mob is hit by a player
 or another mob

---
 crates/horizon-client/src/game.rs           | 15 +++++--
 crates/horizon-client/src/game/creatures.rs | 46 +++++++++++++--------
 2 files changed, 40 insertions(+), 21 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 1d86fe990..f42765de8 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -7674,12 +7674,21 @@ impl Game<'_> {
             // The hurt or death sound the mob raised (getHurtSound / getDeathSound,
             // its voice pitch from its own random).
             let queued = std::mem::take(&mut self.mobs[index].outbox);
+            let mut infested = false;
             for event in queued {
-                if let horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) = event {
-                    self.audio
-                        .play(&format!("minecraft:{s}"), Some(at), volume, pitch);
+                match event {
+                    horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) => {
+                        self.audio
+                            .play(&format!("minecraft:{s}"), Some(at), volume, pitch);
+                    }
+                    horizon_client::mobs::MobEvent::Infested { .. } => infested = true,
+                    _ => {}
                 }
             }
+            if infested {
+                let id = self.mobs[index].id;
+                self.mob_infested(id);
+            }
             self.weapon_hit(index);
         } else {
             self.audio
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index de1cd1bee..f45e7e6a0 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -852,6 +852,18 @@ impl Game<'_> {
             }
         }
     }
+    /// `InfestedMobEffect.onMobHurt` for a mob: silverfish from half its height up.
+    pub(super) fn mob_infested(&mut self, mob: u32) {
+        if let Some(m) = self.mobs.iter().find(|m| m.id == mob) {
+            let at = [
+                m.position.x,
+                m.position.y + f64::from(m.height()) / 2.0,
+                m.position.z,
+            ];
+            let look = m.view_vector();
+            self.infested_hurt(at, look);
+        }
+    }
     pub(super) fn handle_mob_events(&mut self, events: Vec<MobEvent>) -> Result<()> {
         for e in events {
             match e {
@@ -941,6 +953,7 @@ impl Game<'_> {
                 } => {
                     let mut killed = false;
                     let mut hurt = false;
+                    let mut infested = false;
                     if let Some(t) = self.mobs.iter_mut().find(|m| m.id == target) {
                         let hit = t.damage(amount, source);
                         hurt = hit;
@@ -949,17 +962,24 @@ impl Game<'_> {
                             // The hurt or death sound the mob raised.
                             let center = t.center();
                             for event in std::mem::take(&mut t.outbox) {
-                                if let MobEvent::Sound(s, _, volume, pitch) = event {
-                                    self.audio.play(
-                                        &format!("minecraft:{s}"),
-                                        Some(center),
-                                        volume,
-                                        pitch,
-                                    );
+                                match event {
+                                    MobEvent::Sound(s, _, volume, pitch) => {
+                                        self.audio.play(
+                                            &format!("minecraft:{s}"),
+                                            Some(center),
+                                            volume,
+                                            pitch,
+                                        );
+                                    }
+                                    MobEvent::Infested { .. } => infested = true,
+                                    _ => {}
                                 }
                             }
                         }
                     }
+                    if infested {
+                        self.mob_infested(target);
+                    }
                     if hurt
                         && let Some(Who::Mob(attacker)) = source.attacker
                         && let Some(m) = self
@@ -1005,17 +1025,7 @@ impl Game<'_> {
                 }
                 MobEvent::BecomeStatue { mob } => self.golem_become_statue(mob),
                 MobEvent::EnterHive { mob, hive } => self.bee_enter_hive(mob, hive),
-                MobEvent::Infested { mob } => {
-                    if let Some(m) = self.mobs.iter().find(|m| m.id == mob) {
-                        let at = [
-                            m.position.x,
-                            m.position.y + f64::from(m.height()) / 2.0,
-                            m.position.z,
-                        ];
-                        let look = m.view_vector();
-                        self.infested_hurt(at, look);
-                    }
-                }
+                MobEvent::Infested { mob } => self.mob_infested(mob),
                 MobEvent::Gift { target, item } => {
                     if let Some(m) = self.mobs.iter_mut().find(|m| m.id == target)
                         && m.saddle_item().is_none()

From 34f57dbcac49598cb18fc68ae4c1d6421594f6f4 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:59:31 +0100
Subject: [PATCH 301/475] Trident: Impaling through the enchantment's damage
 effect

ThrownTrident.onHitEntity runs EnchantmentHelper.modifyDamage on the
trident, so Impaling adds to the 8 for the entity types in
#sensitive_to_impaling (its minecraft:damage requirement), not for every
mob that swims or breathes water.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/creatures.rs | 46 ++++++++++++++-------
 1 file changed, 30 insertions(+), 16 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index b3618af5c..6ac554d68 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1946,22 +1946,32 @@ impl Game<'_> {
             None => self.projectile_hit(p, hit),
         }
     }
-    /// What an arrow or a thrown trident hits an entity for
-    /// (`AbstractArrow.onHitEntity`, `ThrownTrident.onHitEntity`): a trident's
-    /// 8, plus Impaling on aquatic `victim`s.
-    fn shot_damage(&mut self, shot: &mut Projectile, victim: Option<u32>) -> f32 {
+    /// What an arrow or a thrown trident hits an entity of type `victim`
+    /// for (`AbstractArrow.onHitEntity`, `ThrownTrident.onHitEntity`): a
+    /// trident's 8 through `EnchantmentHelper.modifyDamage` of the trident
+    /// (Impaling's `minecraft:damage` on `#sensitive_to_impaling`).
+    fn shot_damage(&mut self, shot: &mut Projectile, victim: Option<&str>) -> f32 {
         if !matches!(shot.kind, ProjectileKind::Trident) {
             return arrow_damage(shot, &mut self.world.random) + shot.bonus.damage;
         }
-        let impaling = shot
-            .arrow
-            .as_ref()
-            .map_or(0, |a| a.pickup_item.enchantment_level("minecraft:impaling"))
-            as f32;
-        let aquatic = victim
-            .and_then(|id| self.mobs.iter().find(|m| m.id == id))
-            .is_some_and(|m| m.kind.flags.aquatic_swimmer || m.kind.flags.breathes_water);
-        8.0 + if aquatic { 2.5 * impaling } else { 0.0 }
+        let Some(trident) = shot.arrow.as_ref().map(|a| a.pickup_item.clone()) else {
+            return 8.0;
+        };
+        let ctx = horizon_client::enchant::EffectContext {
+            this: victim,
+            attacker: (shot.owner == Some(Who::Player)).then_some("minecraft:player"),
+            direct_attacker: Some("minecraft:trident"),
+            damage_type: Some("minecraft:trident"),
+            items: Some(self.res.items()),
+            ..Default::default()
+        };
+        self.res.stations().enchantments.modify_value(
+            Some(&trident),
+            "minecraft:damage",
+            &ctx,
+            &mut self.world.random,
+            8.0,
+        )
     }
     /// What an arrow's tick asked for: its particles and sounds.
     fn arrow_event(&mut self, at: Vec3, event: horizon_client::arrows::ArrowEvent) {
@@ -2203,10 +2213,14 @@ impl Game<'_> {
             (ProjectileKind::Trident, Hit::Entity { who, .. }) => {
                 let mut trident = p.clone();
                 let victim = match who {
-                    Who::Mob(id) => Some(id),
-                    Who::Player => None,
+                    Who::Mob(id) => self
+                        .mobs
+                        .iter()
+                        .find(|m| m.id == id)
+                        .map(|m| m.kind.id.clone()),
+                    Who::Player => Some("minecraft:player".to_owned()),
                 };
-                let amount = self.shot_damage(&mut trident, victim);
+                let amount = self.shot_damage(&mut trident, victim.as_deref());
                 let hurt = match who {
                     Who::Player => self.mob_hits_player(
                         amount,

From 1fe0f5fcb9690f3dd3886153960ada3a63c6635e Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:59:39 +0100
Subject: [PATCH 302/475] Sound options: Music Frequency starts its own row, as
 in SoundOptionsScreen

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/options_ui.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs
index 50eb50f6f..f599176db 100644
--- a/crates/horizon-client/src/options_ui.rs
+++ b/crates/horizon-client/src/options_ui.rs
@@ -1424,7 +1424,10 @@ impl OptionsUi {
                 let mut rows = vec![Row::Big(Opt::Volume(0))];
                 let others: Vec<Opt> = (1..SOUND_SOURCES.len()).map(Opt::Volume).collect();
                 rows.extend(pairs(&others));
-                rows.extend(pairs(&[Opt::ShowSubtitles, Opt::MusicFrequency]));
+                rows.extend(pairs(&[Opt::ShowSubtitles]));
+                // SoundOptionsScreen: Music Frequency starts the next row (with
+                // Music Toast, not in Horizon yet).
+                rows.extend(pairs(&[Opt::MusicFrequency]));
                 rows
             }
             Page::Controls => {

From 53ea3e7224480c6e72c73a7fd4404bd0cde04fb1 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:00:04 +0100
Subject: [PATCH 303/475] Play the rain sound for this client only

---
 crates/horizon-client/src/game/render_tick.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs
index 2356fbffe..10404c0ba 100644
--- a/crates/horizon-client/src/game/render_tick.rs
+++ b/crates/horizon-client/src/game/render_tick.rs
@@ -354,7 +354,9 @@ impl Game<'_> {
                             ("minecraft:weather.rain", 0.2, 1.0)
                         };
                         let p = at.map(|c| f64::from(c) + 0.5);
-                        self.audio.play(name, Some(p), volume, pitch);
+                        // playLocalSound: guests make their own rain, so a host
+                        // must not capture it for them.
+                        self.audio.play_unshared(name, Some(p), volume, pitch);
                     }
                 }
             }

From 1b0937abff5f0bbca3f00655164bd948845012fa Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 22:00:05 +0100
Subject: [PATCH 304/475] Piglin celebration: the dance roll and wasHurtBy as
 in PiglinAi

wantsToDance draws from RandomSource.createThreadLocalInstance(gameTime),
not the piglin's random, and wasHurtBy ignores another piglin's hit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/mobs/piglin.rs | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs
index 028fa0386..5477ddb05 100644
--- a/crates/horizon-client/src/mobs/piglin.rs
+++ b/crates/horizon-client/src/mobs/piglin.rs
@@ -10,7 +10,7 @@ use super::{
     },
 };
 use horizon_core::geometry::{Vec3, trig::Mth};
-use horizon_core::random::RandomSource;
+use horizon_core::random::{LegacyRandom, RandomSource};
 use std::f32::consts::PI;
 
 /// `PiglinAi.ADMIRE_DURATION`.
@@ -351,11 +351,18 @@ pub fn celebrate(m: &mut Mob, w: &MobWorld) {
             m.extra.home = None;
         }
     }
-    if m.ai.last_hurt_by.is_some() && m.ai.last_hurt_by_time != m.extra.scratch[2] {
+    if let Some(by) = m.ai.last_hurt_by
+        && m.ai.last_hurt_by_time != m.extra.scratch[2]
+    {
         m.extra.scratch[2] = m.ai.last_hurt_by_time;
-        m.extra.scratch[0] = 0;
-        m.extra.scratch[1] = 0;
-        m.extra.home = None;
+        // PiglinAi.wasHurtBy: another piglin's hit ends nothing.
+        let piglin =
+            matches!(by, Who::Mob(id) if w.seen(id).is_some_and(|s| s.species == Species::Piglin));
+        if !piglin {
+            m.extra.scratch[0] = 0;
+            m.extra.scratch[1] = 0;
+            m.extra.home = None;
+        }
     }
     if m.extra.scratch[1] > 0 {
         return;
@@ -366,7 +373,9 @@ pub fn celebrate(m: &mut Mob, w: &MobWorld) {
     };
     let hoglin =
         matches!(target, Who::Mob(id) if w.seen(id).is_some_and(|s| s.species == Species::Hoglin));
-    if hoglin && m.random.next_float() < 0.1 {
+    // PiglinAi.wantsToDance: a fresh random seeded with the game time, not
+    // the piglin's own.
+    if hoglin && LegacyRandom::new(w.game_time).next_float() < 0.1 {
         m.extra.scratch[0] = 1;
     }
     m.extra.scratch[1] = CELEBRATION;

From 6120c8c0ad40618ec4636041d995ca0842f17ef0 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:03:17 +0100
Subject: [PATCH 305/475] Attack the block when a guest's START_DESTROY_BLOCK
 arrives

---
 crates/horizon-client/src/game/lan_actions.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 0ad14bbcc..bc23314d0 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -921,6 +921,20 @@ impl Game<'_> {
                     // The pause between two blocks is the client's (MultiPlayerGameMode's
                     // destroyDelay); the server digs from the START it receives.
                     play.destroy_delay = 0;
+                    // ServerPlayerGameMode.handleBlockBreakAction: a survival START
+                    // attacks the block at once, so a tap released in the same tick
+                    // still plays a note. The dig is marked begun for tick_mining.
+                    let pos = a.pos;
+                    self.as_guest(host, conn, |g| {
+                        if g.may_build() && !g.creative {
+                            let _ = g.attack_block(pos);
+                            g.mining = Some(Mining {
+                                pos,
+                                progress: 0.0,
+                                ticks: 0,
+                            });
+                        }
+                    });
                 }
                 1 => {}
                 3 => {

From 2929bb6dbabbcd337753febc0c69d0055c5c08f4 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 22:00:23 +0100
Subject: [PATCH 306/475] open_url: accept the http and https schemes in any
 case

Util.parseAndValidateUntrustedUri lowercases the scheme before checking it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/component.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/component.rs b/crates/horizon-client/src/component.rs
index cfb15bf0d..64d79f274 100644
--- a/crates/horizon-client/src/component.rs
+++ b/crates/horizon-client/src/component.rs
@@ -173,9 +173,14 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
     if let Some(e) = o.get("click_event").and_then(Value::as_object) {
         let text = |k: &str| e.get(k).and_then(Value::as_str).map(str::to_owned);
         style.click = match e.get("action").and_then(Value::as_str) {
-            // ClickEvent.OpenUrl.CODEC: ExtraCodecs.UNTRUSTED_URI allows http and https only.
+            // ClickEvent.OpenUrl.CODEC: ExtraCodecs.UNTRUSTED_URI allows http and
+            // https only, the scheme in any case (Util.parseAndValidateUntrustedUri).
             Some("open_url") => text("url")
-                .filter(|u| u.starts_with("http://") || u.starts_with("https://"))
+                .filter(|u| {
+                    u.split_once(':').is_some_and(|(scheme, _)| {
+                        scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https")
+                    })
+                })
                 .map(crate::text::ClickEvent::OpenUrl),
             // ClickEvent.ChangePage.CODEC: ExtraCodecs.POSITIVE_INT.
             Some("change_page") => e

From 3f0e70882c8f6be6aa73c8700e70d9eb98457acc Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:58:14 +0100
Subject: [PATCH 307/475] Death messages: no fallback for a message with no
 entity behind it

DamageSource.getLocalizedDeathMessage sends the one-argument message, and
TranslatableContents.decompose shows a template it cannot fill as written.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/combat.rs | 19 ++++---------------
 1 file changed, 4 insertions(+), 15 deletions(-)

diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs
index 22d5c7d8f..2d6b75902 100644
--- a/crates/horizon-client/src/game/combat.rs
+++ b/crates/horizon-client/src/game/combat.rs
@@ -1,7 +1,7 @@
 //! The player's `CombatTracker`: the damage taken lately, who dealt it and
 //! where the player fell from, turned into the vanilla death message.
 use super::{Game, chat::PLAYER_NAME};
-use horizon_client::{health::HealthEvent, lang, motion::MotionEvent, text::Text};
+use horizon_client::{health::HealthEvent, motion::MotionEvent, text::Text};
 
 struct Entry {
     damage_type: String,
@@ -287,19 +287,8 @@ impl Game<'_> {
         {
             return Text::translate(&format!("{key}.player"), &[me, name.clone()]);
         }
-        killerless_message(&key, me)
+        // No entity at all: the one-argument message, as vanilla sends it (a
+        // template that names a killer then shows as written).
+        Text::translate(&key, &[me])
     }
 }
-/// A death message with no entity behind it. One that names a second actor
-/// (`%2$s`) has nobody to name here, so it falls back to its plain sibling
-/// (`indirectMagic` to `magic`, anything else to `generic`) instead of
-/// showing the raw template.
-fn killerless_message(key: &str, me: Text) -> Text {
-    if key == "death.attack.indirectMagic" {
-        return Text::translate("death.attack.magic", &[me]);
-    }
-    if lang::get(key).contains("%2$s") {
-        return Text::translate("death.attack.generic", &[me]);
-    }
-    Text::translate(key, &[me])
-}

From ed9fdb5208fbf2e0fadf1722a376746350827741 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:04:40 +0100
Subject: [PATCH 308/475] Point an explosion's hurt tilt at the blast

---
 crates/horizon-client/src/game/explosion.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs
index 6ecba3a54..789eb5442 100644
--- a/crates/horizon-client/src/game/explosion.rs
+++ b/crates/horizon-client/src/game/explosion.rs
@@ -305,6 +305,12 @@ impl Game<'_> {
                 )
             {
                 outcome = o;
+                // dealDefaultKnockback's `indicateDamage` points at the blast
+                // (the source position), not the no-direction fallback.
+                if o.knockback && o.blocked <= 0.0 {
+                    p.health
+                        .indicate_damage(center[0] - feet[0], center[2] - feet[2], p.yaw);
+                }
             }
             if !spectator && !(creative && flying) {
                 p.velocity = Vec3::new(

From d2a8cf3bdfffbca0f77f897db5a03fa2b13ced1a Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:05:02 +0100
Subject: [PATCH 309/475] Keep a hurt pet's attacker as its player instead of
 swapping in the owner

---
 crates/horizon-client/src/game/lan_mobs.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs
index f0e7cb4f9..75b56ae7b 100644
--- a/crates/horizon-client/src/game/lan_mobs.rs
+++ b/crates/horizon-client/src/game/lan_mobs.rs
@@ -26,9 +26,14 @@ pub(super) fn player_for(
     guests: &GuestViews,
     bound: Option<u32>,
 ) -> Option<u32> {
+    let targeting = m.ai.target == Some(Who::Player)
+        || m.ai.last_hurt_by == Some(Who::Player) && m.age as i32 - m.ai.last_hurt_by_time <= 100;
     // A tame wolf or cat sees its owner (`TamableAnimal.getOwner`), while they
-    // are in play, whoever is nearer.
-    if matches!(m.species(), Species::Wolf | Species::Cat)
+    // are in play, whoever is nearer. Not while it targets or was just hurt by
+    // a player: then `Who::Player` is that attacker, whoever it is, and the
+    // owner goals ignore it until the wolf lets go.
+    if !targeting
+        && matches!(m.species(), Species::Wolf | Species::Cat)
         && m.extra.tame
         && let Some(owner) = m.extra.owner
     {
@@ -39,8 +44,6 @@ pub(super) fn player_for(
             return Some(*conn);
         }
     }
-    let targeting = m.ai.target == Some(Who::Player)
-        || m.ai.last_hurt_by == Some(Who::Player) && m.age as i32 - m.ai.last_hurt_by_time <= 100;
     choose(m.position, targeting, host, guests, bound)
 }
 

From 6977659843800ded64f86b48ad744b9e0c940eb8 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:06:50 +0100
Subject: [PATCH 310/475] Open the command block screen on a server's client
 and send its edits

---
 crates/horizon-client/src/command_block.rs    | 17 ++++
 .../horizon-client/src/game/command_blocks.rs | 83 ++++++++++++++++++-
 crates/horizon-client/src/game/lan_actions.rs |  1 +
 crates/horizon-client/src/game/remote.rs      |  1 +
 crates/horizon-protocol/src/packets/play.rs   |  7 ++
 5 files changed, 106 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/command_block.rs b/crates/horizon-client/src/command_block.rs
index 942e11ab6..47f808932 100644
--- a/crates/horizon-client/src/command_block.rs
+++ b/crates/horizon-client/src/command_block.rs
@@ -35,6 +35,23 @@ impl Mode {
             Self::Redstone => "minecraft:command_block",
         }
     }
+    /// `Enum.ordinal`, which `ServerboundSetCommandBlockPacket` writes.
+    pub fn ordinal(self) -> i32 {
+        match self {
+            Self::Sequence => 0,
+            Self::Auto => 1,
+            Self::Redstone => 2,
+        }
+    }
+    /// The mode of a packet's ordinal; `handleSetCommandBlock` treats any
+    /// other value as a plain command block (its `default` branch).
+    pub fn from_ordinal(ordinal: i32) -> Self {
+        match ordinal {
+            0 => Self::Sequence,
+            1 => Self::Auto,
+            _ => Self::Redstone,
+        }
+    }
     /// `CycleButton`: the next value, wrapping round.
     pub fn next(self) -> Self {
         match self {
diff --git a/crates/horizon-client/src/game/command_blocks.rs b/crates/horizon-client/src/game/command_blocks.rs
index 76fc6d48c..868346452 100644
--- a/crates/horizon-client/src/game/command_blocks.rs
+++ b/crates/horizon-client/src/game/command_blocks.rs
@@ -2,7 +2,7 @@
 //! tick (`execute`, `executeChain`), `BaseCommandBlock.performCommand`
 //! through the command system with the block's output, and
 //! `CommandBlockEditScreen` with what `handleSetCommandBlock` does with it.
-use super::{Game, Screen, commands::execute::Source};
+use super::{Game, Screen, commands::execute::Source, lan::LanHost};
 use horizon_client::{
     command_block::{self, CommandBlock, Mode},
     containers::BlockEntity,
@@ -12,6 +12,7 @@ use horizon_client::{
     world::World,
 };
 use horizon_core::position::BlockPos;
+use horizon_protocol::packets::play::{self, Serverbound as S};
 use horizon_world::{
     chunk::BlockState,
     level::flags,
@@ -35,6 +36,16 @@ pub(super) struct CommandBlockScreen {
     auto: bool,
 }
 
+/// What `ServerboundSetCommandBlockPacket` carries.
+struct CommandBlockEdit {
+    pos: Pos,
+    command: String,
+    track_output: bool,
+    mode: Mode,
+    conditional: bool,
+    auto: bool,
+}
+
 #[derive(Clone, Copy, PartialEq)]
 enum Button {
     Output,
@@ -186,6 +197,18 @@ impl Game<'_> {
     pub(super) fn can_use_game_master_blocks(&self) -> bool {
         self.creative && self.ui.registries.permission >= 2
     }
+    /// `CommandBlock.useWithoutItem` on a server's client, which opens the
+    /// screen itself (`Player.openCommandBlock`) while the server only
+    /// answers the click: the block at `pos`, when it is a command block the
+    /// player may edit.
+    pub(super) fn open_command_block_if_editable(&mut self, pos: Pos) {
+        let is_command_block = self
+            .block_state_at(pos)
+            .is_some_and(|state| Mode::of_block(&state.name).is_some());
+        if is_command_block && self.can_use_game_master_blocks() {
+            self.open_command_block(pos);
+        }
+    }
     fn command_block(&self, pos: Pos) -> Option<&CommandBlock> {
         match self.world.block_entities.get(&pos)? {
             BlockEntity::CommandBlock(c) => Some(c),
@@ -572,12 +595,66 @@ impl Game<'_> {
             s.command.insert_text(&allowed);
         }
     }
-    /// `ServerGamePacketListenerImpl.handleSetCommandBlock`.
+    /// The edit screen's Done: a server's client sends the packet, the
+    /// window's own world applies it (`handleSetCommandBlock`).
     fn set_command_block(&mut self, s: &CommandBlockScreen) {
         if !self.can_use_game_master_blocks() {
             self.system_message(Text::translate("advMode.notAllowed", &[]));
             return;
         }
+        let edit = CommandBlockEdit {
+            pos: s.pos,
+            command: s.command.value.clone(),
+            track_output: s.track_output,
+            mode: s.mode,
+            conditional: s.conditional,
+            auto: s.auto,
+        };
+        if self.remote.is_some() {
+            self.send(S::SetCommandBlock(play::SetCommandBlock {
+                pos: [edit.pos.0, edit.pos.1, edit.pos.2],
+                command: edit.command,
+                mode: edit.mode.ordinal(),
+                flags: i8::from(edit.track_output)
+                    | (i8::from(edit.conditional) << 1)
+                    | (i8::from(edit.auto) << 2),
+            }));
+        } else {
+            self.apply_command_block(&edit);
+        }
+    }
+    /// `ServerGamePacketListenerImpl.handleSetCommandBlock` for a guest: the
+    /// block is edited only by a creative player with game master commands.
+    pub(super) fn lan_set_command_block(
+        &mut self,
+        host: &mut LanHost,
+        conn: u32,
+        p: play::SetCommandBlock,
+    ) {
+        let Some(g) = host.hub.guest(conn) else {
+            return;
+        };
+        let allowed = g.creative() && g.permission >= 2;
+        let edit = CommandBlockEdit {
+            pos: (p.pos[0], p.pos[1], p.pos[2]),
+            command: p.command,
+            track_output: p.flags & 1 != 0,
+            mode: Mode::from_ordinal(p.mode),
+            conditional: p.flags & 2 != 0,
+            auto: p.flags & 4 != 0,
+        };
+        self.as_guest(host, conn, |game| {
+            if allowed {
+                game.apply_command_block(&edit);
+                // BaseCommandBlock.onUpdated: the clients get the new command.
+                game.mark_block_entity_updated(edit.pos);
+            } else {
+                game.system_message(Text::translate("advMode.notAllowed", &[]));
+            }
+        });
+    }
+    /// What `handleSetCommandBlock` does once the player may edit the block.
+    fn apply_command_block(&mut self, s: &CommandBlockEdit) {
         let pos = s.pos;
         let registry = self.pack.assets.registry;
         let Some(current) = self.block_state_at(pos) else {
@@ -609,7 +686,7 @@ impl Game<'_> {
             }
             let _ = self.process_level_events();
         }
-        let command = s.command.value.clone();
+        let command = s.command.clone();
         let Some(c) = command_block_mut(&mut self.world, pos) else {
             return;
         };
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 98162ae46..a24938014 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -1200,6 +1200,7 @@ impl Game<'_> {
             }
             S::RenameItem(p) => self.lan_station_rename(host, conn, &p.name),
             S::SignUpdate(p) => self.lan_sign_update(host, conn, p),
+            S::SetCommandBlock(p) => self.lan_set_command_block(host, conn, p),
             S::EditBook(p) => self.lan_edit_book(host, conn, p),
             S::ContainerSlotStateChanged(p) => {
                 self.lan_crafter_slot_state(host, conn, p.container, p.slot, p.enabled);
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..6538fbaae 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -4064,6 +4064,7 @@ impl Game<'_> {
             }
             if reacts {
                 self.predict_use(&changes, seq);
+                self.open_command_block_if_editable((hit.pos[0], hit.pos[1], hit.pos[2]));
             } else if let Some(stack) = held.as_ref()
                 && self.predict_item_on_block(stack, &hit)
             {
diff --git a/crates/horizon-protocol/src/packets/play.rs b/crates/horizon-protocol/src/packets/play.rs
index 26bc09a84..6140a3b55 100644
--- a/crates/horizon-protocol/src/packets/play.rs
+++ b/crates/horizon-protocol/src/packets/play.rs
@@ -2160,6 +2160,12 @@ packet!(
     /// ServerboundSignUpdatePacket: the four lines the player wrote on a side.
     SignUpdate { pos: [i32; 3] => Pos, lines: [String; 4] => SignLines, front: bool => SignSide }
 );
+packet!(
+    /// ServerboundSetCommandBlockPacket: the command block's command, its
+    /// mode (`CommandBlockEntity.Mode` ordinal) and the track output (1),
+    /// conditional (2) and automatic (4) flags.
+    SetCommandBlock { pos: [i32; 3] => Pos, command: String => Str, mode: i32 => VarInt, flags: i8 => Byte }
+);
 packet!(
     /// ServerboundEditBookPacket: the book's slot (a hotbar slot, or 40 for
     /// the off hand), its pages and, to sign it, its title.
@@ -2320,6 +2326,7 @@ packet_enum!(Serverbound, crate::ids::play::serverbound {
     SelectTrade(SelectTrade) = SELECT_TRADE,
     SetBeacon(SetBeacon) = SET_BEACON,
     SetCarriedItem(SetCarriedItem) = SET_CARRIED_ITEM,
+    SetCommandBlock(SetCommandBlock) = SET_COMMAND_BLOCK,
     SetCreativeModeSlot(SetCreativeModeSlot) = SET_CREATIVE_MODE_SLOT,
     SignUpdate(SignUpdate) = SIGN_UPDATE,
     UseItem(UseItem) = USE_ITEM,

From 031f1e58a3984cb9fb793414f4e94ee670d414fe Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 22:07:12 +0100
Subject: [PATCH 311/475] remote_fireball: a slow fireball, sampled from one
 ctl process

The harness sampled the fireball from a new horizon-ctl process each time,
10-16 ticks apart on a loaded runner: the fireball (~2 blocks a tick) left
the cleared corridor or the guest's tracking range before the sixth sample,
and the harness failed. It now flies slowly (acceleration_power 0.02, under
0.4 blocks a tick) down a longer corridor, and the guest takes 16 samples
in one ctl script (lan_e2e's Game.script returns every reply with every=True).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tools/lan_e2e.py                     |  7 ++++---
 tools/test_remote_fireball_parity.py | 14 +++++++++-----
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index ab3fcde1b..dfa7df454 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -339,8 +339,9 @@ class Game:
     def wait(self, ticks):
         self.d('wait', ticks=ticks)
 
-    def script(self, lines):
-        """Keep tick-sensitive input in one ctl process, through the normal control commands."""
+    def script(self, lines, every=False):
+        """Keep tick-sensitive input in one ctl process, through the normal control commands. Returns the last
+        reply, or with every=True all of them in order."""
         result = subprocess.run(self.d.base + ['script'], input='\n'.join(lines) + '\n',
                                 cwd=self.work, env=self.d.env, capture_output=True, text=True,
                                 timeout=600)
@@ -348,7 +349,7 @@ class Game:
         ticks = [r['ticks'] for r in replies if 'ticks' in r]
         print(f'[{self.name}] script {lines} -> {replies[-1] if replies else result.stderr[:400]}; ticks={ticks}')
         assert result.returncode == 0 and replies and not any('error' in r for r in replies), result.stdout
-        return replies[-1]
+        return replies if every else replies[-1]
 
     def until(self, observe, predicate, ticks=100):
         """Wait for an observable answer, within the existing tick budget."""
diff --git a/tools/test_remote_fireball_parity.py b/tools/test_remote_fireball_parity.py
index 7e60ff30a..d227ed3f7 100644
--- a/tools/test_remote_fireball_parity.py
+++ b/tools/test_remote_fireball_parity.py
@@ -18,15 +18,19 @@ def check_motion(host, guest, out):
     for game in (host, guest):
         game('command', command='gamemode creative')
     tag = 'remote_fireball_parity'
-    host('command', command=f'fill {x + 2} {y + 18} {z - 1} {x + 48} {y + 23} {z + 1} minecraft:air')
+    # A slow fireball (acceleration_power 0.02: under 0.4 blocks a tick, against ~2 by default) stays in the cleared
+    # corridor and in the guest's tracking range for every sample, however many ticks a loaded host takes to answer.
+    host('command', command=f'fill {x + 2} {y + 18} {z - 1} {x + 96} {y + 23} {z + 1} minecraft:air')
     host('command', command=f'summon minecraft:fireball {x + 3.5} {y + 20} {z + 0.5} '
-                            f'{{Tags:["{tag}"],Motion:[0.1d,0.0d,0.0d]}}')
+                            f'{{Tags:["{tag}"],Motion:[0.1d,0.0d,0.0d],acceleration_power:0.02d}}')
     samples = []
     try:
-        for _ in range(8):
-            balls = [p for p in guest('status')['projectiles'] if p['kind'] == 'LargeFireball']
+        # One ctl process for all samples: a ctl process per sample took 10-16 ticks on a loaded runner, by
+        # which time the fireball had left the cleared corridor and exploded.
+        replies = guest.script(['status', 'wait 1'] * 16, every=True)
+        for status in (reply for reply in replies if 'projectiles' in reply):
+            balls = [p for p in status['projectiles'] if p['kind'] == 'LargeFireball']
             samples.append(balls[0]['position'][0] if balls else None)
-            guest.wait(2)
     finally:
         host('command', command=f'kill @e[tag={tag}]')
     seen = [p for p in samples if p is not None]

From 8f78fdeb7bec717e91fa24394b9bcb940cfc8ae5 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:08:35 +0100
Subject: [PATCH 312/475] Keep leash knot ids per level and clear remote knots
 with the other remote objects

---
 crates/horizon-client/src/game/levels.rs         | 4 ++++
 crates/horizon-client/src/game/remote_objects.rs | 1 +
 2 files changed, 5 insertions(+)

diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs
index 8d2e0a4a2..09de6ab62 100644
--- a/crates/horizon-client/src/game/levels.rs
+++ b/crates/horizon-client/src/game/levels.rs
@@ -66,6 +66,8 @@ pub(super) struct Parked {
     tnts: Vec<tnt::PrimedTnt>,
     hoppers: HashMap<(i32, i32, i32), machines::HopperState>,
     mobs: Vec<Mob>,
+    /// The entity ids of the level's fence knots (`knot_ids`).
+    knot_ids: HashMap<[i32; 3], u32>,
     projectiles: Vec<horizon_client::projectiles::Projectile>,
     dropped: Vec<ItemEntity>,
     orbs: Vec<ExperienceOrb>,
@@ -153,6 +155,7 @@ impl Game<'_> {
             tnts: Vec::new(),
             hoppers: HashMap::new(),
             mobs: Vec::new(),
+            knot_ids: HashMap::new(),
             projectiles: Vec::new(),
             dropped: Vec::new(),
             orbs: Vec::new(),
@@ -205,6 +208,7 @@ impl Game<'_> {
         swap(&mut self.tnts, &mut p.tnts);
         swap(&mut self.hoppers, &mut p.hoppers);
         swap(&mut self.mobs, &mut p.mobs);
+        swap(&mut self.knot_ids, &mut p.knot_ids);
         swap(&mut self.creatures.projectiles, &mut p.projectiles);
         swap(&mut self.dropped, &mut p.dropped);
         swap(&mut self.orbs, &mut p.orbs);
diff --git a/crates/horizon-client/src/game/remote_objects.rs b/crates/horizon-client/src/game/remote_objects.rs
index f6afba1b2..7f484c35f 100644
--- a/crates/horizon-client/src/game/remote_objects.rs
+++ b/crates/horizon-client/src/game/remote_objects.rs
@@ -315,6 +315,7 @@ impl Game<'_> {
     /// Every object a server sent (a new connection, level or dimension).
     pub(super) fn clear_remote_objects(&mut self) {
         self.text_displays.clear();
+        self.remote_knots.clear();
         self.carts.clear();
         self.boats.clear();
         self.armor_stands.clear();

From 8f02822a9aa71d5e008d5f18b68345db7a61abc5 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 22:09:44 +0100
Subject: [PATCH 313/475] remote.sh: stop the command on the host with its
 caller, and what it leaves running

The command ran on after remote.sh was stopped or its connection dropped,
holding the name's lock, and a game or daemon it left behind outlived the
run. It now runs in a scope named after the run (remote-<name>.scope),
stopped when the command ends, when the ssh session ends first, and before
the next run under that name.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/parity-workflow.md |  2 +-
 tools/remote.sh         | 18 ++++++++++++++++--
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md
index 7419eef26..50b67c571 100644
--- a/docs/parity-workflow.md
+++ b/docs/parity-workflow.md
@@ -46,7 +46,7 @@ Harnesses a host can't run are listed in the file: `local_only` (`save_roundtrip
 
 ### Any command on playhorizon: `tools/remote.sh`
 
-For Linux work that doesn't need a whole parity run (a crate's tests, a few harnesses, a server build), `tools/remote.sh <worktree> <command...>` runs the command on playhorizon at the worktree's commit and streams its output back; its exit status is the command's. Commit and push first: the host fetches the commit from GitHub, and nothing else leaves this machine (no files, no credentials, no environment). Each worktree keeps one checkout there, `~/remote-work/<name>` with its own `target/`, so the next run only rebuilds what changed, and one run per name goes at a time. The command runs niced in the host's CI slice, pinned to CPUs 4-7 (`--cpus`; 0-3 stay free for benchmarks), with scratch game and launcher homes and the vanilla data linked as CI links it; a command naming `parity`, `lan_e2e` or `horizon-prepare` also gets `.local/horizon-client`, prepared as CI prepares it. Logs stay in `~/remote-work/<name>.logs/`; `--list` shows the checkouts, `--gc [DAYS]` removes old ones.
+For Linux work that doesn't need a whole parity run (a crate's tests, a few harnesses, a server build), `tools/remote.sh <worktree> <command...>` runs the command on playhorizon at the worktree's commit and streams its output back; its exit status is the command's. Commit and push first: the host fetches the commit from GitHub, and nothing else leaves this machine (no files, no credentials, no environment). Each worktree keeps one checkout there, `~/remote-work/<name>` with its own `target/`, so the next run only rebuilds what changed, and one run per name goes at a time. The command runs niced in the host's CI slice, pinned to CPUs 4-7 (`--cpus`; 0-3 stay free for benchmarks), with scratch game and launcher homes and the vanilla data linked as CI links it; a command naming `parity`, `lan_e2e` or `horizon-prepare` also gets `.local/horizon-client`, prepared as CI prepares it. Whatever the command leaves running (a game, a daemon) is stopped when it ends, and stopping `remote.sh` (or losing the connection) stops the command on the host. Logs stay in `~/remote-work/<name>.logs/`; `--list` shows the checkouts, `--gc [DAYS]` removes old ones.
 
 ```sh
 tools/remote.sh .claude/worktrees/my-fix cargo test -p horizon-world --lib   # 33 s, warm
diff --git a/tools/remote.sh b/tools/remote.sh
index 1df21c560..0955666cb 100755
--- a/tools/remote.sh
+++ b/tools/remote.sh
@@ -15,6 +15,7 @@
 # toolchains, a virtual screen and scratch homes for the game and launcher. .local/ links to the host's vanilla
 # data; a command that runs harnesses (it names parity, lan_e2e or horizon-prepare) also gets .local/horizon-client,
 # prepared as CI prepares it (tools/ci/vanilla-data.sh). Output streams back and is kept in ~/remote-work/<name>.logs/.
+# What the command leaves running is stopped when it ends; stopping this script stops the command on the host.
 # The exit status is the command's.
 #
 # The host is lent by a partner who keeps hypervisor access: never send secrets, tokens or credentials there,
@@ -96,9 +97,22 @@ export HORIZON_HOME=$scratch/game HORIZON_LAUNCHER_HOME=$scratch/launcher XDG_DA
 mkdir -p "$HORIZON_HOME" "$HORIZON_LAUNCHER_HOME" "$XDG_DATA_HOME" "$XDG_CONFIG_HOME" ../"$name.logs"
 log=../"$name.logs/$(date -u +%Y%m%dT%H%M%SZ)-${sha:0:9}.log"
 echo "remote.sh: $(hostname) at ${sha:0:9} in ~/remote-work/$name, CPUs $cpus, -j $jobs; log ~/remote-work/${log#../}" >&2
+# The command runs in a scope of its own, stopped with everything in it once the command is done (a game or a
+# daemon it left behind), when the caller goes away first (the ssh session ends), and before the next run here.
+unit=remote-$name.scope
+systemctl --user stop "$unit" 2>/dev/null || true
+session=$PPID
+( while kill -0 "$session" 2>/dev/null; do sleep 2; done; systemctl --user stop "$unit" 2>/dev/null ) \
+  < /dev/null > /dev/null 2>&1 9>&- &
+watcher=$!
 status=0
-systemd-run --user --scope --quiet --slice=horizon-ci.slice --unit="remote-$name-$$" \
+systemd-run --user --scope --quiet --slice=horizon-ci.slice --unit="$unit" \
   "${pin[@]}" nice -n 10 bash -c "$command" 2>&1 < /dev/null 9>&- | tee "$log" || status=${PIPESTATUS[0]}
+kill "$watcher" 2>/dev/null || true
+systemctl --user stop "$unit" 2>/dev/null || true
 exit "$status"
 REMOTE
-} | ssh -o BatchMode=yes "ludovic@$host" bash -s
+} | ssh -o BatchMode=yes "ludovic@$host" bash -s &
+# Stopping this script ends the session, and the host then stops the command (above).
+trap 'kill $! 2>/dev/null' INT TERM HUP
+wait $!

From cc58083574d857b72c3abc6578254b364e256937 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 22:14:56 +0100
Subject: [PATCH 314/475] Give the dropped preload's memory back to the OS

glibc keeps the pages the preload thread freed in that thread's arena, and
macOS keeps them in its zones until memory runs short, so dropping the
preload didn't lower the footprint: horizon-threads now asks the allocator to
return free pages (malloc_trim, malloc_zone_pressure_relief).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../horizon-client/src/game/world_loading.rs  |  1 +
 crates/horizon-threads/src/lib.rs             | 32 +++++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/crates/horizon-client/src/game/world_loading.rs b/crates/horizon-client/src/game/world_loading.rs
index b16bcffb6..73f1820f2 100644
--- a/crates/horizon-client/src/game/world_loading.rs
+++ b/crates/horizon-client/src/game/world_loading.rs
@@ -259,6 +259,7 @@ pub(super) fn preload_world_data(
                 horizon_client::vanillagen::forget_shared_data();
                 horizon_client::structure_blocks::forget_loot_data();
                 super::lan::forget_sync_data();
+                horizon_threads::release_free_memory();
                 *preload = Preload::Idle;
                 log::info!("Horizon: preloaded world data dropped, no world opened");
             }
diff --git a/crates/horizon-threads/src/lib.rs b/crates/horizon-threads/src/lib.rs
index 90c8d128e..917c3b502 100644
--- a/crates/horizon-threads/src/lib.rs
+++ b/crates/horizon-threads/src/lib.rs
@@ -126,6 +126,38 @@ fn idle() -> bool {
     false
 }
 
+/// Give back to the OS the memory the allocator holds free, after something
+/// large was dropped: glibc keeps freed pages in the arena of the thread that
+/// allocated them, and macOS in its zones until memory runs short. Nothing
+/// elsewhere.
+pub fn release_free_memory() {
+    release();
+}
+
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+fn release() {
+    // SAFETY: returns free heap pages of every arena to the OS; no live
+    // allocation moves.
+    unsafe {
+        libc::malloc_trim(0);
+    }
+}
+
+#[cfg(target_vendor = "apple")]
+fn release() {
+    unsafe extern "C" {
+        fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;
+    }
+    // SAFETY: a null zone means every zone and a goal of 0 as much as it can;
+    // it frees only pages no allocation uses.
+    unsafe {
+        malloc_zone_pressure_relief(std::ptr::null_mut(), 0);
+    }
+}
+
+#[cfg(not(any(all(target_os = "linux", target_env = "gnu"), target_vendor = "apple")))]
+fn release() {}
+
 #[cfg(test)]
 mod tests {
     /// The hint holds on the platforms that take it.

From 6c716f457b7609e96bf6bc1642d0917cb615c1e4 Mon Sep 17 00:00:00 2001
From: FusselTV <github@fussel.tv>
Date: Mon, 26 Oct 2026 21:16:23 +0100
Subject: [PATCH 315/475] Mobs: farm animals and frogs keep their variant;
 sound variants are saved

finalizeSpawn picks the variant of a pig, cow, chicken or frog and the
sound variant of a pig, cow, chicken, cat or wolf, but the save wrote
neither for these: pigs, cows, chickens and frogs came back temperate
after a reload, and every cat and wolf was saved with the classic sounds
whatever it rolled. Chickens also lost their egg timer.

Every mob with a variant component now saves and loads `variant`
through finalize::species_variant_component / variant_index (the cat and
wolf code used its own copy). The sound variant is kept as an index into
the species' registry (None is the default, classic) and is saved and
read back; Chicken also saves `EggLayTime`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../examples/probe/finalize_spawn_fixture.rs  |   8 +-
 crates/horizon-client/src/entity_nbt.rs       | 125 ++++++++++++++----
 crates/horizon-client/src/mobs.rs             |   5 +-
 crates/horizon-client/src/mobs/finalize.rs    |  13 +-
 4 files changed, 120 insertions(+), 31 deletions(-)

diff --git a/crates/horizon-client/examples/probe/finalize_spawn_fixture.rs b/crates/horizon-client/examples/probe/finalize_spawn_fixture.rs
index b1b25e723..067d545a8 100644
--- a/crates/horizon-client/examples/probe/finalize_spawn_fixture.rs
+++ b/crates/horizon-client/examples/probe/finalize_spawn_fixture.rs
@@ -154,11 +154,11 @@ const MEMORIES: [&str; 7] = [
 fn variant(m: &Mob, regs: &SpawnRegistries, v: &mut Vec<String>) {
     use Species as S;
     let s = m.species();
-    let named = |reg: &finalize::VariantRegistry, i: u8| {
-        format!(
-            "minecraft:{}",
+    let named = |reg: &finalize::VariantRegistry, i: Option<u8>| {
+        let name = i.map_or("classic", |i| {
             reg.names.get(i as usize).map_or("?", |n| n.as_str())
-        )
+        });
+        format!("minecraft:{name}")
     };
     let var = format!("minecraft:{}", finalize::variant_name(s, m.extra.variant));
     match s {
diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 161ca12e9..8926b3bbe 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -225,6 +225,24 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
     if is_animal(id) {
         map.insert("InLove".into(), Tag::Int(m.extra.in_love.max(0)));
     }
+    let species = m.species();
+    if let Some((_, variant)) =
+        crate::mobs::finalize::species_variant_component(species, m.extra.variant)
+    {
+        map.insert("variant".into(), string(&variant));
+    }
+    if species == crate::mobs::Species::Chicken {
+        map.insert("EggLayTime".into(), Tag::Int(m.extra.egg_time));
+    }
+    let sounds = crate::mobs::finalize::sound_variants(species);
+    if !sounds.is_empty() {
+        let sound = m.extra.sound_variant.and_then(|i| sounds.get(i as usize));
+        let sound = sound.copied().unwrap_or("classic");
+        map.insert(
+            "sound_variant".into(),
+            string(&format!("minecraft:{sound}")),
+        );
+    }
     match id {
         "minecraft:creeper" => {
             for (key, value) in [("Fuse", Tag::Short(30)), ("ExplosionRadius", Tag::Byte(3))] {
@@ -241,10 +259,6 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             }
             map.insert("Sitting".into(), Tag::Byte(i8::from(m.extra.sitting)));
             map.insert("CollarColor".into(), Tag::Byte(m.extra.color as i8));
-            let variant = crate::mobs::tame::CAT_VARIANTS[(m.extra.variant as usize).min(10)];
-            map.insert("variant".into(), string(&format!("minecraft:{variant}")));
-            map.entry("sound_variant".into())
-                .or_insert_with(|| string("minecraft:classic"));
         }
         "minecraft:wolf" => {
             if let Some(owner) = m.extra.owner {
@@ -254,10 +268,6 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             }
             map.insert("Sitting".into(), Tag::Byte(i8::from(m.extra.sitting)));
             map.insert("CollarColor".into(), Tag::Byte(m.extra.color as i8));
-            let variant = crate::mobs::tame::WOLF_VARIANTS[(m.extra.variant as usize).min(8)].0;
-            map.insert("variant".into(), string(&format!("minecraft:{variant}")));
-            map.entry("sound_variant".into())
-                .or_insert_with(|| string("minecraft:classic"));
         }
         "minecraft:piglin" | "minecraft:piglin_brute" | "minecraft:hoglin" => {
             map.insert(
@@ -793,20 +803,27 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
             m.extra.vector[0] = 0.7;
         }
     }
+    if crate::mobs::finalize::species_variant_component(m.species(), 0).is_some()
+        && let Some(v) = text(tag.get("variant"))
+    {
+        m.extra.variant = crate::mobs::finalize::variant_index(m.species(), &v);
+    }
+    if m.species() == crate::mobs::Species::Chicken
+        && let Some(t) = number(tag.get("EggLayTime"))
+    {
+        m.extra.egg_time = t as i32;
+    }
+    if let Some(v) = text(tag.get("sound_variant")) {
+        let v = v.trim_start_matches("minecraft:");
+        let sounds = crate::mobs::finalize::sound_variants(m.species());
+        m.extra.sound_variant = sounds.iter().position(|n| *n == v).map(|i| i as u8);
+    }
     if m.species() == crate::mobs::Species::Cat {
         m.extra.owner = crate::save::uuid_from_tag(tag.get("Owner"));
         m.extra.tame = m.extra.owner.is_some();
         m.extra.sitting = flag(tag, "Sitting");
         m.extra.color =
             number(tag.get("CollarColor")).map_or(crate::mobs::tame::RED, |c| (c as u8) & 15);
-        if let Some(Tag::String(v)) = tag.get("variant") {
-            let v = v.to_string().unwrap_or_default();
-            let v = v.trim_start_matches("minecraft:");
-            m.extra.variant = crate::mobs::tame::CAT_VARIANTS
-                .iter()
-                .position(|n| *n == v)
-                .unwrap_or(0) as u8;
-        }
     }
     if m.species() == crate::mobs::Species::Wolf {
         let health = m.health;
@@ -817,14 +834,6 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
         m.extra.sitting = flag(tag, "Sitting");
         m.extra.color =
             number(tag.get("CollarColor")).map_or(crate::mobs::tame::RED, |c| (c as u8) & 15);
-        if let Some(Tag::String(v)) = tag.get("variant") {
-            let v = v.to_string().unwrap_or_default();
-            let v = v.trim_start_matches("minecraft:");
-            m.extra.variant = crate::mobs::tame::WOLF_VARIANTS
-                .iter()
-                .position(|(n, _)| *n == v)
-                .unwrap_or(0) as u8;
-        }
     }
     if matches!(
         m.species(),
@@ -2425,6 +2434,74 @@ mod sheep_nbt_tests {
         let back = mob_from_nbt(&tag, &types, 2).unwrap();
         assert_eq!((back.extra.color, back.extra.sheared), (14, true));
     }
+
+    #[test]
+    fn farm_animals_keep_their_variant_and_sound_variant() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("items.json").exists() {
+            return;
+        }
+        let data = crate::mobs::MobTypes::load(&root).unwrap();
+        let types: HashMap<String, Arc<MobType>> = data
+            .types
+            .iter()
+            .map(|(k, v)| (k.clone(), Arc::new(v.clone())))
+            .collect();
+        let mut m = Mob::new(
+            1,
+            types["minecraft:pig"].clone(),
+            Vec3::new(0.0, 4.0, 0.0),
+            0.0,
+        );
+        let tag = mob_to_nbt(&m, [1, 2, 3, 4], None);
+        assert_eq!(
+            text(tag.get("variant")).as_deref(),
+            Some("minecraft:temperate")
+        );
+        assert_eq!(
+            text(tag.get("sound_variant")).as_deref(),
+            Some("minecraft:classic")
+        );
+        // Spawned in a warm biome with the mini sounds.
+        (m.extra.variant, m.extra.sound_variant) = (1, Some(2));
+        let tag = mob_to_nbt(&m, [1, 2, 3, 4], None);
+        assert_eq!(text(tag.get("variant")).as_deref(), Some("minecraft:warm"));
+        assert_eq!(
+            text(tag.get("sound_variant")).as_deref(),
+            Some("minecraft:mini")
+        );
+        let back = mob_from_nbt(&tag, &types, 2).unwrap();
+        assert_eq!((back.extra.variant, back.extra.sound_variant), (1, Some(2)));
+        let mut hen = Mob::new(
+            3,
+            types["minecraft:chicken"].clone(),
+            Vec3::new(0.0, 4.0, 0.0),
+            0.0,
+        );
+        (hen.extra.variant, hen.extra.egg_time) = (2, 7795);
+        let tag = mob_to_nbt(&hen, [1, 2, 3, 4], None);
+        assert_eq!(text(tag.get("variant")).as_deref(), Some("minecraft:cold"));
+        let back = mob_from_nbt(&tag, &types, 4).unwrap();
+        assert_eq!((back.extra.variant, back.extra.egg_time), (2, 7795));
+        // The sound variants are indices into the registries finalizeSpawn draws from.
+        use crate::mobs::{Species, finalize};
+        let registries = finalize::SpawnRegistries::load(&root);
+        for (species, registry) in [
+            (Species::Pig, &registries.pig_sound),
+            (Species::Cow, &registries.cow_sound),
+            (Species::Chicken, &registries.chicken_sound),
+            (Species::Cat, &registries.cat_sound),
+            (Species::Wolf, &registries.wolf_sound),
+        ] {
+            assert_eq!(
+                finalize::sound_variants(species),
+                registry.names,
+                "{species:?}"
+            );
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index f4086216d..9933f2a4e 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -763,8 +763,9 @@ pub struct Extra {
     pub drop_chances: Option<Box<[f32; 8]>>,
     /// `Mob.leftHanded`.
     pub left_handed: bool,
-    /// The sound variant: index in the species' `*_sound_variant` registry.
-    pub sound_variant: u8,
+    /// The sound variant: index in the species' `*_sound_variant` registry
+    /// (`finalize::sound_variants`); None is the default, `classic`.
+    pub sound_variant: Option<u8>,
     /// `Zombie.canBreakDoors`.
     pub can_break_doors: bool,
     /// A goat's `IsScreamingGoat` and the horns it lost (left, right).
diff --git a/crates/horizon-client/src/mobs/finalize.rs b/crates/horizon-client/src/mobs/finalize.rs
index 6e5daff1f..ccf4564ca 100644
--- a/crates/horizon-client/src/mobs/finalize.rs
+++ b/crates/horizon-client/src/mobs/finalize.rs
@@ -1508,7 +1508,7 @@ impl<L: FinalizeLevel + ?Sized, R: RandomSource> Ctx<'_, L, R> {
     }
     fn sound(&mut self, m: &mut Mob, registry: fn(&SpawnRegistries) -> &VariantRegistry) {
         let r = registry(self.data.registries);
-        m.extra.sound_variant = r.random(self.random) as u8;
+        m.extra.sound_variant = Some(r.random(self.random) as u8);
     }
 
     /// `finalizeSpawn` of the mob's class.
@@ -2014,6 +2014,17 @@ pub fn species_variant_component(s: Species, variant: u8) -> Option<(&'static st
     };
     Some((component, format!("minecraft:{}", variant_name(s, variant))))
 }
+/// The `*_sound_variant` registry of a species, in registry order.
+pub fn sound_variants(s: Species) -> &'static [&'static str] {
+    match s {
+        Species::Pig => &["big", "classic", "mini"],
+        Species::Cow => &["classic", "moody"],
+        Species::Chicken => &["classic", "picky"],
+        Species::Cat => &["classic", "royal"],
+        Species::Wolf => &["angry", "big", "classic", "cute", "grumpy", "puglin", "sad"],
+        _ => &[],
+    }
+}
 /// The registry name of the game's variant index.
 pub fn variant_name(s: Species, index: u8) -> &'static str {
     let i = index as usize;

From a55c82546773cc719e2e8dd291476c87be1b7686 Mon Sep 17 00:00:00 2001
From: FusselTV <github@fussel.tv>
Date: Mon, 26 Oct 2026 21:46:35 +0100
Subject: [PATCH 316/475] Minecarts save HasTicked and Fire 0

AbstractMinecart saves Entity.firstTick as HasTicked, and a cart's fire
stays 0: Entity.move sets it to -getFireImmuneTicks(), which is 0 for
everything but players. A mineshaft's chest minecart was saved without
HasTicked and with Fire -1; vanilla's generated chunk saves it with
HasTicked 1 and Fire 0, and a cart that has ticked with HasTicked 0 and
Fire 0.

The mineshaft writes both as the proto chunk saves a new cart, and a
cart keeps first_tick from its save until its first tick.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/minecarts.rs   | 35 +++++++++++++++++++
 .../src/worldgen/structure/mineshaft.rs       |  3 ++
 2 files changed, 38 insertions(+)

diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index 072059e49..dcb5421e2 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -90,6 +90,8 @@ pub(super) struct Minecart {
     /// Chest minecarts: the loot table rolled into `items` on load, saved
     /// again while the items are still that roll.
     pub loot: Option<horizon_client::save::RolledLoot>,
+    /// `Entity.firstTick`: not ticked yet (saved as `HasTicked`).
+    pub first_tick: bool,
 }
 pub(super) const WIDTH: f64 = 0.98;
 pub(super) const HEIGHT: f64 = 0.7;
@@ -186,6 +188,7 @@ impl Minecart {
             fuse: -1,
             enabled: true,
             loot: None,
+            first_tick: true,
         }
     }
     pub fn bounds(&self) -> Aabb {
@@ -536,6 +539,7 @@ impl Game<'_> {
     }
     /// `AbstractMinecart.tick` for one cart; returns false once it is gone.
     fn tick_cart(&mut self, c: &mut Minecart, intent: [f64; 2]) -> bool {
+        c.first_tick = false;
         c.previous = c.position;
         c.previous_yaw = c.yaw;
         c.hurt_time = (c.hurt_time - 1).max(0);
@@ -1509,6 +1513,10 @@ impl Minecart {
                 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));
             match self.kind {
                 CartKind::Chest | CartKind::Hopper => {
                     put("Items", horizon_client::save::encode_items(&self.items));
@@ -1558,6 +1566,7 @@ impl Minecart {
             _ => 0.0,
         };
         c.flipped = int("FlippedRotation").unwrap_or(0) != 0;
+        c.first_tick = int("HasTicked").unwrap_or(0) != 0;
         if kind.slots() > 0 {
             c.items = horizon_client::save::decode_items(tag.get("Items"), kind.slots());
         }
@@ -1582,4 +1591,30 @@ mod tests {
         assert_eq!(display_offset(CartKind::CommandBlock), 6.0);
         assert_eq!(display_offset(CartKind::Rideable), 6.0);
     }
+
+    #[test]
+    fn a_cart_saves_as_never_ticked_until_it_ticks() {
+        use horizon_world::nbt::Tag;
+        let generated = Tag::compound([
+            ("id", Tag::String("minecraft:chest_minecart".into())),
+            (
+                "Pos",
+                Tag::List(
+                    [0.5f64, 40.5, 0.5]
+                        .map(|v| Tag::Double(v.to_bits()))
+                        .to_vec(),
+                ),
+            ),
+            ("HasTicked", Tag::Byte(1)),
+            ("Fire", Tag::Short(0)),
+        ]);
+        let mut cart = Minecart::from_nbt(&generated, 1, CartKind::Chest).unwrap();
+        let saved = cart.to_nbt([0; 4], Some(&generated));
+        assert_eq!(saved.get("HasTicked"), Some(&Tag::Byte(1)));
+        assert_eq!(saved.get("Fire"), Some(&Tag::Short(0)));
+        cart.first_tick = false;
+        let saved = cart.to_nbt([0; 4], Some(&generated));
+        assert_eq!(saved.get("HasTicked"), Some(&Tag::Byte(0)));
+        assert_eq!(saved.get("Fire"), Some(&Tag::Short(0)));
+    }
 }
diff --git a/crates/horizon-world/src/worldgen/structure/mineshaft.rs b/crates/horizon-world/src/worldgen/structure/mineshaft.rs
index 0c2d32c08..082afd0cd 100644
--- a/crates/horizon-world/src/worldgen/structure/mineshaft.rs
+++ b/crates/horizon-world/src/worldgen/structure/mineshaft.rs
@@ -616,6 +616,9 @@ impl MineshaftPiece {
             // A chest minecart with the mineshaft loot table.
             let seed = c.random.long();
             let mut nbt = super::legacy::spawn_nbt("minecraft:chest_minecart", pos, false, false);
+            // As the proto chunk saves the new cart: not ticked, not burning.
+            nbt.insert("HasTicked".into(), Tag::Byte(1));
+            nbt.insert("Fire".into(), Tag::Short(0));
             let p = [
                 f64::from(pos[0]) + 0.5,
                 f64::from(pos[1]) + 0.5,

From f8ba6505597ad363b18e8bc0076ccb3610b3ba96 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 22:25:11 +0100
Subject: [PATCH 317/475] ci: full-parity label runs a pull request's parity
 job on the desktop

A crate split reaches every harness (#2160: 352 harnesses, 71 min on a Mac
mini runner) and held the Mac mini's runners while other pull requests'
parity jobs queued for over an hour. With the full-parity label, the job
runs on the desktop's runner only (8 at a time) and waits for it while the
desktop is in use; its timeout is 300 min, since a job under way when
someone comes back goes on with 2 threads.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/ci.yml         |  1 +
 .github/workflows/parity.yml     | 13 +++++++++++--
 .github/workflows/run-parity.yml |  1 +
 docs/release-flow.md             |  7 +++++++
 4 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 39ea920da..b2fd9fa48 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -144,6 +144,7 @@ jobs:
     with:
       base: ${{ github.event.pull_request.base.sha }}
       head: ${{ github.event.pull_request.head.sha }}
+      full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}
   # Horizon never downloads the game. These jobs need a self-hosted Linux runner
   # (label horizon-game) holding the maintainer's own copy: the official launcher's
   # game directory in HORIZON_MINECRAFT_DIR and the pinned server jar in
diff --git a/.github/workflows/parity.yml b/.github/workflows/parity.yml
index 9f678b43b..b90ad9968 100644
--- a/.github/workflows/parity.yml
+++ b/.github/workflows/parity.yml
@@ -13,6 +13,13 @@ on:
         description: The commit to check out and test
         type: string
         required: true
+      full:
+        description: >-
+          The pull request carries the full-parity label (a change every harness reaches, such as a crate split): it
+          runs on the desktop's runner only, so the Mac mini's runners stay free for the others. While the desktop is
+          in use the job waits for it.
+        type: boolean
+        default: false
 permissions:
   contents: read
 env:
@@ -21,8 +28,10 @@ env:
 
 jobs:
   parity:
-    runs-on: [self-hosted, horizon-game]
-    timeout-minutes: 120  # a change to core crates reruns ~300 harnesses: ~60-90 min on the Mac mini
+    runs-on: ${{ inputs.full && fromJSON('["self-hosted", "horizon-game", "ludodesktop"]') || fromJSON('["self-hosted", "horizon-game"]') }}
+    # A change to core crates reruns ~350 harnesses: ~60-90 min on the Mac mini, ~35 min on the desktop, longer if
+    # someone comes back to the desktop meanwhile (the job then goes on with 2 threads).
+    timeout-minutes: ${{ inputs.full && 300 || 120 }}
     steps:
       - uses: actions/checkout@v4
         with:
diff --git a/.github/workflows/run-parity.yml b/.github/workflows/run-parity.yml
index a2b8e3291..9089a9a09 100644
--- a/.github/workflows/run-parity.yml
+++ b/.github/workflows/run-parity.yml
@@ -22,3 +22,4 @@ jobs:
     with:
       base: ${{ github.event.pull_request.base.sha }}
       head: ${{ github.event.pull_request.head.sha }}
+      full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}
diff --git a/docs/release-flow.md b/docs/release-flow.md
index b0d435c29..8373f2bf6 100644
--- a/docs/release-flow.md
+++ b/docs/release-flow.md
@@ -27,6 +27,12 @@ quick steps and finishes in seconds.
 The job is `.github/workflows/parity.yml`, a reusable workflow: `checks` calls it for pull requests from this
 repository, `run-parity.yml` for a fork's pull request a maintainer labels `run-parity`.
 
+A pull request every harness reaches (a crate split moves files every probe links: #2160 ran all 352 harnesses, 71
+minutes on a Mac mini runner, while five other pull requests' jobs queued behind it) carries the `full-parity` label:
+its job runs on the desktop's runner only (8 harnesses at a time), and waits for it while the desktop is in use
+instead of taking a Mac mini runner. Labels don't start `checks`: add it when opening the pull request
+(`gh pr create --label full-parity`), or before the next push.
+
 Horizon never downloads the game, so harnesses that compare with vanilla run only where the maintainer's own
 copy is: the Mac mini, his Linux desktop and playhorizon (below). Their runners run as the maintainer's account and keep their checkout
 between runs (`clean: false`), so the probes build incrementally into `.local/parity-target` and earlier passes
@@ -212,6 +218,7 @@ How releases are numbered, and how installs from before 0.2 reach it: [versionin
 | `release-now` | Releases as soon as main's checks pass, without waiting for merges to settle |
 | `skip-release` | Doesn't trigger a release and isn't listed in the notes |
 | `run-parity` | Runs the parity job once on a fork's pull request |
+| `full-parity` | Runs the pull request's parity job on the desktop's runner only (a change every harness reaches) |
 | `parity-regression` | Opened by the nightly audit for a harness that fails on main |
 | `release-blocker` | On an issue: no game release is published while it is open ([One channel](#one-channel)) |
 

From a146754b0bad67a3985da78346bf8d2487009bfb Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:28:10 +0100
Subject: [PATCH 318/475] Make the Particles option thin every particle,
 explosion debris and rain splash

The Particles option only changed two effects. Follow ClientLevel.doAddParticle
and calculateParticleLevel in the one add path: Decreased drops a third, Minimal
drops all but the always-visible and limiter-overriding particles. Explosion
block debris is thrown only on All, and rain splashes halve on Decreased and
stop on Minimal.
---
 crates/horizon-client/src/animate_tick.rs     | 12 ++--
 crates/horizon-client/src/game/dragon.rs      |  4 +-
 .../horizon-client/src/game/lan_particles.rs  | 10 +--
 .../src/game/level_particles.rs               |  5 +-
 .../src/game/remote_projectiles.rs            |  2 +-
 crates/horizon-client/src/game/render_tick.rs |  8 ++-
 crates/horizon-client/src/particles.rs        | 64 ++++++++++++-------
 7 files changed, 65 insertions(+), 40 deletions(-)

diff --git a/crates/horizon-client/src/animate_tick.rs b/crates/horizon-client/src/animate_tick.rs
index 28b28544b..92445433e 100644
--- a/crates/horizon-client/src/animate_tick.rs
+++ b/crates/horizon-client/src/animate_tick.rs
@@ -357,6 +357,10 @@ impl AnimateContext<'_> {
 fn add(engine: &mut ParticleEngine, ty: T, p: [f64; 3], v: [f64; 3]) {
     engine.add(&ParticleOptions::simple(ty), p, v);
 }
+/// `Level.addAlwaysVisibleParticle`: still shown under the Minimal option now and then.
+fn add_visible(engine: &mut ParticleEngine, ty: T, p: [f64; 3], v: [f64; 3]) {
+    engine.add_with(&ParticleOptions::simple(ty), p, v, false, true);
+}
 fn sound(engine: &mut ParticleEngine, name: &'static str, p: [f64; 3], volume: f32, pitch: f32) {
     engine.sounds.push((name, p, volume, pitch));
 }
@@ -869,7 +873,7 @@ fn block_animate_tick(
                         fy + 1.0 + f64::from(r.next_float()),
                         fz + f64::from(r.next_float()),
                     ];
-                    add(engine, T::SulfurBubbles, p, [0.0; 3]);
+                    add_visible(engine, T::SulfurBubbles, p, [0.0; 3]);
                 }
                 if next_int(engine.random(), 10) == 0 {
                     let name = "minecraft:block.potent_sulfur.noxious_gas";
@@ -1086,7 +1090,7 @@ fn block_animate_tick(
         }
         Animate::BubbleColumn { drag } => {
             if drag {
-                add(engine, T::CurrentDown, [fx + 0.5, fy + 0.8, fz], [0.0; 3]);
+                add_visible(engine, T::CurrentDown, [fx + 0.5, fy + 0.8, fz], [0.0; 3]);
                 let r = engine.random();
                 if next_int(r, 200) == 0 {
                     let (volume, pitch) = (0.2 + r.next_float() * 0.2, 0.9 + r.next_float() * 0.15);
@@ -1099,7 +1103,7 @@ fn block_animate_tick(
                     );
                 }
             } else {
-                add(
+                add_visible(
                     engine,
                     T::BubbleColumnUp,
                     [fx + 0.5, fy, fz + 0.5],
@@ -1111,7 +1115,7 @@ fn block_animate_tick(
                     fy + f64::from(r.next_float()),
                     fz + f64::from(r.next_float()),
                 ];
-                add(engine, T::BubbleColumnUp, p, [0.0, 0.04, 0.0]);
+                add_visible(engine, T::BubbleColumnUp, p, [0.0, 0.04, 0.0]);
                 let r = engine.random();
                 if next_int(r, 200) == 0 {
                     let (volume, pitch) = (0.2 + r.next_float() * 0.2, 0.9 + r.next_float() * 0.15);
diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index fff03ef1c..f7df7c816 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -2127,10 +2127,12 @@ impl Game<'_> {
                     c.at[1],
                     c.at[2] + f64::from(a.sin() * d),
                 ];
-                self.particles.add(
+                self.particles.add_with(
                     &ParticleOptions::simple(ParticleType::DragonBreath),
                     at,
                     [0.0, 0.0, 0.0],
+                    false,
+                    true,
                 );
             }
             // AreaEffectCloud: after its 20-tick wait, every 20 ticks per entity.
diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs
index c41fdf1ad..dc014cd57 100644
--- a/crates/horizon-client/src/game/lan_particles.rs
+++ b/crates/horizon-client/src/game/lan_particles.rs
@@ -151,14 +151,10 @@ impl Game<'_> {
             return;
         };
         let (d, s) = (p.dist.map(f64::from), p.max_speed.map(f64::from));
-        // ClientLevel.addParticle: the camera's 32 blocks unless the packet
-        // (`force`) or the type overrides the limiter.
+        // ClientLevel.addParticle: the camera's 32 blocks and the Particles
+        // option, unless the packet or the type overrides the limiter.
         let add = |particles: &mut horizon_client::particles::ParticleEngine, at, v| {
-            if p.override_limiter {
-                particles.create(&options, at, v);
-            } else {
-                particles.add(&options, at, v);
-            }
+            particles.add_with(&options, at, v, p.override_limiter, p.always_show);
         };
         if p.count == 0 {
             add(
diff --git a/crates/horizon-client/src/game/level_particles.rs b/crates/horizon-client/src/game/level_particles.rs
index f12aedc5b..ca7d71a46 100644
--- a/crates/horizon-client/src/game/level_particles.rs
+++ b/crates/horizon-client/src/game/level_particles.rs
@@ -9,13 +9,12 @@ use horizon_world::level::LevelEvent;
 
 impl Game<'_> {
     pub(super) fn dragon_egg_particles(&mut self, pos: [i32; 3], data: i32) {
-        self.particles
-            .block_teleportation(pos, data, [16, 8, 16], self.settings.particles);
+        self.particles.block_teleportation(pos, data, [16, 8, 16]);
     }
     /// Event 2017: `TeleportRandomlyConsumeEffect`'s directional particles.
     pub(super) fn consume_teleport_particles(&mut self, pos: [i32; 3], data: i32) {
         self.particles
-            .block_teleportation(pos, data, [127, 127, 127], self.settings.particles);
+            .block_teleportation(pos, data, [127, 127, 127]);
     }
     /// `LevelEventHandler.levelEvent` 3002 to 3005, drawing from the client
     /// level's random.
diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs
index 897999c6b..b8a747624 100644
--- a/crates/horizon-client/src/game/remote_projectiles.rs
+++ b/crates/horizon-client/src/game/remote_projectiles.rs
@@ -452,7 +452,7 @@ impl Game<'_> {
                     ];
                     (c.particle.clone(), v)
                 };
-                self.particles.add(&options, at, velocity);
+                self.particles.add_with(&options, at, velocity, false, true);
             }
         }
     }
diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs
index e013c8d29..c9e4c6fb0 100644
--- a/crates/horizon-client/src/game/render_tick.rs
+++ b/crates/horizon-client/src/game/render_tick.rs
@@ -244,6 +244,7 @@ impl Game<'_> {
                 1.0,
             );
         }
+        self.particles.particle_level = self.settings.particles;
         if let Some(e) = eye {
             self.particles.camera = e;
         }
@@ -292,7 +293,8 @@ impl Game<'_> {
                 let mut random = LegacyRandom::new(self.world.game_time.wrapping_mul(312_987_231));
                 let radius = 10;
                 let diameter = 2 * radius + 1;
-                let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32;
+                let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32
+                    / if self.settings.particles == 1 { 2 } else { 1 };
                 for _ in 0..count {
                     let x = block[0] + random.next_int_bound(diameter).unwrap_or(0) - radius;
                     let z = block[2] + random.next_int_bound(diameter).unwrap_or(0) - radius;
@@ -304,6 +306,10 @@ impl Game<'_> {
                     {
                         continue;
                     }
+                    // The Minimal option stops at the first spot that rains.
+                    if self.settings.particles >= 2 {
+                        break;
+                    }
                     let below = top - 1;
                     let (bx, bz) = (random.next_double(), random.next_double());
                     let state = world.block(x, below, z);
diff --git a/crates/horizon-client/src/particles.rs b/crates/horizon-client/src/particles.rs
index fa9dc9c6e..1a5cd979b 100644
--- a/crates/horizon-client/src/particles.rs
+++ b/crates/horizon-client/src/particles.rs
@@ -1188,6 +1188,8 @@ pub struct ParticleEngine {
     emitters: Vec<(ParticleOptions, [f64; 3], f64, f64, u32)>,
     /// Camera position for the 32-block spawn limiter.
     pub camera: [f64; 3],
+    /// The Particles option (`ParticleStatus`): 0 all, 1 decreased, 2 minimal.
+    pub particle_level: u8,
     /// FireworkParticles.Starter instances.
     starters: Vec<Starter>,
     /// Local sounds requested by particles (dripstone drips): (event, position, volume, pitch).
@@ -1218,6 +1220,7 @@ impl ParticleEngine {
             emitters: Vec::new(),
             starters: Vec::new(),
             camera: [0.0; 3],
+            particle_level: 0,
             sounds: Vec::new(),
             made: Default::default(),
             item_sprites: HashMap::new(),
@@ -1328,30 +1331,48 @@ impl ParticleEngine {
         &mut self.level_random
     }
     /// `ClientLevel.addParticle`: dropped beyond 32 blocks of the camera unless
-    /// the type overrides the limiter.
+    /// the type overrides the limiter, and thinned by the Particles option.
     pub fn add(&mut self, options: &ParticleOptions, p: [f64; 3], v: [f64; 3]) {
+        self.add_with(options, p, v, false, false);
+    }
+    /// `ClientLevel.addParticle(particle, overrideLimiter, alwaysShow, ...)`
+    /// (`doAddParticle`). `always_show` is `addAlwaysVisibleParticle`'s flag.
+    pub fn add_with(
+        &mut self,
+        options: &ParticleOptions,
+        p: [f64; 3],
+        v: [f64; 3],
+        override_limiter: bool,
+        always_show: bool,
+    ) {
         let c = self.camera;
         let d2 = (p[0] - c[0]).powi(2) + (p[1] - c[1]).powi(2) + (p[2] - c[2]).powi(2);
         if let Some(requested) = &mut self.requested {
             requested.push((options.clone(), p, v));
             return;
         }
-        if !options.ty.override_limiter() && d2 > 1024.0 {
-            return;
+        let minimal = self.calculate_particle_level(always_show) == 2;
+        if override_limiter || options.ty.override_limiter() || (d2 <= 1024.0 && !minimal) {
+            self.create(options, p, v);
         }
-        self.create(options, p, v);
+    }
+    /// `ClientLevel.calculateParticleLevel`: minimal still shows one in ten
+    /// always-visible particles as decreased, and decreased drops a third.
+    fn calculate_particle_level(&mut self, always_show: bool) -> u8 {
+        let mut level = self.particle_level.min(2);
+        if always_show && level == 2 && self.level_random.next_int_bound(10).unwrap_or(0) == 0 {
+            level = 1;
+        }
+        if level == 1 && self.level_random.next_int_bound(3).unwrap_or(0) == 0 {
+            level = 2;
+        }
+        level
     }
     /// `LevelEventHandler.singleBlockTeleportationParticles` towards
     /// `BlockUtil.unpackDifferenceInPosition(from, data, radius)`: the dragon
     /// egg's event 2015 packs offsets within (16, 8, 16), a consumable's
     /// teleport (2017) within (127, 127, 127).
-    pub fn block_teleportation(
-        &mut self,
-        from: [i32; 3],
-        data: i32,
-        radius: [i32; 3],
-        particle_level: u8,
-    ) {
+    pub fn block_teleportation(&mut self, from: [i32; 3], data: i32, radius: [i32; 3]) {
         let to = [
             from[0].wrapping_add(((data >> 16) & 255) - radius[0]),
             from[1].wrapping_add(((data >> 8) & 255) - radius[1]),
@@ -1369,15 +1390,7 @@ impl ParticleEngine {
                 to[1] + t * (from[1] - to[1]) + r.next_double() - 0.5,
                 to[2] + t * (from[2] - to[2]) + (r.next_double() - 0.5) + 0.5,
             ];
-            // The option roll shares the level random and precedes the distance check.
-            let limited = match particle_level {
-                1 => r.next_int_bound(3).unwrap_or(0) == 0,
-                2 => true,
-                _ => false,
-            };
-            if !limited {
-                self.add(&options, position, velocity);
-            }
+            self.add(&options, position, velocity);
         }
     }
     /// `ClientPacketListener.handleExplosion` + `ClientExplosionTracker`: the
@@ -1406,6 +1419,10 @@ impl ParticleEngine {
         block_count: usize,
         is_air: &dyn Fn([i32; 3]) -> bool,
     ) {
+        // ClientExplosionTracker.tick: only the All option throws the debris.
+        if self.particle_level != 0 {
+            return;
+        }
         for _ in 0..block_count.min(512) {
             let r = &mut self.random;
             let d = Vec3::new(
@@ -3970,7 +3987,7 @@ mod tests {
         let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
         engine.seed_randoms(0, 0, 0);
         // Destination offset (-15, 7, 15); the unused top byte is ignored.
-        engine.block_teleportation([4, 12, -5], 0xff01_0f1fu32 as i32, [16, 8, 16], 0);
+        engine.block_teleportation([4, 12, -5], 0xff01_0f1fu32 as i32, [16, 8, 16]);
         assert_eq!(engine.pending.len(), 128);
         assert!(engine.pending.iter().all(|p| p.ty == ParticleType::Portal));
         let first = &engine.pending[0];
@@ -3997,7 +4014,7 @@ mod tests {
         // TeleportRandomlyConsumeEffect: BlockUtil.clampedPackDifferenceInPosition
         // of the move (-7, -3, 9) with radii 127, from (4, 12, -5) to (-3, 9, 4).
         let data = (-7 + 127) << 16 | (-3 + 127) << 8 | (9 + 127);
-        engine.block_teleportation([4, 12, -5], data, [127, 127, 127], 0);
+        engine.block_teleportation([4, 12, -5], data, [127, 127, 127]);
         assert_eq!(engine.pending.len(), 128);
         for p in &engine.pending {
             let [x, y, z] = p.position;
@@ -4023,7 +4040,8 @@ mod tests {
                 if distant {
                     engine.camera = [1000.0; 3];
                 }
-                engine.block_teleportation([4, 12, -5], 0x010f1f, [16, 8, 16], option);
+                engine.particle_level = option;
+                engine.block_teleportation([4, 12, -5], 0x010f1f, [16, 8, 16]);
                 assert_eq!(engine.pending.len(), if distant { 0 } else { count });
                 assert_eq!(engine.level_random.state(), state);
             }

From cb488cf51591d7a948b948bbcccc1c2123935823 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:29:18 +0100
Subject: [PATCH 319/475] Rain splashes follow the Weather Radius and the
 Weather option

Splashes always used a radius of 10 blocks; vanilla uses the Weather Radius
option. The Horizon Weather toggle now also stops the splashes and the rain
sound, not only the falling rain.
---
 crates/horizon-client/src/game.rs             | 15 +++++++++------
 crates/horizon-client/src/game/render_tick.rs |  7 ++++---
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 807a1d2cf..605732b3c 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -9910,12 +9910,15 @@ impl Game<'_> {
                 } else {
                     ("minecraft:weather.rain", 0.2, 1.0)
                 };
-                self.audio.play(
-                    name,
-                    Some([f64::from(x) + 0.5, f64::from(top), f64::from(z) + 0.5]),
-                    volume,
-                    pitch,
-                );
+                // The Horizon Weather option off silences the rain too.
+                if self.settings.horizon.weather {
+                    self.audio.play(
+                        name,
+                        Some([f64::from(x) + 0.5, f64::from(top), f64::from(z) + 0.5]),
+                        volume,
+                        pitch,
+                    );
+                }
             }
         }
     }
diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs
index e013c8d29..04c4660d8 100644
--- a/crates/horizon-client/src/game/render_tick.rs
+++ b/crates/horizon-client/src/game/render_tick.rs
@@ -287,10 +287,11 @@ impl Game<'_> {
                 e[2].floor() as i32,
             ];
             animate_tick(self.res.animate(), &mut self.particles, &ctx, block);
-            if rain > 0.0 {
-                // ClientLevel.tickWeatherEffects: rain splashes (weather radius 10).
+            // The Horizon Weather option off means no rain visuals at all.
+            if rain > 0.0 && self.settings.horizon.weather {
+                // ClientLevel.tickWeatherEffects: rain splashes within the weather radius.
                 let mut random = LegacyRandom::new(self.world.game_time.wrapping_mul(312_987_231));
-                let radius = 10;
+                let radius = self.settings.weather_radius;
                 let diameter = 2 * radius + 1;
                 let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32;
                 for _ in 0..count {

From 190cf4e0c27e3b2a8485c1706397d48771239015 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:30:03 +0100
Subject: [PATCH 320/475] Changing Chunk Builder sets the graphics preset to
 Custom

---
 crates/horizon-client/src/options_ui.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs
index 61fda9878..ac23bba9b 100644
--- a/crates/horizon-client/src/options_ui.rs
+++ b/crates/horizon-client/src/options_ui.rs
@@ -680,6 +680,7 @@ impl Opt {
                 | Opt::CutoutLeaves
                 | Opt::ImprovedTransparency
                 | Opt::MenuBlur
+                | Opt::ChunkBuilder
         )
     }
     /// Advance a cycle button (CycleButton.cycleValue).

From 1596b8429921fc07f98620908b61c6d21c90ab45 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:37:24 +0100
Subject: [PATCH 321/475] Create New World: the Game Rules button opens the
 rules screen and the choices are saved with the world

---
 crates/horizon-client/src/game.rs             |  4 +-
 crates/horizon-client/src/game/lan_screen.rs  |  8 +-
 .../horizon-client/src/game/startup_menu.rs   |  5 ++
 .../horizon-client/src/game/world_loading.rs  |  2 +
 .../src/{game => }/game_rules_screen.rs       | 68 +++++++++-------
 crates/horizon-client/src/lib.rs              |  1 +
 crates/horizon-client/src/title.rs            | 79 +++++++++++++++++++
 .../horizon-client/src/title/create_world.rs  |  8 +-
 crates/horizon-client/src/title/tests.rs      |  7 +-
 9 files changed, 140 insertions(+), 42 deletions(-)
 rename crates/horizon-client/src/{game => }/game_rules_screen.rs (91%)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index f9edd98bb..a82c23692 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -62,7 +62,6 @@ mod frames;
 mod friends;
 mod functions;
 mod game_mode;
-mod game_rules_screen;
 mod gamemode_switcher;
 mod ghasts;
 mod golems;
@@ -11879,7 +11878,8 @@ impl ApplicationHandler for Game<'_> {
                     let (action, sound) = self.title.as_mut().map_or((Action::None, false), |t| {
                         let clicked = t.click(self.cursor.0, self.cursor.1, (b.width, b.height));
                         t.press_field(atlas, self.cursor, (b.width, b.height), shift);
-                        clicked
+                        let rules = t.press_rules(atlas, self.cursor, (b.width, b.height));
+                        (clicked.0, clicked.1 || rules)
                     });
                     self.save_title_options();
                     if sound {
diff --git a/crates/horizon-client/src/game/lan_screen.rs b/crates/horizon-client/src/game/lan_screen.rs
index 260cc76c3..055d1ea1f 100644
--- a/crates/horizon-client/src/game/lan_screen.rs
+++ b/crates/horizon-client/src/game/lan_screen.rs
@@ -5,14 +5,10 @@
 //! forcing the game mode. Its difficulty lock asks first (PopupScreen), and
 //! Restrictions opens RestrictionsScreen.
 //! Parity reference: https://mcsrc.dev/2/26.3/net/minecraft/client/gui/screens/WorldOptionsScreen
-use super::{
-    Game, Screen,
-    game_rules_screen::{Exit, RulesScreen},
-    integrated::ServerOptions,
-    lan::LanSettings,
-};
+use super::{Game, Screen, integrated::ServerOptions, lan::LanSettings};
 use horizon_client::{
     font::Font,
+    game_rules_screen::{Exit, RulesScreen},
     hud::{HudBatch, rgba},
     text::{Text, named_color},
     ui::{self, EditBox},
diff --git a/crates/horizon-client/src/game/startup_menu.rs b/crates/horizon-client/src/game/startup_menu.rs
index ed5971324..fdeb726ae 100644
--- a/crates/horizon-client/src/game/startup_menu.rs
+++ b/crates/horizon-client/src/game/startup_menu.rs
@@ -546,6 +546,11 @@ impl Loading {
                             (batch.width, batch.height),
                             self.menu.modifiers.shift_key(),
                         );
+                        title.press_rules(
+                            &gui.atlas,
+                            self.menu.cursor,
+                            (batch.width, batch.height),
+                        );
                         self.menu_action(event_loop, action);
                     }
                 }
diff --git a/crates/horizon-client/src/game/world_loading.rs b/crates/horizon-client/src/game/world_loading.rs
index e9ee8e3e8..7aa55d21d 100644
--- a/crates/horizon-client/src/game/world_loading.rs
+++ b/crates/horizon-client/src/game/world_loading.rs
@@ -94,6 +94,8 @@ impl WorldRequest {
             level.difficulty = horizon_client::title::DIFFICULTIES[o.difficulty()].into();
             level.allow_commands = Some(o.commands(creative));
             horizon_client::save::write_world_gen_settings(&save_root, level.seed, o.world_gen())?;
+            // WorldCreationUiState.getGameRules, written with the level.
+            level.game_rules = o.rules.by_name();
         }
         // Worlds made without the Create New World screen (--world, the
         // control socket) take its default: commands on for Creative only.
diff --git a/crates/horizon-client/src/game/game_rules_screen.rs b/crates/horizon-client/src/game_rules_screen.rs
similarity index 91%
rename from crates/horizon-client/src/game/game_rules_screen.rs
rename to crates/horizon-client/src/game_rules_screen.rs
index 0992f7689..7f7c307b6 100644
--- a/crates/horizon-client/src/game/game_rules_screen.rs
+++ b/crates/horizon-client/src/game_rules_screen.rs
@@ -1,8 +1,9 @@
-//! InWorldGameRulesScreen (AbstractGameRulesScreen), opened from World
-//! Options: the rules by category under a search box, a switch or a number
-//! box each, and Done sending the changed ones (ServerboundSetGameRulePacket).
-//! Leaving with changes asks first (ConfirmScreen).
-use horizon_client::{
+//! AbstractGameRulesScreen: the rules by category under a search box, a
+//! switch or a number box each. InWorldGameRulesScreen, opened from World
+//! Options, sends the changed ones on Done (ServerboundSetGameRulePacket) and
+//! asks before leaving with changes (ConfirmScreen); WorldCreationGameRulesScreen,
+//! opened from Create New World, hands them back and leaves without asking.
+use crate::{
     confirm_screen::Confirm,
     font::Font,
     gamerules::{self, GameRules, RULES, Rule, Value},
@@ -32,14 +33,14 @@ enum Row {
 
 /// What a click or Escape asks of World Options.
 #[derive(Debug, PartialEq)]
-pub(super) enum Exit {
+pub enum Exit {
     /// Done: the rules that changed.
     Apply(Vec<(&'static str, Value)>),
     /// Cancel, or discarding the changes.
     Discard,
 }
 
-pub(super) struct RulesScreen {
+pub struct RulesScreen {
     search: EditBox,
     values: GameRules,
     initial: GameRules,
@@ -49,6 +50,8 @@ pub(super) struct RulesScreen {
     scroll: ui::Scroll,
     /// ConfirmScreen "Game Rule Changes" in its place.
     confirm: bool,
+    /// InWorldGameRulesScreen rather than WorldCreationGameRulesScreen.
+    in_world: bool,
 }
 
 fn name_key(r: &Rule) -> String {
@@ -102,7 +105,15 @@ fn confirm(font: &Font, size: (f32, f32)) -> Confirm {
 }
 
 impl RulesScreen {
-    pub(super) fn new(rules: &GameRules) -> Self {
+    /// InWorldGameRulesScreen over the world's rules.
+    pub fn new(rules: &GameRules) -> Self {
+        Self::build(rules, true)
+    }
+    /// WorldCreationGameRulesScreen over the new world's rules.
+    pub fn for_creation(rules: &GameRules) -> Self {
+        Self::build(rules, false)
+    }
+    fn build(rules: &GameRules, in_world: bool) -> Self {
         // setInitialFocus: the search box.
         let search = EditBox::new(0.0, 0.0, SEARCH_WIDTH, 15.0);
         let numbers = RULES
@@ -123,6 +134,7 @@ impl RulesScreen {
             numbers,
             scroll: ui::Scroll::default(),
             confirm: false,
+            in_world,
         }
     }
 
@@ -197,9 +209,10 @@ impl RulesScreen {
             })
             .collect()
     }
-    /// InWorldGameRulesScreen.onClose: pending changes ask first.
+    /// InWorldGameRulesScreen.onClose: pending changes ask first;
+    /// WorldCreationGameRulesScreen.onClose discards them.
     fn close(&mut self) -> Option<Exit> {
-        if self.changes().is_empty() {
+        if !self.in_world || self.changes().is_empty() {
             Some(Exit::Discard)
         } else {
             self.confirm = true;
@@ -207,7 +220,7 @@ impl RulesScreen {
         }
     }
     /// Escape: ConfirmScreen answers no; the rules close.
-    pub(super) fn escape(&mut self) -> Option<Exit> {
+    pub fn escape(&mut self) -> Option<Exit> {
         if self.confirm {
             self.confirm = false;
             None
@@ -216,7 +229,7 @@ impl RulesScreen {
         }
     }
     /// The mouse wheel (AbstractSelectionList: half an entry a step).
-    pub(super) fn wheel(&mut self, delta: f32, h: f32) {
+    pub fn wheel(&mut self, delta: f32, h: f32) {
         if !self.confirm {
             let content = self.content();
             self.scroll
@@ -224,20 +237,20 @@ impl RulesScreen {
         }
     }
     /// A press on the scrollbar holds it (AbstractSelectionList.updateScrolling).
-    pub(super) fn press_scrollbar(&mut self, cursor: (f32, f32), (w, h): (f32, f32)) -> bool {
+    pub fn press_scrollbar(&mut self, cursor: (f32, f32), (w, h): (f32, f32)) -> bool {
         let content = self.content();
         self.scroll
             .press(cursor, Self::bar(w), HEADER, h - FOOTER, content)
     }
     /// The pointer moved while the scrollbar is held.
-    pub(super) fn drag(&mut self, y: f32, h: f32) {
+    pub fn drag(&mut self, y: f32, h: f32) {
         if self.scroll.held() {
             let content = self.content();
             self.scroll.drag(y, HEADER, h - FOOTER, content);
         }
     }
     /// The button came up: the scrollbar lets go.
-    pub(super) fn release(&mut self) {
+    pub fn release(&mut self) {
         self.scroll.release();
     }
     fn focused(&mut self) -> Option<(Option<&'static str>, &mut EditBox)> {
@@ -272,7 +285,7 @@ impl RulesScreen {
         }
     }
     /// Run an edit on the focused box, then its responder.
-    pub(super) fn edit(&mut self, f: impl FnOnce(&mut EditBox)) {
+    pub fn edit(&mut self, f: impl FnOnce(&mut EditBox)) {
         let Some((rule, b)) = self.focused() else {
             return;
         };
@@ -282,12 +295,12 @@ impl RulesScreen {
             self.edited(rule);
         }
     }
-    pub(super) fn typing(&self) -> bool {
+    pub fn typing(&self) -> bool {
         !self.confirm && (self.search.focused || self.numbers.iter().any(|(_, b)| b.focused))
     }
 
     /// A left click; Some when the screen closes.
-    pub(super) fn click(
+    pub fn click(
         &mut self,
         atlas: &HudAtlas,
         cursor: (f32, f32),
@@ -355,12 +368,7 @@ impl RulesScreen {
         }
     }
     /// Whether a click lands on a button (for its sound).
-    pub(super) fn clicks_button(
-        &self,
-        atlas: &HudAtlas,
-        cursor: (f32, f32),
-        size: (f32, f32),
-    ) -> bool {
+    pub fn clicks_button(&self, atlas: &HudAtlas, cursor: (f32, f32), size: (f32, f32)) -> bool {
         let (w, h) = size;
         let on = |(x, y): (f32, f32)| ui::hovered(cursor, x, y, 150.0, 20.0);
         if self.confirm {
@@ -377,9 +385,9 @@ impl RulesScreen {
         })
     }
 
-    pub(super) fn draw(&mut self, batch: &mut HudBatch, atlas: &HudAtlas, cursor: (f32, f32)) {
+    pub fn draw(&mut self, batch: &mut HudBatch, atlas: &HudAtlas, cursor: (f32, f32)) {
         let (w, h) = (batch.width, batch.height);
-        ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true);
+        ui::menu_background(batch, atlas, 0.0, 0.0, w, h, self.in_world);
         if self.confirm {
             let labels = [
                 Text::translate("gui.yes", &[]),
@@ -393,7 +401,7 @@ impl RulesScreen {
         self.scroll.clamp(HEADER, h - FOOTER, content);
         // RuleList: the in-world list background, its entries clipped to it,
         // then the separators and scrollbar.
-        ui::list_background(batch, atlas, HEADER, h - FOOTER, true);
+        ui::list_background(batch, atlas, HEADER, h - FOOTER, self.in_world);
         let first = batch.vertices.len();
         let hovered = self.hovered(rows.len(), cursor, (w, h));
         let (left, x) = (row_left(w), control_x(w));
@@ -450,7 +458,7 @@ impl RulesScreen {
             }
         }
         batch.clip_since(first, 0.0, HEADER, w, h - FOOTER);
-        ui::separators(batch, atlas, HEADER, h - FOOTER, true);
+        ui::separators(batch, atlas, HEADER, h - FOOTER, self.in_world);
         ui::scrollbar(
             batch,
             atlas,
@@ -526,8 +534,8 @@ mod tests {
 
     #[test]
     fn box_colours_are_vanillas() {
-        assert_eq!(VALID, horizon_client::hud::rgba(224, 224, 224, 255));
-        assert_eq!(INVALID, horizon_client::hud::rgba(255, 0, 0, 255));
+        assert_eq!(VALID, crate::hud::rgba(224, 224, 224, 255));
+        assert_eq!(INVALID, crate::hud::rgba(255, 0, 0, 255));
     }
 
     #[test]
diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs
index ebfbdea58..c2b308817 100644
--- a/crates/horizon-client/src/lib.rs
+++ b/crates/horizon-client/src/lib.rs
@@ -79,6 +79,7 @@ pub mod fog;
 pub mod font;
 pub mod friends_screen;
 pub mod game_mode_switcher;
+pub mod game_rules_screen;
 pub mod gamepad;
 pub mod gamerules;
 pub mod gfx;
diff --git a/crates/horizon-client/src/title.rs b/crates/horizon-client/src/title.rs
index 87bd05fd0..9984cdcdf 100644
--- a/crates/horizon-client/src/title.rs
+++ b/crates/horizon-client/src/title.rs
@@ -1,6 +1,7 @@
 //! Title, world selection and world creation screens (TitleScreen,
 //! SelectWorldScreen, CreateWorldScreen layouts), drawn as HUD quads.
 use crate::{
+    game_rules_screen::{Exit, RulesScreen},
     hud::{HudAtlas, HudBatch, rgba},
     lang,
     save::Level,
@@ -144,6 +145,8 @@ pub struct Title {
     splash: Option<String>,
     /// The saves listed for Home, re-read every couple of seconds.
     recent: std::cell::RefCell<Option<(std::time::Instant, Vec<WorldEntry>)>>,
+    /// WorldCreationGameRulesScreen, over Create New World while it is open.
+    rules: RefCell<Option<RulesScreen>>,
 }
 pub(crate) struct Button {
     x: f32,
@@ -252,6 +255,7 @@ impl Title {
                 (today.month(), today.day()),
             ),
             recent: std::cell::RefCell::new(None),
+            rules: RefCell::new(None),
         }
     }
     /// Vanilla bypasses the selector when there are no saves.
@@ -360,6 +364,9 @@ impl Title {
     }
     /// The pointer moved with the button held (`mouseDragged`).
     pub fn drag(&mut self, cursor: (f32, f32), size: (f32, f32)) {
+        if let Some(rules) = self.rules.get_mut() {
+            return rules.drag(cursor.1, size.1.ceil());
+        }
         if let Mode::Multiplayer(screen) = &mut self.mode {
             return screen.drag(cursor.1, size);
         }
@@ -372,6 +379,9 @@ impl Title {
     }
     /// The button was released (`onRelease`).
     pub fn release(&mut self) {
+        if let Some(rules) = self.rules.get_mut() {
+            rules.release();
+        }
         if let Mode::Multiplayer(screen) = &mut self.mode {
             screen.release();
         }
@@ -379,6 +389,9 @@ impl Title {
     }
     /// Mouse wheel over the classic world and server lists.
     pub fn scroll_worlds(&mut self, delta: f32, cursor: (f32, f32), size: (f32, f32)) {
+        if let Some(rules) = self.rules.get_mut() {
+            return rules.wheel(delta, size.1.ceil());
+        }
         if let Mode::Multiplayer(screen) = &mut self.mode {
             screen.wheel(delta, cursor, size);
             return;
@@ -566,6 +579,10 @@ impl Title {
         folder
     }
     fn buttons(&self, w: f32, h: f32) -> Vec<Button> {
+        // The game rules draw and press their own.
+        if self.rules.borrow().is_some() {
+            return Vec::new();
+        }
         let (w, h) = (w.ceil(), h.ceil());
         let b = |x: f32, y: f32, w: f32, label: &str, enabled: bool, id: u8| Button {
             x,
@@ -814,6 +831,9 @@ impl Title {
         hide_splash: bool,
     ) {
         let (w, h) = (batch.width.ceil(), batch.height.ceil());
+        if let Some(rules) = self.rules.borrow_mut().as_mut() {
+            return rules.draw(batch, atlas, cursor);
+        }
         match &self.mode {
             Mode::Main => {
                 // LogoRenderer: the logo's top 44 of 64 rows, then the edition
@@ -1207,6 +1227,10 @@ impl Title {
     /// Navigation buttons can return `Action::None` while still sounding.
     pub fn click(&mut self, x: f32, y: f32, size: (f32, f32)) -> (Action, bool) {
         self.remember_direct_address();
+        // The game rules take the press in `press_rules`, which has the atlas.
+        if self.rules.get_mut().is_some() {
+            return (Action::None, false);
+        }
         let (w, h) = (size.0.ceil(), size.1.ceil());
         // MenuTabBar: a new tab clears the focus and clicks.
         if let Mode::Create { focus, options, .. } = &mut self.mode
@@ -1387,6 +1411,11 @@ impl Title {
                 self.mode = *return_to.clone();
                 Action::None
             }
+            // CreateWorldScreen.openGameRulesScreen over a copy of the rules.
+            (Mode::Create { options, .. }, Some(29)) => {
+                *self.rules.get_mut() = Some(RulesScreen::for_creation(&options.rules));
+                Action::None
+            }
             (
                 Mode::Create {
                     creative, options, ..
@@ -1410,6 +1439,9 @@ impl Title {
     }
     /// The focused text field, its id and maximum length (copy and paste).
     pub fn focused_field(&mut self) -> Option<(crate::clipboard::FieldId, &mut String, usize)> {
+        if self.rules.get_mut().is_some() {
+            return None;
+        }
         match &mut self.mode {
             Mode::Multiplayer(screen) => screen.focused_text(),
             mode => caret_field(mode, self.search_focused, &mut self.search),
@@ -1417,10 +1449,18 @@ impl Title {
     }
     /// Whether the focused field edits at its cursor.
     pub fn has_caret_field(&mut self) -> bool {
+        // The game rules' boxes edit themselves (`edit_field`).
+        if let Some(rules) = self.rules.get_mut() {
+            return rules.typing();
+        }
         caret_field(&mut self.mode, self.search_focused, &mut self.search).is_some()
     }
     /// Edit the focused field through its `EditBox`; false when there is none.
     fn edit_field(&mut self, f: impl FnOnce(&mut crate::ui::EditBox)) -> bool {
+        if let Some(rules) = self.rules.get_mut() {
+            rules.edit(f);
+            return rules.typing();
+        }
         let Some((id, value, max)) =
             caret_field(&mut self.mode, self.search_focused, &mut self.search)
         else {
@@ -1479,6 +1519,9 @@ impl Title {
         shift: bool,
     ) {
         let (w, h) = (size.0.ceil(), size.1.ceil());
+        if self.rules.get_mut().is_some() {
+            return;
+        }
         let Some(rect @ [fx, fy, fw, fh]) = self.focused_rect((w, h)) else {
             return;
         };
@@ -1491,6 +1534,9 @@ impl Title {
     }
     /// The pointer moved with the button held (`EditBox.onDrag`).
     pub fn drag_field(&mut self, atlas: &HudAtlas, x: f32) {
+        if self.rules.get_mut().is_some() {
+            return;
+        }
         if let Some(field) = caret_field(&mut self.mode, self.search_focused, &mut self.search) {
             self.caret.get_mut().drag(atlas, field, x);
         }
@@ -1527,6 +1573,9 @@ impl Title {
         }
     }
     pub fn tab(&mut self) {
+        if self.rules.get_mut().is_some() {
+            return;
+        }
         if let Mode::Edit { focused, .. } = &mut self.mode {
             *focused = !*focused;
         }
@@ -1576,7 +1625,37 @@ impl Title {
         }
         outcome
     }
+    /// A left press on the game rules (they need the atlas for text): whether
+    /// it lands on a button, for its sound.
+    pub fn press_rules(&mut self, atlas: &HudAtlas, cursor: (f32, f32), size: (f32, f32)) -> bool {
+        let size = (size.0.ceil(), size.1.ceil());
+        let Some(rules) = self.rules.get_mut() else {
+            return false;
+        };
+        let sound = rules.clicks_button(atlas, cursor, size);
+        let exit = rules.click(atlas, cursor, size);
+        if let Some(exit) = exit {
+            self.close_rules(exit);
+        }
+        sound
+    }
+    /// WorldCreationGameRulesScreen's exit callback: Done keeps the edited
+    /// rules (`setGameRules`), Cancel drops them.
+    fn close_rules(&mut self, exit: Exit) {
+        *self.rules.get_mut() = None;
+        if let (Exit::Apply(changes), Mode::Create { options, .. }) = (exit, &mut self.mode) {
+            for (name, value) in changes {
+                options.rules.set(name, value);
+            }
+        }
+    }
     pub fn escape(&mut self) {
+        if let Some(rules) = self.rules.get_mut() {
+            if let Some(exit) = rules.escape() {
+                self.close_rules(exit);
+            }
+            return;
+        }
         self.remember_direct_address();
         if let Mode::Multiplayer(screen) = &mut self.mode
             && !screen.escape(&self.saves)
diff --git a/crates/horizon-client/src/title/create_world.rs b/crates/horizon-client/src/title/create_world.rs
index a2fa6b8ce..65d4f60ac 100644
--- a/crates/horizon-client/src/title/create_world.rs
+++ b/crates/horizon-client/src/title/create_world.rs
@@ -34,6 +34,8 @@ pub struct WorldOptions {
     pub flat: bool,
     pub structures: bool,
     pub bonus_chest: bool,
+    /// `getGameRules`: the Game Rules screen's values, saved with the world.
+    pub rules: crate::gamerules::GameRules,
 }
 impl Default for WorldOptions {
     fn default() -> Self {
@@ -45,6 +47,7 @@ impl Default for WorldOptions {
             flat: false,
             structures: true,
             bonus_chest: false,
+            rules: crate::gamerules::GameRules::default(),
         }
     }
 }
@@ -66,6 +69,7 @@ impl WorldOptions {
             flat: generation.flat,
             structures: generation.structures,
             bonus_chest: generation.bonus_chest,
+            rules: crate::gamerules::GameRules::load(dir),
             ..Self::default()
         }
     }
@@ -263,7 +267,7 @@ pub(super) fn buttons(w: f32, h: f32, creative: bool, o: &WorldOptions) -> Vec<B
                 28,
             ),
         ],
-        // Game rules, experiments and data packs have no screens yet.
+        // Experiments and data packs have no screens yet.
         _ => [
             "selectWorld.gameRules",
             "selectWorld.experiments",
@@ -277,7 +281,7 @@ pub(super) fn buttons(w: f32, h: f32, creative: bool, o: &WorldOptions) -> Vec<B
                 gy + 28.0 * i as f32,
                 210.0,
                 tr(key),
-                false,
+                i == 0,
                 29 + i as u8,
             )
         })
diff --git a/crates/horizon-client/src/title/tests.rs b/crates/horizon-client/src/title/tests.rs
index fcaf68225..04fefe366 100644
--- a/crates/horizon-client/src/title/tests.rs
+++ b/crates/horizon-client/src/title/tests.rs
@@ -770,9 +770,12 @@ fn create_world_tabs_follow_vanilla_and_their_choices_reach_the_action() {
             bonus_chest: true
         }
     );
-    // The More tab's screens don't exist yet.
+    // The More tab's Experiments and Data Packs screens don't exist yet.
     f.title.click(54.0 + 248.0 + 10.0, 10.0, size);
-    assert!(labels(&f)[..3].iter().all(|b| !b.3));
+    assert_eq!(
+        labels(&f)[..3].iter().map(|b| b.3).collect::<Vec<_>>(),
+        [true, false, false]
+    );
 }
 
 #[test]

From 3f1181bab42d47842df9e45176fdc6b2ce5bcefb Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:37:48 +0100
Subject: [PATCH 322/475] Play player step sounds while crawling under a low
 ceiling

---
 crates/horizon-client/src/game.rs        | 7 ++++---
 crates/horizon-client/src/game/remote.rs | 3 +--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 7596ee871..a7bf12ca8 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4519,7 +4519,6 @@ impl Game<'_> {
             player.dimensions.eye_height
         };
         self.eye += (camera_eye.unwrap_or(eye_height) - self.eye) * 0.5;
-        let crouching = player.pose == horizon_client::pose::Pose::Crouching;
         // `ItemStack.hurtAndBreak` for the glide: Unbreaking can save the wear.
         if glider_wear > 0
             && !self.creative
@@ -4539,10 +4538,12 @@ impl Game<'_> {
                 MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, feet),
                 MotionEvent::Emission {
                     state, in_water, ..
-                } if !crouching => {
+                } => {
                     let sounds = self.res.facts().get(state).sounds.clone();
                     // Entity.playStepSound: the block's step sound at 0.15 volume,
-                    // muffled under the swim sound in water.
+                    // muffled under the swim sound in water. Whether it plays is
+                    // Player.getMovementEmission's call (shift on the ground),
+                    // not the pose: a forced crouch still steps.
                     let (volume, pitch) = if in_water {
                         (sounds.volume * 0.05, sounds.pitch * 0.8)
                     } else {
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..7e566319f 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3305,13 +3305,12 @@ impl Game<'_> {
         let events = std::mem::take(&mut player.events);
         self.previous_eye = self.eye;
         self.eye += (player.dimensions.eye_height - self.eye) * 0.5;
-        let crouching = player.pose == horizon_client::pose::Pose::Crouching;
         let feet = [player.position.x, player.position.y, player.position.z];
         for event in events {
             match event {
                 horizon_client::motion::MotionEvent::Emission {
                     state, in_water, ..
-                } if !crouching => {
+                } => {
                     let sounds = self.res.facts().get(state).sounds.clone();
                     // Player.playStepSound: muffled under the swim sound in water.
                     let (volume, pitch) = if in_water {

From 960b8aabad302a88f01a3e71b11bbdebfd7ad567 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:38:18 +0100
Subject: [PATCH 323/475] Villagers in an ongoing raid splash: send entity
 event 42

---
 crates/horizon-client/src/game/raids.rs | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs
index 743f02f44..d85e0509d 100644
--- a/crates/horizon-client/src/game/raids.rs
+++ b/crates/horizon-client/src/game/raids.rs
@@ -1036,6 +1036,7 @@ impl Game<'_> {
     /// read it).
     fn sync_villager_raids(&mut self, infos: &HashMap<i32, Vec<RaiderInfo>>) {
         let raids = &self.raiding.raids;
+        let mut ongoing = Vec::new();
         for m in &mut self.mobs {
             if m.species() != Species::Villager {
                 continue;
@@ -1061,7 +1062,27 @@ impl Game<'_> {
             let ext = mobs_villager::ext_mut(m);
             ext.raid = status;
             ext.raid_wave = wave;
+            if !m.no_ai && matches!(status, mobs_villager::PRE_RAID | mobs_villager::RAID) {
+                ongoing.push(m.id);
+            }
         }
+        // Villager.customServerAiStep: a 1 in 100 chance each tick, in an
+        // ongoing raid, of entity event 42 (`handleEntityEvent` splashes).
+        for id in ongoing {
+            if self.particles.random().next_int_bound(100) == Ok(0) {
+                self.mob_raid_splash(id);
+            }
+        }
+    }
+    /// Entity event 42 for villager `id`: the guests get the byte, and this
+    /// game draws `AbstractVillager.addParticlesAroundSelf(SPLASH)` itself.
+    fn mob_raid_splash(&mut self, id: u32) {
+        let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
+            return;
+        };
+        let at = [m.position.x, m.position.y, m.position.z];
+        self.lan_entity_event(id as i32, 42, at);
+        self.particles_around_mob(id, "splash", horizon_client::particles::Burst::VILLAGER);
     }
 
     /// The raid bar a living player at `at` is in (`Raid.getPlayers`): red,

From 00e15171d5ffd2ebb8f26ff823489f62ae8cb1ac Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:38:21 +0100
Subject: [PATCH 324/475] Draw the smoke trail behind wither skulls and
 fireballs, and the wither's head smoke on a client

---
 crates/horizon-client/src/game/creatures.rs   |  6 ++++
 crates/horizon-client/src/game/remote.rs      | 17 +++++++++++
 .../src/game/remote_projectiles.rs            | 28 +++++++++++++++++++
 crates/horizon-client/src/mobs/wither.rs      |  2 +-
 4 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index f6961ab13..3a779e5c4 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1850,6 +1850,7 @@ impl Game<'_> {
         let mut hits = Vec::new();
         let mut deflections: Vec<[f64; 3]> = Vec::new();
         let mut arrow_events = Vec::new();
+        let mut trails = Vec::new();
         {
             let mut targets: Vec<(Who, Aabb)> = self
                 .mobs
@@ -1941,6 +1942,10 @@ impl Game<'_> {
                 if shooter.is_some() {
                     p.owner = Some(Who::Player);
                 }
+                // AbstractHurtingProjectile.tick ends with createParticleTrail.
+                if super::remote_projectiles::has_smoke_trail(&p.kind) {
+                    trails.push(p.position);
+                }
                 if let Some(a) = p.arrow.as_mut() {
                     arrow_events.extend(a.events.drain(..).map(|e| (p.position, e)));
                 }
@@ -1983,6 +1988,7 @@ impl Game<'_> {
                 keep
             });
         }
+        self.smoke_trails(trails);
         for at in deflections {
             self.audio
                 .play("minecraft:entity.breeze.deflect", Some(at), 1.0, 1.0);
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..1790f8500 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3492,11 +3492,15 @@ impl Game<'_> {
         let head_lerps = &mut r.head_lerps;
         let players = &r.level_players;
         let mut using = Vec::new();
+        let mut wither_heads = Vec::new();
         for m in &mut self.mobs {
             let player = players.contains_key(&(m.id as i32));
             if !running && !player {
                 continue;
             }
+            if m.species() == horizon_client::mobs::Species::Wither {
+                wither_heads.extend((0..3).map(|i| horizon_client::mobs::wither::head_pos(m, i)));
+            }
             m.previous = m.position;
             m.previous_yaw = m.yaw;
             m.previous_body_yaw = m.body_yaw;
@@ -3613,6 +3617,19 @@ impl Game<'_> {
             d.tick(world, facts, collision, false, &self.res.motion().fluids);
         }
         head_lerps.retain(|_, (_, steps)| *steps > 0);
+        // WitherBoss.aiStep runs on a client too: smoke around each head.
+        let smoke = horizon_client::particles::ParticleOptions::simple(
+            horizon_client::particles::ParticleType::Smoke,
+        );
+        for h in wither_heads {
+            let r = self.particles.random();
+            let at = [
+                h[0] + r.next_gaussian() * 0.3,
+                h[1] + r.next_gaussian() * 0.3,
+                h[2] + r.next_gaussian() * 0.3,
+            ];
+            self.particles.add(&smoke, at, [0.0; 3]);
+        }
         for (item, ticks, at, eye, pitch, yaw) in using {
             self.remote_player_eating(&item, ticks, at, eye, pitch, yaw);
         }
diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs
index 897999c6b..c4adc8be7 100644
--- a/crates/horizon-client/src/game/remote_projectiles.rs
+++ b/crates/horizon-client/src/game/remote_projectiles.rs
@@ -78,7 +78,27 @@ fn remote_arrow_tick(p: &mut Projectile, w: &impl ProjectileWorld) {
     p.velocity.y -= 0.05;
 }
 
+/// `AbstractHurtingProjectile.getTrailParticle`: smoke for every one of them
+/// but the wind charges (no trail) and the dragon's fireball (its own).
+pub(super) fn has_smoke_trail(kind: &ProjectileKind) -> bool {
+    matches!(
+        kind,
+        ProjectileKind::SmallFireball
+            | ProjectileKind::LargeFireball { .. }
+            | ProjectileKind::WitherSkull { .. }
+    )
+}
+
 impl Game<'_> {
+    /// `AbstractHurtingProjectile.createParticleTrail`: one smoke puff half a
+    /// block above each position.
+    pub(super) fn smoke_trails(&mut self, at: impl IntoIterator<Item = Vec3>) {
+        let smoke = ParticleOptions::simple(ParticleType::Smoke);
+        for p in at {
+            self.particles.add(&smoke, [p.x, p.y + 0.5, p.z], [0.0; 3]);
+        }
+    }
+
     /// `handleAddEntity` for these types; false when `kind` isn't one.
     pub(super) fn spawn_remote_projectile(
         &mut self,
@@ -350,6 +370,14 @@ impl Game<'_> {
             }
         }
         self.creatures.projectiles = projectiles;
+        let trails: Vec<Vec3> = self
+            .creatures
+            .projectiles
+            .iter()
+            .filter(|p| has_smoke_trail(&p.kind))
+            .map(|p| p.position)
+            .collect();
+        self.smoke_trails(trails);
         for t in &mut self.tridents {
             let id = t.id;
             t.remote_step(|at| step(id, at));
diff --git a/crates/horizon-client/src/mobs/wither.rs b/crates/horizon-client/src/mobs/wither.rs
index 6702686c5..6c3316ac7 100644
--- a/crates/horizon-client/src/mobs/wither.rs
+++ b/crates/horizon-client/src/mobs/wither.rs
@@ -96,7 +96,7 @@ pub fn make_invulnerable(m: &mut Mob) {
 pub fn powered(m: &Mob) -> bool {
     m.health <= m.attrs.max_health / 2.0
 }
-fn head_pos(m: &Mob, i: usize) -> [f64; 3] {
+pub fn head_pos(m: &Mob, i: usize) -> [f64; 3] {
     if i == 0 {
         return [m.position.x, m.position.y + 3.0, m.position.z];
     }

From 1d93086e33a212b3a263f459fdb75d61e5895e49 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:39:50 +0100
Subject: [PATCH 325/475] Ease the night vision pulse with the partial tick

The last 10 seconds of Night Vision pulse in brightness. Vanilla reads the pulse at (duration - partial tick), so it eases between ticks. Horizon used the whole tick count, so the brightness stepped once per tick.
---
 crates/horizon-client/src/game.rs       | 2 +-
 crates/horizon-client/src/game/sculk.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 7596ee871..e568fa5a9 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -10990,7 +10990,7 @@ impl Game<'_> {
             }),
             ticks: self.ticks,
             darkness: self.darkness_lighting(alpha as f32),
-            night_vision: self.night_vision_intensity(),
+            night_vision: self.night_vision_intensity(alpha as f32),
             block_flicker: self.fog.block_light_flicker,
             boss_darken: self
                 .boss_overlay
diff --git a/crates/horizon-client/src/game/sculk.rs b/crates/horizon-client/src/game/sculk.rs
index 7916c46a1..473509f0a 100644
--- a/crates/horizon-client/src/game/sculk.rs
+++ b/crates/horizon-client/src/game/sculk.rs
@@ -1194,14 +1194,14 @@ impl Game<'_> {
 
     /// `LightmapRenderStateExtractor`: the night vision effect's intensity
     /// (`GameRenderer.nightVisionScale`), or conduit power's water vision.
-    pub(super) fn night_vision_intensity(&self) -> f32 {
+    pub(super) fn night_vision_intensity(&self, partial: f32) -> f32 {
         use horizon_client::fog::FogType;
         if let Some(e) = self.potions.effects.get("night_vision") {
             // MobEffectInstance.endsWithin(200); -1 is infinite.
             return if e.duration < 0 || e.duration > 200 {
                 1.0
             } else {
-                0.7 + (e.duration as f32 * std::f32::consts::PI * 0.2).sin() * 0.3
+                0.7 + ((e.duration as f32 - partial) * std::f32::consts::PI * 0.2).sin() * 0.3
             };
         }
         if self.potions.effects.get("conduit_power").is_some()

From f2856845f43b812191bd561b6237d9ca2a1fd8a1 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:40:27 +0100
Subject: [PATCH 326/475] Stop End flashes lighting the scene when Hide
 Lightning Flashes is on

Vanilla only adds the End flash to the sky light factor while the option is off. Horizon added it every time.
---
 crates/horizon-client/src/game/end.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs
index 32d5113b0..b34a86183 100644
--- a/crates/horizon-client/src/game/end.rs
+++ b/crates/horizon-client/src/game/end.rs
@@ -253,9 +253,10 @@ impl Game<'_> {
         out
     }
 
-    /// LightmapRenderStateExtractor: End flashes add to the sky light factor.
+    /// LightmapRenderStateExtractor: End flashes add to the sky light factor
+    /// unless Hide Lightning Flashes is on (the sky sprite is not gated).
     pub(super) fn end_flash_sky(&self, sky: &mut horizon_client::environment::Sky, partial: f64) {
-        if self.dim == Dim::End {
+        if self.dim == Dim::End && !self.settings.file.bool("hideLightningFlashes") {
             sky.sky_light_factor += self.end.flash.intensity(partial as f32);
         }
     }

From 426b3c83cf6a749e6966528bc90baab7ca6d658a Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:40:47 +0100
Subject: [PATCH 327/475] Play the sand idle and poplar leaves ambient sounds

---
 crates/horizon-client/src/animate_tick.rs | 135 +++++++++++++++++++---
 1 file changed, 122 insertions(+), 13 deletions(-)

diff --git a/crates/horizon-client/src/animate_tick.rs b/crates/horizon-client/src/animate_tick.rs
index 28b28544b..0160071d9 100644
--- a/crates/horizon-client/src/animate_tick.rs
+++ b/crates/horizon-client/src/animate_tick.rs
@@ -35,8 +35,9 @@ enum Animate {
     Campfire {
         spawn_particles: bool,
     },
-    /// Leaves: optional falling-leaf particle and chance, tinted by foliage.
-    Leaves(Option<(T, f32)>),
+    /// Leaves: optional falling-leaf particle and chance, tinted by foliage; and
+    /// whether they have the poplar ambient sound (`AmbientLeavesBlockSoundPlayer`).
+    Leaves(Option<(T, f32)>, bool),
     NetherPortal,
     EnchantingTable,
     EndRod([i32; 3]),
@@ -47,8 +48,9 @@ enum Animate {
     CandleCake,
     BrewingStand,
     EnderChest,
-    /// FallingBlock with its dust colour.
-    Falling(u32),
+    /// FallingBlock with its dust colour; sand also has the ambient desert sound
+    /// (`SandBlock.animateTick`).
+    Falling(u32, bool),
     RedstoneOre,
     RedstoneWire {
         power: u8,
@@ -104,10 +106,15 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
             spawn_particles: false,
         },
         "oak_leaves" | "birch_leaves" | "jungle_leaves" | "acacia_leaves" | "dark_oak_leaves"
-        | "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01))),
-        "cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1))),
-        "pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02))),
-        "spruce_leaves" | "azalea_leaves" | "flowering_azalea_leaves" => Animate::Leaves(None),
+        | "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01)), false),
+        "cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1)), false),
+        "pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02)), false),
+        "red_poplar_leaves" => Animate::Leaves(Some((T::RedPoplarLeaves, 0.01)), true),
+        "orange_poplar_leaves" => Animate::Leaves(Some((T::OrangePoplarLeaves, 0.01)), true),
+        "yellow_poplar_leaves" => Animate::Leaves(Some((T::YellowPoplarLeaves, 0.01)), true),
+        "spruce_leaves" | "azalea_leaves" | "flowering_azalea_leaves" => {
+            Animate::Leaves(None, false)
+        }
         "nether_portal" => Animate::NetherPortal,
         "enchanting_table" => Animate::EnchantingTable,
         "end_rod" => Animate::EndRod(facing()),
@@ -116,9 +123,9 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
         "mycelium" => Animate::Mycelium,
         "brewing_stand" => Animate::BrewingStand,
         "ender_chest" => Animate::EnderChest,
-        "sand" => Animate::Falling(0xDBD3A0),
-        "red_sand" => Animate::Falling(0xA95821),
-        "gravel" => Animate::Falling(0x807C7B),
+        "sand" => Animate::Falling(0xDBD3A0, true),
+        "red_sand" => Animate::Falling(0xA95821, true),
+        "gravel" => Animate::Falling(0x807C7B, false),
         "redstone_ore" | "deepslate_redstone_ore" if lit => Animate::RedstoneOre,
         "redstone_wire" => {
             let power = prop("power").and_then(|p| p.parse().ok()).unwrap_or(0);
@@ -194,6 +201,10 @@ pub struct AnimateTables {
     power_transmitter: Vec<bool>,
     /// `#triggers_ambient_dried_ghast_block_sounds` (soul sand, soul soil).
     dried_ghast_sounds: Vec<bool>,
+    /// `#triggers_ambient_desert_sand_block_sounds` (sand, red sand).
+    desert_sand_sounds: Vec<bool>,
+    /// `#required_for_poplar_leaf_ambience` (overworld natural logs).
+    poplar_leaf_logs: Vec<bool>,
     /// `FireBlock.canBurn`: states with ignite odds above zero (none waterlogged).
     burnable: Vec<bool>,
     /// Biome id -> ambient particles and probabilities (`minecraft:visual/ambient_particles`).
@@ -269,6 +280,8 @@ impl AnimateTables {
             power_provider: by_state("minecraft:enchantment_power_provider"),
             power_transmitter: by_state("minecraft:enchantment_power_transmitter"),
             dried_ghast_sounds: by_state("minecraft:triggers_ambient_dried_ghast_block_sounds"),
+            desert_sand_sounds: by_state("minecraft:triggers_ambient_desert_sand_block_sounds"),
+            poplar_leaf_logs: by_state("minecraft:required_for_poplar_leaf_ambience"),
             burnable,
             ambient,
         })
@@ -685,7 +698,7 @@ fn block_animate_tick(
                 }
             }
         }
-        Animate::Leaves(falling) => {
+        Animate::Leaves(falling, poplar) => {
             let below = [pos[0], pos[1] - 1, pos[2]];
             // LeavesBlock.makeDrippingWaterParticles.
             if (ctx.raining_at)([pos[0], pos[1] + 1, pos[2]]) && next_int(engine.random(), 15) == 1
@@ -697,6 +710,9 @@ fn block_animate_tick(
                     add(engine, T::DrippingWater, p, [0.0; 3]);
                 }
             }
+            if poplar {
+                leaves_ambient_sound(tables, engine, ctx, state, pos);
+            }
             // FallingParticlesLeavesBlock.makeFallingLeavesParticles.
             if let Some((ty, chance)) = falling
                 && engine.random().next_float() < chance
@@ -959,7 +975,7 @@ fn block_animate_tick(
                 add(engine, T::Portal, p, v);
             }
         }
-        Animate::Falling(color) => {
+        Animate::Falling(color, sand) => {
             if next_int(engine.random(), 16) == 0 {
                 let below = ctx.facts.get(ctx.state([pos[0], pos[1] - 1, pos[2]]));
                 // FallingBlock.isFree: air, fire, liquids or replaceable.
@@ -976,6 +992,14 @@ fn block_animate_tick(
                     );
                 }
             }
+            // AmbientDesertBlockSoundsPlayer.playAmbientSandSounds: only for the air block.
+            if sand
+                && ctx.state([pos[0], pos[1] + 1, pos[2]]) == ctx.world.air
+                && next_int(engine.random(), 2100) == 0
+                && sand_sound_nearby(tables, ctx, pos)
+            {
+                sound(engine, "minecraft:block.sand.idle", [fx, fy, fz], 1.0, 1.0);
+            }
         }
         Animate::RedstoneOre => {
             for d in [
@@ -1190,6 +1214,91 @@ fn block_animate_tick(
     }
 }
 /// `AbstractCandleBlock.addParticlesAndSound`.
+/// `AmbientLeavesBlockSoundPlayer.playAmbientLeavesSounds` for the poplar leaves:
+/// one log and three leaves of the same kind around the block.
+fn leaves_ambient_sound(
+    tables: &AnimateTables,
+    engine: &mut ParticleEngine,
+    ctx: &AnimateContext,
+    state: BlockStateId,
+    pos: [i32; 3],
+) {
+    if next_int(engine.random(), 300) != 0 {
+        return;
+    }
+    let Some(name) = ctx.registry.state(state).map(|s| &s.name) else {
+        return;
+    };
+    let (mut logs, mut leaves) = (0, 0);
+    for d in [[0, -1], [1, 0], [0, 1], [-1, 0]] {
+        let neighbor = ctx.state([pos[0] + d[0], pos[1], pos[2] + d[1]]);
+        if tables
+            .poplar_leaf_logs
+            .get(neighbor.0 as usize)
+            .copied()
+            .unwrap_or(false)
+        {
+            logs += 1;
+        }
+        if ctx
+            .registry
+            .state(neighbor)
+            .is_some_and(|s| &s.name == name)
+        {
+            leaves += 1;
+        }
+        if logs == 1 && leaves == 3 {
+            let p = pos.map(f64::from);
+            sound(engine, "minecraft:block.poplar_leaves.ambient", p, 1.0, 1.0);
+            return;
+        }
+    }
+}
+/// `AmbientDesertBlockSoundsPlayer.shouldPlayAmbientSandSound`: sand in the
+/// surface column eight blocks away on all four sides.
+fn sand_sound_nearby(tables: &AnimateTables, ctx: &AnimateContext, pos: [i32; 3]) -> bool {
+    let is_sand = |p: [i32; 3]| {
+        tables
+            .desert_sand_sounds
+            .get(ctx.state(p).0 as usize)
+            .copied()
+            .unwrap_or(false)
+    };
+    let (mut found, mut checked) = (0, 0);
+    for d in [[0, -8], [8, 0], [0, 8], [-8, 0]] {
+        let (x, z) = (pos[0] + d[0], pos[2] + d[1]);
+        // columnContainsTriggeringBlock.
+        let surface = ctx.world.world_surface(x, z, |s| ctx.facts.is_air(s)) - 1;
+        let matches = if (surface - pos[1]).abs() > 5 {
+            let mut y = pos[1] + 6;
+            let mut above_air = ctx.is_air([x, y, z]);
+            y -= 1;
+            let mut hit = false;
+            for _ in 0..10 {
+                if above_air && is_sand([x, y, z]) {
+                    hit = true;
+                    break;
+                }
+                above_air = ctx.is_air([x, y, z]);
+                y -= 1;
+            }
+            hit
+        } else {
+            ctx.is_air([x, surface + 1, z]) && is_sand([x, surface, z])
+        };
+        if matches {
+            found += 1;
+            if found > 3 {
+                return true;
+            }
+        }
+        checked += 1;
+        if 4 - checked + found < 3 {
+            return false;
+        }
+    }
+    false
+}
 fn candle(engine: &mut ParticleEngine, p: [f64; 3]) {
     let r = engine.random();
     let chance = r.next_float();

From 7673d38ed77042a3972d2040524231410e1564c4 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:41:23 +0100
Subject: [PATCH 328/475] Play the amethyst chime when walking on amethyst
 blocks

---
 crates/horizon-client/src/game.rs        |  8 +++++
 crates/horizon-client/src/game/remote.rs |  8 +++++
 crates/horizon-client/src/motion.rs      | 38 ++++++++++++++++++++++++
 3 files changed, 54 insertions(+)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 7596ee871..748e66d44 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4554,6 +4554,14 @@ impl Game<'_> {
                     self.audio
                         .play("minecraft:entity.player.swim", Some(feet), volume, pitch);
                 }
+                MotionEvent::Chime { volume, pitch } => {
+                    self.audio.play(
+                        "minecraft:block.amethyst_block.chime",
+                        Some(feet),
+                        volume,
+                        pitch,
+                    );
+                }
                 MotionEvent::Drown => {
                     // LivingEntity.makeDrownParticles: eight bubbles moving
                     // with the player.
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..ff5d170e6 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3325,6 +3325,14 @@ impl Game<'_> {
                     self.audio
                         .play("minecraft:entity.player.swim", Some(feet), volume, pitch);
                 }
+                horizon_client::motion::MotionEvent::Chime { volume, pitch } => {
+                    self.audio.play(
+                        "minecraft:block.amethyst_block.chime",
+                        Some(feet),
+                        volume,
+                        pitch,
+                    );
+                }
                 // NetherPortalBlock.entityInside on the client's own level:
                 // the portal overlay and its trigger sound (the server moves
                 // the player).
diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index 234390e23..e654b6c5b 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -53,6 +53,8 @@ pub struct MotionResources {
     /// `BlockTags.CAN_GLIDE_THROUGH`: climbable blocks a gliding player passes.
     pub glide_through: BTreeSet<String>,
     pub fall_reset: BTreeSet<String>,
+    /// `BlockTags.CRYSTAL_SOUND_BLOCKS`: blocks that chime under footsteps.
+    pub crystal_sound: BTreeSet<String>,
     pub landing: BlockLandingRegistry,
     pub health: crate::health::HealthResources,
     pub fluids: FluidResources,
@@ -112,6 +114,7 @@ impl MotionResources {
             climbable: tag("minecraft:climbable")?,
             glide_through: tag("minecraft:can_glide_through")?,
             fall_reset: tag("minecraft:fall_damage_resetting")?,
+            crystal_sound: tag("minecraft:crystal_sound_blocks")?,
         })
     }
 }
@@ -145,6 +148,11 @@ pub enum MotionEvent {
         state: BlockStateId,
         in_water: bool,
     },
+    /// `Entity.playAmethystStepSound`: `block.amethyst_block.chime`.
+    Chime {
+        volume: f32,
+        pitch: f32,
+    },
     /// `Entity.waterSwimSound`: `entity.player.swim`.
     Swim {
         volume: f32,
@@ -279,6 +287,10 @@ pub struct PlayerMotion {
     /// `Entity.moveDist`, `flyDist` and `nextStep`: footsteps come once per
     /// metre walked, not once per move.
     pub steps: MovementDistances,
+    /// `Entity.crystalSoundIntensity` and `lastCrystalSoundPlayTick`: the
+    /// amethyst chime grows with steps taken close together.
+    pub crystal_sound_intensity: f32,
+    pub last_crystal_sound_play_tick: i32,
     pub needs_sync: bool,
     pub sync_position: bool,
     /// Moved by an ender pearl (`ServerPlayer.teleport`): a server sends the
@@ -470,6 +482,8 @@ impl PlayerMotion {
                 next_step: 1.0,
                 ..MovementDistances::default()
             },
+            crystal_sound_intensity: 0.0,
+            last_crystal_sound_play_tick: 0,
             needs_sync: false,
             sync_position: false,
             teleported: false,
@@ -2065,6 +2079,30 @@ impl MovementEmissionWorld for MotionWorld<'_, '_, '_> {
             state,
             in_water,
         });
+        // Entity.walkingStepSound: the amethyst chime after the step.
+        let name = &self
+            .assets
+            .registry
+            .state(state)
+            .ok_or("missing scene state")?
+            .name;
+        let tick = self.player.health.tick_count;
+        if self.resources.crystal_sound.contains(name)
+            && tick >= self.player.last_crystal_sound_play_tick + 20
+        {
+            // Entity.playAmethystStepSound (the level random stands in for
+            // the entity's).
+            let elapsed = f64::from(tick - self.player.last_crystal_sound_play_tick);
+            let decayed = self.player.crystal_sound_intensity * 0.997_f64.powf(elapsed) as f32;
+            let intensity = 1.0_f32.min(decayed + 0.07);
+            self.player.crystal_sound_intensity = intensity;
+            let pitch = 0.5 + intensity * self.scene.random.next_float() * 1.2;
+            let volume = 0.1 + intensity * 1.2;
+            self.player
+                .events
+                .push(MotionEvent::Chime { volume, pitch });
+            self.player.last_crystal_sound_play_tick = tick;
+        }
         Ok(())
     }
     fn step_event(&mut self, _: BlockStateId) -> Result<()> {

From 861e7279e09e40073b2c0191f995299e3626ae5f Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:41:57 +0100
Subject: [PATCH 329/475] Drip water from wet sponges and dust from suspicious
 sand and gravel

Wet sponges now drip water from their sides and bottom like
WetSpongeBlock.animateTick, and suspicious sand and gravel now shed
falling dust in their map colour when nothing is below them.
---
 crates/horizon-client/src/animate_tick.rs | 36 +++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/crates/horizon-client/src/animate_tick.rs b/crates/horizon-client/src/animate_tick.rs
index 28b28544b..d8195e44e 100644
--- a/crates/horizon-client/src/animate_tick.rs
+++ b/crates/horizon-client/src/animate_tick.rs
@@ -70,6 +70,8 @@ enum Animate {
         waterlogged: bool,
     },
     EndPortal,
+    /// `WetSpongeBlock.animateTick`.
+    WetSponge,
 }
 fn step(facing: &str) -> [i32; 3] {
     match facing {
@@ -149,6 +151,10 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
             waterlogged: prop("waterlogged").as_deref() == Some("true"),
         },
         "end_portal" => Animate::EndPortal,
+        "wet_sponge" => Animate::WetSponge,
+        // BrushableBlock has no dust colour of its own, so the dust is the map colour.
+        "suspicious_sand" => Animate::Falling(0xF7E9A3),
+        "suspicious_gravel" => Animate::Falling(0x707070),
         "sculk_sensor" | "calibrated_sculk_sensor"
             if prop("sculk_sensor_phase").as_deref() == Some("active") =>
         {
@@ -877,6 +883,36 @@ fn block_animate_tick(
                 }
             }
         }
+        Animate::WetSponge => {
+            // Direction.getRandom: DOWN, UP, NORTH, SOUTH, WEST, EAST.
+            const DIRECTIONS: [[i32; 3]; 6] = [
+                [0, -1, 0],
+                [0, 1, 0],
+                [0, 0, -1],
+                [0, 0, 1],
+                [-1, 0, 0],
+                [1, 0, 0],
+            ];
+            let d = DIRECTIONS[next_int(engine.random(), 6) as usize];
+            // The sponge occludes, so only a sturdy neighbour face hides the drip.
+            if d != [0, 1, 0] && !ctx.sturdy([pos[0] + d[0], pos[1] + d[1], pos[2] + d[2]]) {
+                let r = engine.random();
+                let p = match d {
+                    [0, -1, 0] => [fx + r.next_double(), fy - 0.05, fz + r.next_double()],
+                    [dx, _, 0] => {
+                        let y = fy + r.next_double() * 0.8;
+                        let z = fz + r.next_double();
+                        [fx + if dx > 0 { 1.1 } else { 0.05 }, y, z]
+                    }
+                    [_, _, dz] => {
+                        let y = fy + r.next_double() * 0.8;
+                        let x = fx + r.next_double();
+                        [x, y, fz + if dz > 0 { 1.1 } else { 0.05 }]
+                    }
+                };
+                add(engine, T::DrippingWater, p, [0.0; 3]);
+            }
+        }
         Animate::Mycelium => {
             let r = engine.random();
             if next_int(r, 10) == 0 {

From 57e8de0007d63eee598d96c3f9a305659f39327d Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:42:59 +0100
Subject: [PATCH 330/475] Send the drowning entity event (67) and draw the
 bubbles on clients

---
 crates/horizon-client/src/game.rs             | 23 +++-------
 crates/horizon-client/src/game/combat.rs      | 43 ++++++++++++++++++-
 crates/horizon-client/src/game/creatures.rs   |  9 ++++
 crates/horizon-client/src/game/lan_actions.rs |  9 ++++
 crates/horizon-client/src/game/remote.rs      |  3 ++
 crates/horizon-client/src/mobs.rs             |  6 +++
 crates/horizon-client/src/mobs/ai.rs          |  4 ++
 7 files changed, 78 insertions(+), 19 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 7596ee871..96da5c51c 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4555,25 +4555,12 @@ impl Game<'_> {
                         .play("minecraft:entity.player.swim", Some(feet), volume, pitch);
                 }
                 MotionEvent::Drown => {
-                    // LivingEntity.makeDrownParticles: eight bubbles moving
-                    // with the player.
-                    use horizon_client::particles::{ParticleOptions, ParticleType};
-                    for _ in 0..8 {
-                        let mut triangle = || {
-                            let r = self.particles.random();
-                            r.next_double() - r.next_double()
-                        };
-                        let p = [
-                            feet[0] + triangle(),
-                            feet[1] + triangle(),
-                            feet[2] + triangle(),
-                        ];
-                        self.particles.add(
-                            &ParticleOptions::simple(ParticleType::Bubble),
-                            p,
-                            player_velocity,
-                        );
+                    // The guests see the entity event 67 too.
+                    if let Some(host) = &self.lan {
+                        host.hub
+                            .entity_event(host.host_entity, combat::DROWN_EVENT, feet);
                     }
+                    self.drown_particles(feet, player_velocity);
                 }
                 MotionEvent::BubbleColumnParticle { bubble, position } => {
                     // ServerLevel.sendParticles: SPLASH (speed 1) or BUBBLE
diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs
index 6e1d5d82b..1ae609587 100644
--- a/crates/horizon-client/src/game/combat.rs
+++ b/crates/horizon-client/src/game/combat.rs
@@ -1,7 +1,16 @@
 //! The player's `CombatTracker`: the damage taken lately, who dealt it and
 //! where the player fell from, turned into the vanilla death message.
 use super::{Game, chat::PLAYER_NAME};
-use horizon_client::{health::HealthEvent, motion::MotionEvent, text::Text};
+use horizon_client::{
+    health::HealthEvent,
+    motion::MotionEvent,
+    particles::{ParticleOptions, ParticleType},
+    text::Text,
+};
+use horizon_core::random::RandomSource;
+
+/// `EntityEvent.DROWN_PARTICLES`: broadcast with the drowning damage.
+pub(super) const DROWN_EVENT: i8 = 67;
 
 struct Entry {
     damage_type: String,
@@ -40,6 +49,38 @@ pub(super) struct CombatTracker {
     fall_before: f64,
 }
 impl Game<'_> {
+    /// `LivingEntity.makeDrownParticles`: eight bubbles around the entity,
+    /// moving with it.
+    pub(super) fn drown_particles(&mut self, at: [f64; 3], velocity: [f64; 3]) {
+        let bubble = ParticleOptions::simple(ParticleType::Bubble);
+        for _ in 0..8 {
+            let mut triangle = || {
+                let r = self.particles.random();
+                r.next_double() - r.next_double()
+            };
+            let p = [at[0] + triangle(), at[1] + triangle(), at[2] + triangle()];
+            self.particles.add(&bubble, p, velocity);
+        }
+    }
+    /// Entity event 67 from a server, for this client's own player or an
+    /// entity it draws.
+    pub(super) fn remote_drown(&mut self, id: i32) {
+        let own = self.remote.as_ref().is_some_and(|r| r.entity_id == id);
+        let body = if own {
+            self.player.as_ref().map(|p| {
+                let (at, v) = (p.position, p.velocity);
+                ([at.x, at.y, at.z], [v.x, v.y, v.z])
+            })
+        } else {
+            self.mobs.iter().find(|m| m.id == id as u32).map(|m| {
+                let (at, v) = (m.position, m.velocity);
+                ([at.x, at.y, at.z], [v.x, v.y, v.z])
+            })
+        };
+        if let Some((at, v)) = body {
+            self.drown_particles(at, v);
+        }
+    }
     /// The display name of a mob: its custom name or its type's name.
     pub(super) fn mob_display_name(&self, id: u32) -> Option<Text> {
         let m = self.mobs.iter().find(|m| m.id == id)?;
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index f6961ab13..6fcbc7166 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -897,6 +897,15 @@ impl Game<'_> {
             match e {
                 MobEvent::SquidCycle { mob, at } => self.lan_entity_event(mob as i32, 19, at),
                 MobEvent::RabbitHop { mob, at } => self.lan_entity_event(mob as i32, 1, at),
+                MobEvent::Drown { mob, at } => {
+                    self.lan_entity_event(mob as i32, super::combat::DROWN_EVENT, at);
+                    let v = self
+                        .mobs
+                        .iter()
+                        .find(|m| m.id == mob)
+                        .map_or([0.0; 3], |m| [m.velocity.x, m.velocity.y, m.velocity.z]);
+                    self.drown_particles(at, v);
+                }
                 MobEvent::Sound(name, at, volume, pitch)
                 | MobEvent::LocalSound(name, at, volume, pitch) => {
                     self.audio
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 98162ae46..6c7f76e16 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -2312,6 +2312,15 @@ impl Game<'_> {
             match event {
                 MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, at),
                 MotionEvent::Fall(event) => self.landing_block_updates(&event),
+                // LivingEntity.baseTick's entity event 67, to every client
+                // around, the guest's own included; this window draws it too.
+                MotionEvent::Drown => {
+                    if let Some(g) = host.hub.guest(conn) {
+                        host.hub
+                            .entity_event(g.entity_id, super::combat::DROWN_EVENT, at);
+                    }
+                    self.drown_particles(at, [0.0; 3]);
+                }
                 _ => {}
             }
         }
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..845b1880d 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -2138,6 +2138,9 @@ impl Game<'_> {
                 if p.event == super::totem::TOTEM_EVENT {
                     self.remote_totem(p.id);
                 }
+                if p.event == super::combat::DROWN_EVENT {
+                    self.remote_drown(p.id);
+                }
             }
             C::Animate(p) => self.remote_animate(p.id, p.action),
             // ClientPacketListener.handleSwingAnimation: the entity swings
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index f4086216d..53a62fe3c 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -885,6 +885,12 @@ pub enum MobEvent {
         mob: u32,
         at: [f64; 3],
     },
+    /// `LivingEntity.baseTick`'s drowning damage: entity event 67, the
+    /// clients' `makeDrownParticles`.
+    Drown {
+        mob: u32,
+        at: [f64; 3],
+    },
     Sound(&'static str, [f64; 3], f32, f32),
     /// `ChestBlockEntity.startOpen` / `stopOpen` by a copper golem: the
     /// chest's opener count goes up or down (interaction range 3).
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 258c1ccc7..8eacdd732 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -517,6 +517,10 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
             m.air -= 1;
             if m.air == -20 {
                 m.air = 0;
+                events.push(MobEvent::Drown {
+                    mob: m.id,
+                    at: [m.position.x, m.position.y, m.position.z],
+                });
                 m.damage(2.0, Damage::of(DamageKind::Drown));
             }
         } else if m.air < 300 {

From b3e1542e09d26508febc2e577b428ed805785c99 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:43:10 +0100
Subject: [PATCH 331/475] Follow vanilla's block outline rules: high contrast
 option, F1 and adventure

---
 crates/horizon-client/src/game.rs      |  8 ++-
 crates/horizon-client/src/gfx.rs       | 67 ++++++++++++++++++++------
 crates/horizon-client/src/terrain.wgsl | 14 ++++--
 3 files changed, 68 insertions(+), 21 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 7596ee871..97aa6ef15 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -10746,7 +10746,11 @@ impl Game<'_> {
         let debug_crosshair = horizon_client::gizmos::camera_relative(&crosshair.on_top, at, view);
         // LevelExtractor.extractBlockOutline: model translucency controls draw order.
         let mut outline_after_terrain = false;
-        let outline = if self.screen == Screen::Playing && !self.spectator() {
+        // GameRenderer.shouldRenderBlockOutline: not with the HUD hidden (F1), and only for a
+        // player who may build. Adventure players only get one with a CAN_BREAK or
+        // CAN_PLACE_ON item and spectators with a menu block; Horizon reads neither the
+        // components nor opens menus for spectators, so those never show it.
+        let outline = if self.screen == Screen::Playing && !self.ui.hide_gui && self.may_build() {
             self.pick()
                 .map(|h| {
                     let state = self.world.block(h.pos[0], h.pos[1], h.pos[2]);
@@ -10931,6 +10935,7 @@ impl Game<'_> {
             dark_disc: self.dark_disc(camera),
             outline,
             outline_after_terrain,
+            outline_high_contrast: self.settings.file.bool("highContrastBlockOutline"),
             debug_lines: &debug_lines,
             debug_lines_on_top: &debug_lines_on_top,
             debug_crosshair: &debug_crosshair,
@@ -13627,6 +13632,7 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> {
         dark_disc: false,
         outline: Vec::new(),
         outline_after_terrain: false,
+        outline_high_contrast: false,
         debug_lines: &[],
         debug_lines_on_top: &[],
         debug_crosshair: &[],
diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index 70d882a98..77b0510a8 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -247,6 +247,8 @@ pub struct Frame<'a> {
     pub outline: Vec<[f64; 6]>,
     /// `BlockOutlineRenderState.isTranslucent`: draw after translucent terrain.
     pub outline_after_terrain: bool,
+    /// `BlockOutlineRenderState.highContrast`: a thick black outline under a bright one.
+    pub outline_high_contrast: bool,
     /// `lines` with a colour and pixel width (`gizmos::camera_relative`):
     /// the fishing line and debug gizmos, depth tested, then gizmos drawn
     /// over everything.
@@ -377,6 +379,7 @@ pub struct Renderer {
     sky: wgpu::RenderPipeline,
     dark_disc: wgpu::RenderPipeline,
     lines: wgpu::RenderPipeline,
+    lines_secondary: wgpu::RenderPipeline,
     /// Gizmo lines (`RenderTypes.linesTranslucentNoDepthWrite`) and the
     /// always-on-top ones.
     debug_lines: wgpu::RenderPipeline,
@@ -1213,12 +1216,6 @@ impl Renderer {
                 attributes: &instance_attributes,
             }),
         ];
-        let line_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x3];
-        let line_buffers = [Some(wgpu::VertexBufferLayout {
-            array_stride: 24,
-            step_mode: wgpu::VertexStepMode::Instance,
-            attributes: &line_attributes,
-        })];
         let alpha_blend = wgpu::BlendState::ALPHA_BLENDING;
         let debug_line_attributes =
             wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x3,2=>Unorm8x4,3=>Float32];
@@ -1351,13 +1348,25 @@ impl Renderer {
             "Block outline",
             "vs_line",
             "fs_line",
-            &line_buffers,
+            &debug_line_buffers,
             wgpu::PrimitiveTopology::TriangleStrip,
             None,
             true,
             true,
             Some(alpha_blend),
         );
+        // RenderTypes.secondaryBlockOutline: the black stroke under a high contrast outline.
+        let lines_secondary = pipeline(
+            "Block outline secondary",
+            "vs_line",
+            "fs_line",
+            &debug_line_buffers,
+            wgpu::PrimitiveTopology::TriangleStrip,
+            None,
+            false,
+            true,
+            Some(alpha_blend),
+        );
         let debug_lines = pipeline(
             "Debug lines",
             "vs_debug_line",
@@ -1531,7 +1540,7 @@ impl Renderer {
         });
         let outline = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Outline"),
-            size: 24 * MAX_OUTLINE_EDGES,
+            size: 32 * 2 * MAX_OUTLINE_EDGES,
             usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
             mapped_at_creation: false,
         });
@@ -2361,6 +2370,7 @@ impl Renderer {
             sky,
             dark_disc,
             lines,
+            lines_secondary,
             debug_lines,
             debug_lines_on_top,
             debug_line_buffer,
@@ -2482,6 +2492,18 @@ impl Renderer {
             present_modes,
         })
     }
+    /// LevelRenderer.submitBlockOutline: the buffer holds `edges` per stroke, the black
+    /// secondary stroke first when high contrast is on.
+    fn draw_outline(&self, pass: &mut wgpu::RenderPass<'_>, edges: u32, high_contrast: bool) {
+        pass.set_vertex_buffer(0, self.outline.slice(..));
+        if high_contrast {
+            pass.set_pipeline(&self.lines_secondary);
+            pass.draw(0..4, 0..edges);
+        }
+        pass.set_pipeline(&self.lines);
+        let first = if high_contrast { edges } else { 0 };
+        pass.draw(0..4, first..first + edges);
+    }
     fn quad_indices(device: &wgpu::Device, quads: u32) -> wgpu::Buffer {
         let indices: Vec<u32> = (0..quads)
             .flat_map(|q| {
@@ -3954,7 +3976,26 @@ impl Renderer {
         );
         let outline_edges = frame.outline.len().min(MAX_OUTLINE_EDGES as usize);
         if outline_edges > 0 {
-            let lines = outline_vertices(&frame.outline[..outline_edges], camera);
+            // The same per-line colour and pixel width layout as the gizmo lines. A high
+            // contrast outline is two strokes: the black one first, the bright one after it.
+            let edges = outline_vertices(&frame.outline[..outline_edges], camera);
+            let width = outline_width(self.config.width);
+            let stroke = |color: u32, width: f32| {
+                edges.iter().map(move |e| {
+                    let mut line = [0.0; 8];
+                    line[..6].copy_from_slice(e);
+                    line[6] = f32::from_bits(color);
+                    line[7] = width;
+                    line
+                })
+            };
+            let lines: Vec<[f32; 8]> = if frame.outline_high_contrast {
+                stroke(0xff00_0000, 7.0)
+                    .chain(stroke(0xff57_ffe1, width))
+                    .collect()
+            } else {
+                stroke(0x6600_0000, width).collect()
+            };
             self.uploads
                 .buffer(&mut encoder, &self.outline, 0, bytemuck::cast_slice(&lines));
         }
@@ -4562,9 +4603,7 @@ impl Renderer {
                 pass.set_bind_group(0, &self.group, &[]);
             }
             if outline_edges > 0 && !frame.outline_after_terrain {
-                pass.set_pipeline(&self.lines);
-                pass.set_vertex_buffer(0, self.outline.slice(..));
-                pass.draw(0..4, 0..outline_edges as u32);
+                self.draw_outline(&mut pass, outline_edges as u32, frame.outline_high_contrast);
             }
             if debug_depth > 0 {
                 pass.set_pipeline(&self.debug_lines);
@@ -4619,9 +4658,7 @@ impl Renderer {
             // LevelRenderer.executeClassicTransparency: translucent targets'
             // outlines follow terrain, so its blending cannot wash them out.
             if outline_edges > 0 && frame.outline_after_terrain {
-                pass.set_pipeline(&self.lines);
-                pass.set_vertex_buffer(0, self.outline.slice(..));
-                pass.draw(0..4, 0..outline_edges as u32);
+                self.draw_outline(&mut pass, outline_edges as u32, frame.outline_high_contrast);
             }
             pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
             // LevelRenderer: the world border after translucent terrain and weather.
diff --git a/crates/horizon-client/src/terrain.wgsl b/crates/horizon-client/src/terrain.wgsl
index c0cf44bb5..3aea6fc1a 100644
--- a/crates/horizon-client/src/terrain.wgsl
+++ b/crates/horizon-client/src/terrain.wgsl
@@ -258,7 +258,7 @@ fn sky_along_ray(d: vec3<f32>) -> vec3<f32> {
 }
 
 // rendertype_lines.vsh: screen-space stroke and camera-space depth separation.
-fn outline_clip(vertex: u32, start: vec3<f32>, end: vec3<f32>) -> vec4<f32> {
+fn outline_clip(vertex: u32, start: vec3<f32>, end: vec3<f32>, width: f32) -> vec4<f32> {
     let position = select(start, end, vertex >= 2u);
     let normal = normalize(end - start);
     let view_shrink = 1.0 - 1.0 / 256.0;
@@ -268,7 +268,7 @@ fn outline_clip(vertex: u32, start: vec3<f32>, end: vec3<f32>) -> vec4<f32> {
     let ndc2 = line_end.xyz / line_end.w;
     let screen = globals.outline_params.xy;
     let direction = normalize((ndc2.xy - ndc1.xy) * screen);
-    var offset = vec2(-direction.y, direction.x) * globals.outline_params.z / screen;
+    var offset = vec2(-direction.y, direction.x) * width / screen;
     if offset.x < 0.0 { offset = -offset; }
     if vertex % 2u != 0u { offset = -offset; }
     return vec4((ndc1 + vec3(offset, 0.0)) * line_start.w, line_start.w);
@@ -277,18 +277,22 @@ struct LineOut {
     @builtin(position) clip: vec4<f32>,
     @location(0) spherical: f32,
     @location(1) cylindrical: f32,
+    @location(2) color: vec4<f32>,
 }
 @vertex fn vs_line(@builtin(vertex_index) vertex: u32,
-    @location(0) start: vec3<f32>, @location(1) end: vec3<f32>) -> LineOut {
+    @location(0) start: vec3<f32>, @location(1) end: vec3<f32>,
+    @location(2) argb: vec4<f32>, @location(3) width: f32) -> LineOut {
     let position = select(start, end, vertex >= 2u);
     var out: LineOut;
-    out.clip = outline_clip(vertex, start, end);
+    out.clip = outline_clip(vertex, start, end, width);
     out.spherical = length(position);
     out.cylindrical = max(length(position.xz), abs(position.y));
+    // ARGB in a little-endian u32 reads as B, G, R, A.
+    out.color = argb.zyxw;
     return out;
 }
 @fragment fn fs_line(in: LineOut) -> @location(0) vec4<f32> {
-    return apply_fog(vec4(0.0, 0.0, 0.0, 0.4), in.spherical, in.cylindrical);
+    return apply_fog(in.color, in.spherical, in.cylindrical);
 }
 // Gizmo lines (rendertype_lines with a per-vertex colour and LineWidth in
 // pixels; no layering transform).

From e0e484e44b8370fef8d2608d200ef8dd0f8bb97a Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:43:18 +0100
Subject: [PATCH 332/475] Fix the baby zombie villager, happy ghast and player
 hurt voice pitch

---
 crates/horizon-client/src/audio.rs       |  5 -----
 crates/horizon-client/src/game/combat.rs |  4 ++--
 crates/horizon-client/src/mobs.rs        | 12 +++++++++++-
 3 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/crates/horizon-client/src/audio.rs b/crates/horizon-client/src/audio.rs
index be6628ece..e45362e19 100644
--- a/crates/horizon-client/src/audio.rs
+++ b/crates/horizon-client/src/audio.rs
@@ -719,11 +719,6 @@ impl Audio {
         self.play(event, at, volume, pitch);
         self.capture = capture;
     }
-    /// `LivingEntity.handleDamageEvent`'s pitch, `(r - r) * 0.2 + 1`, drawn on the
-    /// client (the entity's own random there, never the server's world random).
-    pub fn hurt_pitch(&mut self) -> f32 {
-        (self.random.next_float() - self.random.next_float()) * 0.2 + 1.0
-    }
     /// `AbstractWidget.playButtonClickSound`: an unseeded, relative UI sound.
     pub fn play_button_click(&mut self) {
         self.play_instance(
diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs
index 6e1d5d82b..b74e1ae72 100644
--- a/crates/horizon-client/src/game/combat.rs
+++ b/crates/horizon-client/src/game/combat.rs
@@ -69,8 +69,8 @@ impl Game<'_> {
     /// `LivingEntity.handleDamageEvent` for the player: the hurt sound of the
     /// source's `DamageEffects` (`Player.getHurtSound`).
     pub(super) fn player_hurt_sound(&mut self, sound: &str, at: [f64; 3]) {
-        let pitch = self.audio.hurt_pitch();
-        self.audio.play(sound, Some(at), 1.0, pitch);
+        // Player.getVoicePitch: always 1.0.
+        self.audio.play(sound, Some(at), 1.0, 1.0);
     }
     /// `CombatTracker.recordDamage` for the motion events of this tick.
     pub(super) fn record_combat(&mut self, events: &[MotionEvent]) {
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index f4086216d..ffb6f6f00 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1968,8 +1968,18 @@ impl Mob {
     }
     /// LivingEntity.getVoicePitch.
     pub fn voice_pitch(&mut self) -> f32 {
+        // HappyGhast.getVoicePitch: always 1.0, babies and all.
+        if self.species() == Species::HappyGhast {
+            return 1.0;
+        }
+        // ZombieVillager.getVoicePitch: babies are 2.0, not 1.5.
+        let baby = if self.species() == Species::ZombieVillager {
+            2.0
+        } else {
+            1.5
+        };
         let pitch = (self.random.next_float() - self.random.next_float()) * 0.2
-            + if self.is_baby() { 1.5 } else { 1.0 };
+            + if self.is_baby() { baby } else { 1.0 };
         // Bat.getVoicePitch: a little lower.
         if self.species() == Species::Bat {
             pitch * 0.95

From dca96dd1df8f0fc2b4328b904e32a7ef7a2ae64a Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:43:50 +0100
Subject: [PATCH 333/475] Fix turtle step timing and camel sand step sounds

---
 crates/horizon-client/src/mobs/ai.rs     | 16 ++++++++++++++--
 crates/horizon-client/src/mobs/living.rs |  4 +++-
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 258c1ccc7..cd0986f9a 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -1591,8 +1591,20 @@ pub fn step_sound(
         S::Husk => quiet("entity.husk.step"),
         S::Drowned => quiet("entity.drowned.step"),
         S::ZombieVillager => quiet("entity.zombie_villager.step"),
-        S::CamelHusk => Some(("entity.camel_husk.step", 0.4, 1.0)),
-        S::Camel => Some(("entity.camel.step", 1.0, 1.0)),
+        // Camel.playStepSound and CamelHusk.playStepSound: sand and concrete
+        // powder have their own step.
+        S::CamelHusk | S::Camel => {
+            let sand = w.has_tag(
+                "minecraft:camel_sand_step_sound_blocks",
+                &w.facts.get(state).name,
+            );
+            Some(match (m.species(), sand) {
+                (S::Camel, true) => ("entity.camel.step_sand", 1.0, 1.0),
+                (S::Camel, false) => ("entity.camel.step", 1.0, 1.0),
+                (_, true) => ("entity.camel_husk.step_sand", 0.4, 1.0),
+                (_, false) => ("entity.camel_husk.step", 0.4, 1.0),
+            })
+        }
         S::IronGolem => Some(("entity.iron_golem.step", 1.0, 1.0)),
         // CopperGolem.playStepSound: its oxidation level's step.
         S::CopperGolem => Some((super::copper_golem::sound(m, "step"), 1.0, 1.0)),
diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs
index 394821ace..ca9f92892 100644
--- a/crates/horizon-client/src/mobs/living.rs
+++ b/crates/horizon-client/src/mobs/living.rs
@@ -529,13 +529,15 @@ impl Mob {
         }
     }
     /// `Entity.nextStep`: the next whole metre walked; a warden's steps come
-    /// every 0.55, a strider's every 0.6.
+    /// every 0.55, a strider's every 0.6, a turtle's every 0.15.
     fn next_step(&self) -> f32 {
         let walked = self.ai.steps.move_dist;
         if self.kind.species == super::Species::Warden {
             walked + 0.55
         } else if self.kind.species == super::Species::Strider {
             walked + 0.6
+        } else if self.kind.species == super::Species::Turtle {
+            walked + 0.15
         } else {
             (walked as i32).wrapping_add(1) as f32
         }

From f6db8b1f56227da23ff72407c8af3e8ca081f6a5 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:44:16 +0100
Subject: [PATCH 334/475] Scroll and add the energy swirl of charged creepers
 and powered withers

---
 crates/horizon-client/src/entity.wgsl         | 14 ++++++
 crates/horizon-client/src/gfx.rs              | 47 +++++++++++++++++-
 crates/horizon-client/src/gfx/entity_batch.rs | 21 +++++---
 .../horizon-client/src/gfx/pack_entities.rs   |  6 +--
 crates/horizon-client/src/mobs/render.rs      | 48 +++++++++++++++----
 5 files changed, 116 insertions(+), 20 deletions(-)

diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl
index 79e11719f..ae89c4a66 100644
--- a/crates/horizon-client/src/entity.wgsl
+++ b/crates/horizon-client/src/entity.wgsl
@@ -224,6 +224,20 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
     return color;
 }
 
+// RenderPipelines.ENERGY_SWIRL (entity.fsh with EMISSIVE and NO_OVERLAY): the sprite, scrolled by
+// the UV and repeated within itself, times the layer colour 0xFF808080, unlit; the pipeline adds
+// it to the frame. The light bytes carry the sprite's origin and the colour bytes its size, both
+// as breaking::stage_light packs them.
+@fragment fn fs_energy_swirl(in: Out) -> @location(0) vec4<f32> {
+    let bytes = round(in.color * 255.0);
+    let size = vec2(bytes.x + bytes.y * 256.0, bytes.z + bytes.w * 256.0) / 65535.0;
+    let color = textureSample(atlas, atlas_sampler, crumbling_uv(in.uv, in.wrap, size, textureDimensions(atlas)));
+    if color.a < 0.1 { discard; }
+    let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
+                linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
+    return vec4(mix(color.rgb * (128.0 / 255.0), globals.fog_color.rgb, f * globals.fog_color.a), color.a);
+}
+
 // RenderPipelines.WATER_MASK: depth only (the pipeline masks the colour off).
 @fragment fn fs_water_mask() -> @location(0) vec4<f32> {
     return vec4(0.0);
diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index 70d882a98..fe8baeaae 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -37,7 +37,9 @@ mod crumbling_tests;
 mod entity_batch;
 mod weather;
 use entity_batch::EntityBatch;
-pub use entity_batch::{SHADOW_OVERLAY, TRANSLUCENT_PARTICLE_OVERLAY, WATER_MASK_OVERLAY};
+pub use entity_batch::{
+    ENERGY_SWIRL_OVERLAY, SHADOW_OVERLAY, TRANSLUCENT_PARTICLE_OVERLAY, WATER_MASK_OVERLAY,
+};
 
 /// Window.getAppropriateLineWidth, in framebuffer pixels.
 pub fn outline_width(width: u32) -> f32 {
@@ -400,6 +402,8 @@ pub struct Renderer {
     cloud_uniform: wgpu::Buffer,
     cloud_group: wgpu::BindGroup,
     additive_pipeline: wgpu::RenderPipeline,
+    /// `RenderPipelines.ENERGY_SWIRL`: additive, unlit, the sprite repeated within itself.
+    energy_swirl_pipeline: wgpu::RenderPipeline,
     lightning_pipeline: wgpu::RenderPipeline,
     lightning: lightning::Renderer,
     see_through_pipeline: wgpu::RenderPipeline,
@@ -1865,6 +1869,27 @@ impl Renderer {
             alpha_blend,
             false,
         );
+        // RenderPipelines.ENERGY_SWIRL: BlendFunction.ADDITIVE (one, one), no culling; no depth
+        // writes either: vanilla sorts the quads far to near, so every face passes the test.
+        let one_one = wgpu::BlendComponent {
+            src_factor: wgpu::BlendFactor::One,
+            dst_factor: wgpu::BlendFactor::One,
+            operation: wgpu::BlendOperation::Add,
+        };
+        let energy_swirl_pipeline = entity_pipeline_with(
+            "Energy swirls",
+            None,
+            false,
+            wgpu::CompareFunction::GreaterEqual,
+            Default::default(),
+            wgpu::BlendState {
+                color: one_one,
+                alpha: one_one,
+            },
+            false,
+            "fs_energy_swirl",
+            wgpu::ColorWrites::ALL,
+        );
         let lightning_attributes = wgpu::vertex_attr_array![6=>Float32x3];
         let lightning_vertex = [
             entity_vertex[0].clone(),
@@ -2379,6 +2404,7 @@ impl Renderer {
             cloud_uniform,
             cloud_group,
             additive_pipeline,
+            energy_swirl_pipeline,
             lightning_pipeline,
             lightning: lightning::Renderer::new(),
             see_through_pipeline,
@@ -3979,6 +4005,7 @@ impl Renderer {
             crumbling_quads,
             translucent_crumbling_quads,
             water_mask_quads,
+            swirl_quads,
             shadow_quads,
             translucent_particle_quads,
         ] = self
@@ -3989,6 +4016,7 @@ impl Renderer {
             + crumbling_quads
             + translucent_crumbling_quads
             + water_mask_quads
+            + swirl_quads
             + shadow_quads
             + translucent_particle_quads;
         let cloud_quads = if let Some(input) = &frame.clouds {
@@ -4554,6 +4582,21 @@ impl Renderer {
                 self.lightning.draw(&mut pass, &frame.lightning);
                 pass.set_bind_group(0, &self.group, &[]);
             }
+            if swirl_quads > 0 {
+                pass.set_pipeline(&self.energy_swirl_pipeline);
+                pass.set_bind_group(0, &self.entity_group, &[]);
+                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
+                pass.draw_indexed(
+                    0..swirl_quads * 6,
+                    ((entity_quads
+                        + crumbling_quads
+                        + translucent_crumbling_quads
+                        + water_mask_quads)
+                        * 4) as i32,
+                    0..1,
+                );
+                pass.set_bind_group(0, &self.group, &[]);
+            }
             if additive_quads > 0 {
                 pass.set_pipeline(&self.additive_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
@@ -5240,7 +5283,7 @@ mod tests {
         let mut batch = super::EntityBatch::default();
         let counts = batch.update(&entities, &quad(3, 5), &quad(0, 6), &quad(0, 8));
         let vertices = &batch.combined;
-        assert_eq!(counts, [4, 1, 1, 0, 1, 1]);
+        assert_eq!(counts, [4, 1, 1, 0, 0, 1, 1]);
         assert_eq!(
             vertices
                 .as_chunks::<4>()
diff --git a/crates/horizon-client/src/gfx/entity_batch.rs b/crates/horizon-client/src/gfx/entity_batch.rs
index 8153699fc..d00ac3d43 100644
--- a/crates/horizon-client/src/gfx/entity_batch.rs
+++ b/crates/horizon-client/src/gfx/entity_batch.rs
@@ -3,12 +3,17 @@ use super::Vertex;
 
 /// Entity materials by a quad's overlay (`Vertex::layer`), in draw order:
 /// ordinary entities, breaking cracks (11), translucent breaking cracks (12),
-/// the boat water mask (13, `RenderPipelines.WATER_MASK`), entity shadows
-/// (14, `RenderPipelines.ENTITY_SHADOW`) and translucent-layer particles (15,
-/// drawn after translucent terrain: `SubmitNodeCollection.submitQuadParticleGroup`).
-const MATERIALS: usize = 6;
+/// the boat water mask (13, `RenderPipelines.WATER_MASK`), energy swirls
+/// (32, `RenderPipelines.ENERGY_SWIRL`), entity shadows (14,
+/// `RenderPipelines.ENTITY_SHADOW`) and translucent-layer particles (15, drawn
+/// after translucent terrain: `SubmitNodeCollection.submitQuadParticleGroup`).
+const MATERIALS: usize = 7;
 /// The overlay of depth-only quads that hide water (`RenderTypes.waterMask`).
 pub const WATER_MASK_OVERLAY: u32 = 13;
+/// The overlay of energy swirl quads (`RenderTypes.energySwirl`: the charged creeper's and the
+/// powered wither's armour). The light bytes carry the sprite's origin and the colour bytes its
+/// size (`breaking::stage_light`), the UV the scrolled position in the sprite.
+pub const ENERGY_SWIRL_OVERLAY: u32 = 32;
 /// The overlay of entity shadow quads (`RenderTypes.entityShadow`).
 pub const SHADOW_OVERLAY: u32 = 14;
 /// The overlay of translucent-layer particles (`SingleQuadParticle.Layer.translucent`).
@@ -43,8 +48,9 @@ impl EntityBatch {
                 11 => 1,
                 12 => 2,
                 WATER_MASK_OVERLAY => 3,
-                SHADOW_OVERLAY => 4,
-                TRANSLUCENT_PARTICLE_OVERLAY => 5,
+                ENERGY_SWIRL_OVERLAY => 4,
+                SHADOW_OVERLAY => 5,
+                TRANSLUCENT_PARTICLE_OVERLAY => 6,
                 _ => 0,
             };
             self.buckets[material][counts[material]] = index;
@@ -96,12 +102,13 @@ mod tests {
     ) -> (Vec<Vertex>, [u32; MATERIALS]) {
         let mut combined = Vec::with_capacity(entities.len() + additive.len() + hand.len());
         let mut counts = [0; MATERIALS];
-        for (i, layer) in [0, 11, 12, 13, 14, 15].into_iter().enumerate() {
+        for (i, layer) in [0, 11, 12, 13, 32, 14, 15].into_iter().enumerate() {
             for quad in entities.as_chunks::<4>().0 {
                 let material = match quad[0].layer {
                     11 => 11,
                     12 => 12,
                     13 => 13,
+                    32 => 32,
                     14 => 14,
                     15 => 15,
                     _ => 0,
diff --git a/crates/horizon-client/src/gfx/pack_entities.rs b/crates/horizon-client/src/gfx/pack_entities.rs
index ab3c66c69..c2cc5fe72 100644
--- a/crates/horizon-client/src/gfx/pack_entities.rs
+++ b/crates/horizon-client/src/gfx/pack_entities.rs
@@ -405,12 +405,12 @@ pub(super) fn quad_indices(device: &wgpu::Device, quads: u32) -> wgpu::Buffer {
 }
 
 /// Whether a run holds only geometry a gbuffers program can draw from the shared atlas: no
-/// celestial body, cloud, beam, End portal or crack (overlay codes Horizon's entity shader
-/// draws in its own way; entity.wgsl).
+/// celestial body, cloud, beam, End portal, crack or energy swirl (overlay codes Horizon's entity
+/// shader draws in its own way; entity.wgsl).
 fn plain(run: &[Vertex]) -> bool {
     run.iter()
         .step_by(4)
-        .all(|v| !matches!(v.layer, 2 | 4 | 6 | 9 | 10 | 11 | 12))
+        .all(|v| !matches!(v.layer, 2 | 4 | 6 | 9 | 10 | 11 | 12 | 32))
 }
 
 /// The programs of entity runs, in the order they draw.
diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs
index 077fd38a6..2f6275d37 100644
--- a/crates/horizon-client/src/mobs/render.rs
+++ b/crates/horizon-client/src/mobs/render.rs
@@ -601,14 +601,6 @@ pub fn layers(m: &Mob) -> Vec<Layer> {
             white,
             false,
         ),
-        // EnergySwirlLayer (the scroll is not reproduced: atlas sprites do not wrap).
-        S::Creeper if m.extra.charged => push(
-            &mut v,
-            "creeper#armor",
-            "entity/creeper/creeper_armor",
-            0x80FF_FFFF,
-            true,
-        ),
         S::TropicalFish => {
             // TropicalFishPatternLayer: the pattern tinted with the pattern colour.
             let (model, letter, n) = if m.extra.variant < 6 {
@@ -1151,10 +1143,50 @@ fn render_visible(
             }
         }
     }
+    // EnergySwirlLayer: the armour model, additive, scrolling over the sprite.
+    if let Some((model, texture, x_offset)) = energy_swirl(m, s.age)
+        && let Some(part) = m.kind.layer(model)
+        && let Some([u0, v0, u1, v1]) = atlas(texture)
+    {
+        layer_poses.reset(part);
+        anim::setup(m, &s, &mut layer_poses, &data.animations);
+        // `RenderTypes.energySwirl`'s texture offset, as the sprite-local UV.
+        let (du, dv) = (x_offset % 1.0, s.age * 0.01 % 1.0);
+        let start = out.len();
+        draw(
+            part,
+            base,
+            &layer_poses,
+            [du, dv, 1.0 + du, 1.0 + dv],
+            crate::breaking::stage_light([u1 - u0, v1 - v0]),
+            crate::breaking::stage_light([u0, v0]),
+            crate::gfx::ENERGY_SWIRL_OVERLAY,
+            out,
+        );
+        // No lighting: the colour bytes carry the sprite's size (fs_energy_swirl).
+        for vertex in &mut out[start..] {
+            vertex.normal = [0; 4];
+        }
+    }
     if shell_last {
         draw_body(out);
     }
 }
+/// `EnergySwirlLayer`'s model, texture and `xOffset(t)` for a charged creeper
+/// (`CreeperPowerLayer`) or a powered wither (`WitherArmorLayer`); `t` is `ageInTicks`.
+fn energy_swirl(m: &Mob, t: f32) -> Option<(&'static str, &'static str, f32)> {
+    match m.species() {
+        Species::Creeper if m.extra.charged => {
+            Some(("creeper#armor", "entity/creeper/creeper_armor", t * 0.01))
+        }
+        Species::Wither if super::wither::powered(m) => Some((
+            "wither#armor",
+            "entity/wither/wither_armor",
+            (t * 0.02).mcos() * 3.0,
+        )),
+        _ => None,
+    }
+}
 /// The equipment slot of a `HumanoidArmorLayer` model (`zombie#helmet`).
 fn armor_slot(model: &str) -> Option<usize> {
     Some(match model.rsplit('#').next()? {

From 7fdd57ad1ef559706e0ebf445aa7f49323c635b9 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:45:14 +0100
Subject: [PATCH 335/475] Play the level-up sound for each level a gain crosses

---
 crates/horizon-client/src/entities.rs | 12 ++++++++----
 crates/horizon-client/src/game.rs     | 11 ++++-------
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/crates/horizon-client/src/entities.rs b/crates/horizon-client/src/entities.rs
index 44f07dc82..14cd946c2 100644
--- a/crates/horizon-client/src/entities.rs
+++ b/crates/horizon-client/src/entities.rs
@@ -582,17 +582,21 @@ impl Experience {
             7 + level * 2
         }
     }
-    /// Returns true when a level was gained.
-    pub fn give(&mut self, points: i32) -> bool {
-        let start = self.level;
+    /// Returns the first multiple of 5 the player reached, where each level
+    /// gained would play the level-up sound (`Player.giveExperienceLevels`).
+    pub fn give(&mut self, points: i32) -> Option<i32> {
+        let mut sound_level = None;
         self.progress += points as f32 / Self::needed(self.level) as f32;
         self.total = self.total.saturating_add(points).max(0);
         while self.progress >= 1.0 {
             self.progress = (self.progress - 1.0) * Self::needed(self.level) as f32;
             self.level += 1;
+            if self.level % 5 == 0 {
+                sound_level.get_or_insert(self.level);
+            }
             self.progress /= Self::needed(self.level) as f32;
         }
-        self.level > start
+        sound_level
     }
 }
 /// A painting (`Painting`, a `HangingEntity`): the block it hangs in, the
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index db49087b2..046aab105 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -9524,16 +9524,13 @@ impl Game<'_> {
     /// sound every fifth level (at most every 100 ticks).
     pub(super) fn give_orb_points(&mut self, gained: u32) {
         let at = self.eye_position();
-        if self.experience.give(gained as i32)
-            && self.experience.level % 5 == 0
+        // Player.giveExperienceLevels runs per level, so the first multiple of 5
+        // crossed plays the sound (and starts the cooldown for the rest).
+        if let Some(level) = self.experience.give(gained as i32)
             && self.ticks > self.last_level_up + 100
         {
             self.last_level_up = self.ticks;
-            let volume = if self.experience.level > 30 {
-                1.0
-            } else {
-                self.experience.level as f32 / 30.0
-            };
+            let volume = if level > 30 { 1.0 } else { level as f32 / 30.0 };
             self.audio
                 .play("minecraft:entity.player.levelup", at, volume * 0.75, 1.0);
         }

From 7f6e47b02e65a236900b49f9fd0fd71844637c7d Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:45:48 +0100
Subject: [PATCH 336/475] Hide player arrows and markers on a map in an item
 frame

---
 crates/horizon-client/src/game/frames.rs |  2 +-
 crates/horizon-client/src/game/maps.rs   | 21 ++++++++++++++++++---
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/game/frames.rs b/crates/horizon-client/src/game/frames.rs
index d08c5f283..fb0cc8c10 100644
--- a/crates/horizon-client/src/game/frames.rs
+++ b/crates/horizon-client/src/game/frames.rs
@@ -456,7 +456,7 @@ impl Game<'_> {
         }
         for (id, m, light) in maps {
             let entity_start = out.len();
-            self.map_vertices(id, m, light, out);
+            self.map_vertices(id, true, m, light, out);
             self.cull_entity_vertices(out, entity_start);
         }
     }
diff --git a/crates/horizon-client/src/game/maps.rs b/crates/horizon-client/src/game/maps.rs
index 6da65c592..eb8c3687b 100644
--- a/crates/horizon-client/src/game/maps.rs
+++ b/crates/horizon-client/src/game/maps.rs
@@ -324,6 +324,13 @@ const DECORATION_TYPES: [(&str, &str); 24] = [
     ("mineshaft", "map/decorations/mineshaft"),
     ("ocean_ruin_warm", "map/decorations/warm_ocean_ruins"),
 ];
+/// `MapDecorationType.showOnItemFrame` is false for the player arrows and the two markers.
+fn shown_on_frame(sprite: &str) -> bool {
+    !matches!(
+        decoration_type(sprite),
+        Some("player" | "red_marker" | "blue_marker" | "player_off_map" | "player_off_limits")
+    )
+}
 /// The sprite of a decoration type that a `minecraft:map_decorations`
 /// entry or a server's packet names.
 fn decoration_sprite(id: &str) -> Option<&'static str> {
@@ -1114,9 +1121,12 @@ impl Game<'_> {
     }
     /// `MapRenderer.render`: the map texture and its decorations under `m`
     /// (map pixels 0..128, y down), drawn at depth offsets toward the viewer.
+    /// `show_only_frame` (a map in an item frame) leaves out the decorations that
+    /// do not show on frames.
     pub(super) fn map_vertices(
         &mut self,
         id: i32,
+        show_only_frame: bool,
         m: glam::Mat4,
         light: u32,
         out: &mut Vec<Vertex>,
@@ -1158,14 +1168,18 @@ impl Game<'_> {
             .get(&id)
             .map(|m| m.decorations.clone())
             .unwrap_or_default();
-        for (i, d) in decorations.iter().enumerate() {
+        let mut count = 0;
+        for d in &decorations {
+            if show_only_frame && !shown_on_frame(d.sprite) {
+                continue;
+            }
             let Some(s) = self.gui.atlas.sprites.get(d.sprite).copied() else {
                 continue;
             };
             let dm = glam::Mat4::from_translation(glam::Vec3::new(
                 f32::from(d.x) / 2.0 + 64.0,
                 f32::from(d.y) / 2.0 + 64.0,
-                -0.02 - i as f32 * 0.001,
+                -0.02 - count as f32 * 0.001,
             )) * glam::Mat4::from_rotation_z(
                 (f32::from(d.rot) * 360.0 / 16.0).to_radians(),
             ) * glam::Mat4::from_scale(glam::Vec3::splat(4.0))
@@ -1187,6 +1201,7 @@ impl Game<'_> {
                 [p(-1.0, 1.0), p(1.0, 1.0), p(1.0, -1.0), p(-1.0, -1.0)],
                 [[s.u0, s.v0], [s.u1, s.v0], [s.u1, s.v1], [s.u0, s.v1]],
             );
+            count += 1;
         }
     }
     /// `renderTwoHandedMap`: map `id` held in both hands, in view space (the
@@ -1255,7 +1270,7 @@ impl Game<'_> {
             }
         }
         if has_data {
-            self.map_vertices(id, m, light, out);
+            self.map_vertices(id, false, m, light, out);
         }
     }
 }

From 87b533c5a92ac6054c66f7320247ef27c3cae0e8 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:46:15 +0100
Subject: [PATCH 337/475] Draw the guardian's swimming bubbles and the bubble
 trail along its beam

---
 crates/horizon-client/src/game/creatures.rs | 55 +++++++++++++++++++++
 crates/horizon-client/src/game/remote.rs    |  1 +
 2 files changed, 56 insertions(+)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index f6961ab13..81bc7bdb1 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -659,6 +659,7 @@ impl Game<'_> {
         self.sync_riders();
         self.tick_skeleton_traps();
         self.tick_apparition();
+        self.guardian_bubbles();
         self.villager_reputation_tick();
         self.merchant_tick();
         self.villager_pickups();
@@ -3255,6 +3256,60 @@ impl Game<'_> {
             }
         }
     }
+    /// `Guardian.aiStep` on a client: two bubbles a tick trailing a guardian
+    /// that swims along, and bubbles up the beam to its target. The server
+    /// never draws them, so the mob's own random stays untouched.
+    pub(super) fn guardian_bubbles(&mut self) {
+        use horizon_client::mobs::guardian;
+        use horizon_client::particles::{ParticleOptions, ParticleType};
+        let mut swimming = Vec::new();
+        let mut beams = Vec::new();
+        for m in &self.mobs {
+            if !m.alive() || !matches!(m.species(), Species::Guardian | Species::ElderGuardian) {
+                continue;
+            }
+            let at = [m.position.x, m.position.y, m.position.z];
+            if m.extra.flag2 && m.fluids.in_water {
+                let (width, height, _) = m.dims();
+                swimming.push((at, width, height, m.view_vector()));
+            }
+            if let Some((_, scale)) = guardian::beam(m, 0.0)
+                && let Some(t) = self.beam_target(m.ai.target, 1.0)
+            {
+                beams.push(([at[0], m.eye_y(), at[2]], [t.x, t.y, t.z], f64::from(scale)));
+            }
+        }
+        let bubble = ParticleOptions::simple(ParticleType::Bubble);
+        for (at, width, height, view) in swimming {
+            for _ in 0..2 {
+                let (x, y, z) = {
+                    let r = self.particles.random();
+                    (r.next_double(), r.next_double(), r.next_double())
+                };
+                let p = [
+                    at[0] + width * (2.0 * x - 1.0) * 0.5 - view[0] * 1.5,
+                    at[1] + height * y - view[1] * 1.5,
+                    at[2] + width * (2.0 * z - 1.0) * 0.5 - view[2] * 1.5,
+                ];
+                self.particles.add(&bubble, p, [0.0; 3]);
+            }
+        }
+        for (eye, target, scale) in beams {
+            let d = [target[0] - eye[0], target[1] - eye[1], target[2] - eye[2]];
+            let length = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt();
+            if length <= 0.0 {
+                continue;
+            }
+            let mut dist = self.particles.random().next_double();
+            while dist < length {
+                let r = self.particles.random();
+                dist += 1.8 - scale + r.next_double() * (1.7 - scale);
+                let f = dist / length;
+                let p = [eye[0] + d[0] * f, eye[1] + d[1] * f, eye[2] + d[2] * f];
+                self.particles.add(&bubble, p, [0.0; 3]);
+            }
+        }
+    }
     /// Mob models and projectiles for the entity pass.
     pub(super) fn mob_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec<Vertex>) {
         let atlas = &self.gui.atlas;
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..4d4e4909f 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3617,6 +3617,7 @@ impl Game<'_> {
             self.remote_player_eating(&item, ticks, at, eye, pitch, yaw);
         }
         if running {
+            self.guardian_bubbles();
             // The dragon: LivingEntity's interpolation, inside its aiStep.
             let dragon_lerp = self
                 .dragon

From 9dd6933dab52997b13902e41b79802e9cbda23f5 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:46:36 +0100
Subject: [PATCH 338/475] Size players' boxes by pose, including sleeping

---
 crates/horizon-client/src/game.rs             |  5 +-
 crates/horizon-client/src/game/lan.rs         |  1 +
 crates/horizon-client/src/game/lan_actions.rs |  6 +--
 crates/horizon-client/src/game/lan_mobs.rs    | 17 +++---
 crates/horizon-client/src/game/minecarts.rs   |  7 +--
 crates/horizon-client/src/game/remote.rs      |  2 +-
 .../src/game/remote_mob_data.rs               |  6 +++
 crates/horizon-client/src/lan/guest.rs        | 42 ++++++++++++++-
 crates/horizon-client/src/lan/hub.rs          | 31 ++++++-----
 crates/horizon-client/src/mobs.rs             |  3 ++
 crates/horizon-client/src/mobs/living.rs      |  9 ++++
 crates/horizon-client/src/mobs/render.rs      |  9 +++-
 crates/horizon-client/src/motion.rs           |  3 ++
 crates/horizon-client/src/pose.rs             | 52 +++++++++++++++----
 14 files changed, 143 insertions(+), 50 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 7596ee871..8763a4077 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -1983,9 +1983,11 @@ impl Game<'_> {
     /// item in use (LocalPlayer.modifyInput), the helmet's Respiration
     /// (decreaseAirSupply), the wings, leather boots on powder snow
     /// (PowderSnowBlock.canEntityWalkOnPowderSnow), freeze-immune wear
-    /// (LivingEntity.canFreeze) and the dimension's FAST_LAVA.
+    /// (LivingEntity.canFreeze), the dimension's FAST_LAVA and the sleeping
+    /// pose.
     pub(crate) fn sync_player_body(&mut self) {
         let glider = self.glider_worn();
+        let sleeping = self.sleeping.is_some();
         let item_use_speed = self
             .using
             .and_then(|(slot, _)| {
@@ -2013,6 +2015,7 @@ impl Game<'_> {
         player.item_use_speed = item_use_speed;
         player.respiration = respiration;
         player.glider = glider;
+        let _ = player.set_sleeping(sleeping);
         player.leather_boots = leather_boots;
         player.freeze_immune = freeze_immune;
         player.fluids.fast_lava = self.dim == Dim::Nether;
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index e39fa3a68..f1a06e98b 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -1428,6 +1428,7 @@ impl Game<'_> {
                 .each_ref()
                 .map(|s| s.as_ref().map(|s| s.item.clone()));
             m.extra.crouching = g.sneaking;
+            m.extra.avatar_pose = g.pose();
             // Lying in its bed (LivingEntity.getBedOrientation).
             m.extra.ints[1] = g.bed.map_or(0, |b| self.bed_facing(b));
             // LivingEntity.updateSwingTime: the arm swing lan_swings started.
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 98162ae46..d4cbe536c 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -2182,7 +2182,7 @@ impl Game<'_> {
         }
         let in_wall = !g.sleeping && self.in_wall(g.position, g.eye_height());
         let at = g.position;
-        let sneaking = g.sneaking;
+        let (sneaking, sleeping) = (g.sneaking, g.sleeping);
         let events = self.as_guest(host, conn, |game| {
             let (rules, motion) = (game.world.health_rules, game.motion);
             let health = &motion.health;
@@ -2250,6 +2250,7 @@ impl Game<'_> {
             // Entity.applyEffectsFromBlocks along those moves: magma, cactus,
             // lit campfires and grown sweet berry bushes hurt (#1305).
             w.player.shift_key_down = sneaking;
+            let _ = w.player.set_sleeping(sleeping);
             w.player.freeze_immune = freeze_immune;
             let _ = w.server_block_damage(start);
             let _ = w.tick_environment_damage();
@@ -2626,8 +2627,7 @@ impl Game<'_> {
     /// with Mending and gives the rest as points. Everyone near hears it.
     fn guest_orbs(&mut self, host: &mut LanHost, gi: usize) {
         let g = &host.hub.guests[gi];
-        // Player's standing and crouching boxes: 1.8 and 1.5 high.
-        let height = if g.sneaking { 1.5 } else { 1.8 };
+        let height = f64::from(g.dimensions().height);
         let (conn, id, at) = (g.conn, g.entity_id, g.position);
         let unable = g.spectator() || g.dead || g.health <= 0.0;
         let play = host.play.entry(conn).or_default();
diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs
index 6527f1015..db042be43 100644
--- a/crates/horizon-client/src/game/lan_mobs.rs
+++ b/crates/horizon-client/src/game/lan_mobs.rs
@@ -175,9 +175,9 @@ impl Game<'_> {
             .iter()
             .filter(|g| host.hub.here(g) && g.loaded && !g.dead && !g.spectator())
             .map(|g| {
-                let [x, y, z] = g.position;
-                let height = if g.sneaking { 1.5 } else { 1.8 };
-                ([x - 0.3, y, z - 0.3], [x + 0.3, y + height, z + 0.3])
+                let b = g.bounds();
+                let (lo, hi) = (b.min_position(), b.max_position());
+                ([lo.x, lo.y, lo.z], [hi.x, hi.y, hi.z])
             })
             .collect()
     }
@@ -319,7 +319,7 @@ impl Game<'_> {
                     uuid: horizon_client::lan::playerdata::uuid_ints(g.uuid),
                     position: g.position,
                     eye: [x, y + g.eye_height(), z],
-                    height: if g.sneaking { 1.5 } else { 1.8 },
+                    height: g.dimensions().height,
                     creative: g.creative(),
                     spectator: g.spectator(),
                     alive: !g.dead,
@@ -336,14 +336,9 @@ impl Game<'_> {
     }
 }
 
-/// A guest's bounding box (0.6 wide, 1.8 tall, 1.5 crouching).
+/// A guest's bounding box, by its pose (`Avatar.POSES`).
 pub(super) fn guest_bounds(g: &horizon_client::lan::guest::Guest) -> Aabb {
-    let [x, y, z] = g.position;
-    let height = if g.sneaking { 1.5 } else { 1.8 };
-    Aabb::new(
-        Vec3::new(x - 0.3, y, z - 0.3),
-        Vec3::new(x + 0.3, y + height, z + 0.3),
-    )
+    g.bounds()
 }
 
 #[cfg(test)]
diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index 072059e49..8a9241a58 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -713,12 +713,7 @@ impl Game<'_> {
                 host.hub.here(g) && g.loaded && !g.dead && !g.spectator() && g.vehicle.is_none()
             }) {
                 let [x, y, z] = g.position;
-                let height = if g.sneaking { 1.5 } else { 1.8 };
-                let bb = Aabb::new(
-                    Vec3::new(x - 0.3, y, z - 0.3),
-                    Vec3::new(x + 0.3, y + height, z + 0.3),
-                );
-                pushers.push((Vec3::new(x, y, z), bb));
+                pushers.push((Vec3::new(x, y, z), g.bounds()));
             }
         }
         for (feet, bb) in pushers {
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..509eb972c 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -3555,7 +3555,7 @@ impl Game<'_> {
                         m.extra.main_hand.clone()
                     };
                     if let Some(item) = item {
-                        let eye = if m.extra.crouching { 1.27 } else { 1.62 };
+                        let eye = m.eye_height();
                         let at = [m.position.x, m.position.y, m.position.z];
                         using.push((
                             item,
diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs
index c6702dfb6..a974dd9e4 100644
--- a/crates/horizon-client/src/game/remote_mob_data.rs
+++ b/crates/horizon-client/src/game/remote_mob_data.rs
@@ -16,6 +16,12 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
     let baby = super::lan::baby_index(&m.kind.id);
     for (index, _, value) in values {
         match (*index, value) {
+            // Entity.DATA_POSE: a player's or mannequin's box follows it.
+            (6, Value::Id(pose))
+                if matches!(&*m.kind.id, "minecraft:player" | "minecraft:mannequin") =>
+            {
+                m.extra.avatar_pose = horizon_client::pose::Pose::from_id(*pose);
+            }
             // Entity.DATA_SHARED_FLAGS_ID's FLAG_ONFIRE: Entity.isOnFire on a
             // client, which draws the flames. A client doesn't count the
             // fire down: the flag goes off when the server's fire is out.
diff --git a/crates/horizon-client/src/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs
index 7e43cf04e..2deb5905e 100644
--- a/crates/horizon-client/src/lan/guest.rs
+++ b/crates/horizon-client/src/lan/guest.rs
@@ -2,7 +2,12 @@
 //! player state (inventory, health, game mode) that the host's gameplay code
 //! operates on when it acts for them.
 use super::{Joined, PlayerSender, entity::Tracker};
-use crate::{items::ItemStack, motion::PlayerMotion};
+use crate::{
+    items::ItemStack,
+    motion::PlayerMotion,
+    pose::{Dimensions, Pose},
+};
+use horizon_core::geometry::{Aabb, Vec3};
 use horizon_protocol::{
     item::Stack,
     packets::{configuration::ClientInformation, play},
@@ -407,8 +412,41 @@ impl Guest {
         }
         f
     }
+    /// `Player.getDesiredPose`: sleeping, gliding, then the body's own pose
+    /// (swimming, crawling, crouching) once its server tick has run.
+    pub fn pose(&self) -> Pose {
+        if self.sleeping {
+            Pose::Sleeping
+        } else if self.fall_flying {
+            Pose::FallFlying
+        } else if let Some(m) = &self.motion {
+            m.pose
+        } else if self.sneaking && !self.flying {
+            Pose::Crouching
+        } else {
+            Pose::Standing
+        }
+    }
+    /// `Avatar.POSES` for the guest's pose, with its scale attribute.
+    pub fn dimensions(&self) -> Dimensions {
+        let pose = self.pose();
+        match &self.motion {
+            Some(m) if m.pose == pose => m.dimensions,
+            _ => pose.dimensions(1.0),
+        }
+    }
+    /// `Entity.getBoundingBox`.
+    pub fn bounds(&self) -> Aabb {
+        let [x, y, z] = self.position;
+        let d = self.dimensions();
+        let half = f64::from(d.width) / 2.0;
+        Aabb::new(
+            Vec3::new(x - half, y, z - half),
+            Vec3::new(x + half, y + f64::from(d.height), z + half),
+        )
+    }
     pub fn eye_height(&self) -> f64 {
-        if self.sneaking { 1.27 } else { 1.62 }
+        f64::from(self.dimensions().eye_height)
     }
     /// `Player.isWithinBlockInteractionRange(pos, buffer)` for the guest:
     /// its block interaction range is 4.5, 5 in creative.
diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs
index b1a8cbc62..c4ce83946 100644
--- a/crates/horizon-client/src/lan/hub.rs
+++ b/crates/horizon-client/src/lan/hub.rs
@@ -16,6 +16,7 @@ use crate::{
     collisions::SceneCollisions,
     effects::{EffectInstance, PlayerEffects},
     items::ItemStack,
+    pose::Pose,
     world::World,
 };
 use horizon_core::geometry::{Aabb, ShapeOp, Vec3, VoxelShape};
@@ -1507,7 +1508,7 @@ impl Hub {
         position: [f64; 3],
         rot: (f32, f32, f32),
         on_ground: bool,
-        flags: (bool, bool, bool, bool),
+        flags: (bool, bool, bool, bool, bool),
         living_flags: i8,
         bed: Option<[i32; 3]>,
         skin: u8,
@@ -1515,12 +1516,14 @@ impl Hub {
         equipment: Vec<(u8, Option<horizon_protocol::item::Stack>)>,
         attributes: Vec<play::AttributeSnapshot>,
     ) -> EntityState {
-        let (sneaking, sprinting, gliding, sleeping) = flags;
+        let (sneaking, sprinting, gliding, sleeping, swimming) = flags;
         let shared = shared_flags(sneaking, sprinting, gliding);
         let pose = if sleeping {
             2
         } else if gliding {
             1
+        } else if swimming {
+            3
         } else if sneaking {
             5
         } else {
@@ -1607,7 +1610,7 @@ impl Hub {
                 h.position,
                 (h.yaw, h.pitch, h.head_yaw),
                 h.on_ground,
-                (h.sneaking, h.sprinting, false, h.bed.is_some()),
+                (h.sneaking, h.sprinting, false, h.bed.is_some(), false),
                 h.living_flags,
                 h.bed,
                 0x7F,
@@ -1639,7 +1642,13 @@ impl Hub {
                     g.position,
                     (g.yaw, g.pitch, g.head_yaw),
                     g.on_ground,
-                    (g.sneaking, g.sprinting, g.fall_flying, g.sleeping),
+                    (
+                        g.sneaking,
+                        g.sprinting,
+                        g.fall_flying,
+                        g.sleeping,
+                        g.pose() == Pose::Swimming,
+                    ),
                     g.living_flags,
                     g.bed,
                     g.info.model_customisation,
@@ -2194,18 +2203,8 @@ impl Hub {
         }
         // getBoundingBox: the box of the body's pose (swimming and crawling
         // are 0.6 tall), so a swimmer under a ceiling isn't sent back.
-        let (half, height) = if g.fall_flying {
-            (0.3, 0.6)
-        } else if let Some(m) = &g.motion {
-            (
-                f64::from(m.dimensions.width) / 2.0,
-                f64::from(m.dimensions.height),
-            )
-        } else if g.sneaking {
-            (0.3, 1.5)
-        } else {
-            (0.3, 1.8)
-        };
+        let d = g.dimensions();
+        let (half, height) = (f64::from(d.width) / 2.0, f64::from(d.height));
         let at = |p: [f64; 3]| {
             Aabb::new(
                 Vec3::new(p[0] - half, p[1], p[2] - half),
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index f4086216d..34ecab1a7 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -638,6 +638,9 @@ pub struct Attrs {
 pub struct Extra {
     /// Players: crouching and riding (HumanoidModel's poses).
     pub crouching: bool,
+    /// A player's or mannequin's synced pose (`Entity.DATA_POSE`), which
+    /// sets its box (`Avatar.POSES`).
+    pub avatar_pose: crate::pose::Pose,
     pub passenger: bool,
     /// AgeableMob.age: negative while a baby (a tadpole counts up to 24000).
     pub age: i32,
diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs
index 394821ace..829603f64 100644
--- a/crates/horizon-client/src/mobs/living.rs
+++ b/crates/horizon-client/src/mobs/living.rs
@@ -281,6 +281,15 @@ impl Mob {
             return (f64::from(0.2_f32), f64::from(0.2_f32), f64::from(0.2_f32));
         }
         let k = &self.kind;
+        // Avatar.POSES: a player's or mannequin's box follows its pose.
+        if matches!(&*k.id, "minecraft:player" | "minecraft:mannequin") {
+            let d = self.extra.avatar_pose.dimensions(1.0);
+            return (
+                f64::from(d.width),
+                f64::from(d.height),
+                f64::from(d.eye_height),
+            );
+        }
         let (mut w, mut h, mut e) = (k.width as f32, k.height as f32, k.eye_height as f32);
         // Sniffer.DIGGING_DIMENSIONS: 0.4 lower, its eyes at 0.81.
         if k.species == super::Species::Sniffer && super::sniffer::digging(self) {
diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs
index 077fd38a6..e161e6af1 100644
--- a/crates/horizon-client/src/mobs/render.rs
+++ b/crates/horizon-client/src/mobs/render.rs
@@ -765,7 +765,14 @@ pub fn base_transform_at(m: &Mob, alpha: f32, origin: glam::Mat4) -> glam::Mat4
     let rotation = match sleep {
         // setupRotations for Pose.SLEEPING, with the head moved toward the pillow.
         Some((angle, step)) => {
-            let head = (m.eye_y() - m.position.y) as f32 - 0.1;
+            // The eye height of the standing pose (LivingEntityRenderer
+            // extracts `getEyeHeight(Pose.STANDING)` for a bed).
+            let eye = if avatar(m) {
+                m.kind.eye_height as f32
+            } else {
+                (m.eye_y() - m.position.y) as f32
+            };
+            let head = eye - 0.1;
             glam::Mat4::from_translation(glam::Vec3::new(-step[0] * head, 0.0, -step[1] * head))
                 * glam::Mat4::from_rotation_y(angle.to_radians())
                 * glam::Mat4::from_rotation_z(90.0_f32.to_radians())
diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index 234390e23..a71e29abc 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -252,6 +252,8 @@ pub struct PlayerMotion {
     pub pitch: f32,
     /// Gliding (shared flag 7) and LivingEntity.fallFlyTicks.
     pub fall_flying: bool,
+    /// Asleep in a bed (`LivingEntity.isSleeping`): the sleeping pose.
+    pub sleeping: bool,
     pub fall_fly_ticks: i32,
     /// The server saw the glide end last tick (`updateFallFlying`'s `canGlide`
     /// failed): the cleared flag reaches the client at its next tick.
@@ -446,6 +448,7 @@ impl PlayerMotion {
             glider: false,
             pitch: 0.0,
             fall_flying: false,
+            sleeping: false,
             fall_fly_ticks: 0,
             glide_ending: false,
             glider_wear: 0,
diff --git a/crates/horizon-client/src/pose.rs b/crates/horizon-client/src/pose.rs
index e34b1f1fc..2a01579f3 100644
--- a/crates/horizon-client/src/pose.rs
+++ b/crates/horizon-client/src/pose.rs
@@ -15,8 +15,21 @@ pub enum Pose {
     Swimming,
     FallFlying,
     SpinAttack,
+    Sleeping,
 }
 impl Pose {
+    /// `Pose` by its network id (`Pose.id`); the poses a player never takes
+    /// are standing.
+    pub fn from_id(id: i32) -> Self {
+        match id {
+            1 => Self::FallFlying,
+            2 => Self::Sleeping,
+            3 => Self::Swimming,
+            4 => Self::SpinAttack,
+            5 => Self::Crouching,
+            _ => Self::Standing,
+        }
+    }
     pub fn name(self) -> &'static str {
         match self {
             Self::Standing => "STANDING",
@@ -24,18 +37,24 @@ impl Pose {
             Self::Swimming => "SWIMMING",
             Self::FallFlying => "FALL_FLYING",
             Self::SpinAttack => "SPIN_ATTACK",
+            Self::Sleeping => "SLEEPING",
         }
     }
+    /// `Avatar.POSES` (and `LivingEntity.SLEEPING_DIMENSIONS`): the box of a
+    /// player or mannequin in this pose; sleeping ignores the scale.
     pub fn dimensions(self, scale: f32) -> Dimensions {
-        let (height, eye_height) = match self {
-            Self::Standing => (1.8, 1.62),
-            Self::Crouching => (1.5, 1.27),
-            Self::Swimming | Self::FallFlying | Self::SpinAttack => (0.6, 0.4),
+        let (width, height, eye_height) = match self {
+            Self::Standing => (0.6 * scale, 1.8 * scale, 1.62 * scale),
+            Self::Crouching => (0.6 * scale, 1.5 * scale, 1.27 * scale),
+            Self::Swimming | Self::FallFlying | Self::SpinAttack => {
+                (0.6 * scale, 0.6 * scale, 0.4 * scale)
+            }
+            Self::Sleeping => (0.2, 0.2, 0.2),
         };
         Dimensions {
-            width: 0.6 * scale,
-            height: height * scale,
-            eye_height: eye_height * scale,
+            width,
+            height,
+            eye_height,
         }
     }
 }
@@ -73,6 +92,19 @@ impl PlayerMotion {
         }
         Ok(())
     }
+    /// `LivingEntity.startSleeping` and `stopSleeping` set the pose at once
+    /// (the 0.2 box in the bed, standing again after).
+    pub fn set_sleeping(&mut self, sleeping: bool) -> Result<()> {
+        if self.sleeping != sleeping {
+            self.sleeping = sleeping;
+            self.set_pose(if sleeping {
+                Pose::Sleeping
+            } else {
+                Pose::Standing
+            })?;
+        }
+        Ok(())
+    }
     pub fn moving_slowly(&self) -> bool {
         self.local_crouching || (self.pose == Pose::Swimming && !self.fluids.was_touching_water)
     }
@@ -100,8 +132,10 @@ impl MotionWorld<'_, '_, '_> {
         if !self.can_fit_pose(Pose::Swimming)? {
             return Ok(());
         }
-        // Player.getDesiredPose: swimming, gliding, Riptide's spin.
-        let desired = if self.player.swimming {
+        // Player.getDesiredPose: sleeping, swimming, gliding, Riptide's spin.
+        let desired = if self.player.sleeping {
+            Pose::Sleeping
+        } else if self.player.swimming {
             Pose::Swimming
         } else if self.player.fall_flying {
             Pose::FallFlying

From 688733132d7e105312337bb21cf8a96ee441ba33 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:47:27 +0100
Subject: [PATCH 339/475] Freeze mobs in powder snow and shake frozen mobs and
 cold striders

---
 .../src/game/commands/world_cmds.rs           |  1 +
 crates/horizon-client/src/game/creatures.rs   |  1 +
 crates/horizon-client/src/game/lan.rs         | 21 ++++++++
 crates/horizon-client/src/game/remote.rs      | 16 ++++++
 crates/horizon-client/src/mobs.rs             | 17 ++++++
 crates/horizon-client/src/mobs/ai.rs          | 52 +++++++++++++++++++
 crates/horizon-client/src/mobs/render.rs      |  9 +++-
 crates/horizon-client/src/mobs/sulfur_cube.rs |  1 +
 8 files changed, 116 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs
index 687eb3f88..103211dd2 100644
--- a/crates/horizon-client/src/game/commands/world_cmds.rs
+++ b/crates/horizon-client/src/game/commands/world_cmds.rs
@@ -118,6 +118,7 @@ impl Game<'_> {
             "magic" | "indirect_magic" | "dragon_breath" => DamageKind::Magic,
             "sting" => DamageKind::Sting,
             "cactus" | "sweet_berry_bush" => DamageKind::Cactus,
+            "freeze" => DamageKind::Freeze,
             "in_wall" => DamageKind::InWall,
             "thorns" => DamageKind::Thorns,
             _ => DamageKind::Generic,
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index f6961ab13..a19b2c7c5 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -3531,6 +3531,7 @@ pub(super) fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool)
         K::InWall => "minecraft:in_wall",
         K::Thorns => "minecraft:thorns",
         K::SonicBoom => "minecraft:sonic_boom",
+        K::Freeze => "minecraft:freeze",
         K::OutOfWorld => "minecraft:out_of_world",
     }
 }
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index e39fa3a68..967d29e40 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -371,6 +371,26 @@ fn mob_meta(
     }
 }
 
+/// What a client shakes a mob by: Entity.DATA_TICKS_FROZEN (7), whose full
+/// count is `isFullyFrozen`, and Strider.DATA_SUFFOCATING (18, after
+/// AgeableMob's baby flag and DATA_BOOST_TIME).
+fn mob_freeze_meta(
+    m: &Mob,
+    meta: &mut Vec<(u8, i32, Value)>,
+    defaults: &mut Vec<(u8, i32, Value)>,
+) {
+    if m.ticks_frozen > 0 {
+        meta.push((7, serializer::INT, Value::Int(m.ticks_frozen)));
+    }
+    defaults.push((7, serializer::INT, Value::Int(0)));
+    if m.kind.id == "minecraft:strider" {
+        if m.extra.flag {
+            meta.push((18, serializer::BOOLEAN, Value::Bool(true)));
+        }
+        defaults.push((18, serializer::BOOLEAN, Value::Bool(false)));
+    }
+}
+
 /// The equipment a mob shows (ClientboundSetEquipmentPacket slots: main hand,
 /// off hand, feet, legs, chest, head, body, saddle).
 fn mob_equipment(
@@ -878,6 +898,7 @@ impl Game<'_> {
             e.velocity = [m.velocity.x, m.velocity.y, m.velocity.z];
             e.needs_sync = m.needs_sync;
             mob_meta(m, hub, player_entity, &mut e.meta, &mut e.defaults);
+            mob_freeze_meta(m, &mut e.meta, &mut e.defaults);
             mob_equipment(m, hub, &mut e.equipment);
             self.mob_attributes(m, &mut e.attributes);
             e.leash = leash;
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..08f76033a 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -1916,6 +1916,22 @@ impl Game<'_> {
                         }
                     }
                 }
+                if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
+                    for (index, _, value) in &p.values {
+                        match (index, value) {
+                            // Entity.DATA_TICKS_FROZEN: isFullyFrozen shakes it.
+                            (7, Value::Int(ticks)) => m.ticks_frozen = *ticks,
+                            // Strider.DATA_SUFFOCATING (after AgeableMob's baby
+                            // flag and DATA_BOOST_TIME): a cold strider shakes.
+                            (18, Value::Bool(cold))
+                                if m.species() == horizon_client::mobs::Species::Strider =>
+                            {
+                                m.extra.flag = *cold;
+                            }
+                            _ => {}
+                        }
+                    }
+                }
                 // LivingEntity.DATA_LIVING_ENTITY_FLAGS: for another player
                 // too, remote_mob_data's apply reads index 8 above.
                 let mannequin = self
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index f4086216d..13d282eba 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -524,6 +524,8 @@ pub enum DamageKind {
     InWall,
     Thorns,
     SonicBoom,
+    /// `freeze`: a fully frozen mob in powder snow.
+    Freeze,
     /// `fell_out_of_world`: below the world's floor.
     OutOfWorld,
 }
@@ -589,6 +591,7 @@ impl Damage {
                 | DamageKind::InWall
                 | DamageKind::Generic
                 | DamageKind::SonicBoom
+                | DamageKind::Freeze
                 | DamageKind::OutOfWorld
         )
     }
@@ -612,6 +615,7 @@ impl Damage {
                 | DamageKind::Cactus
                 | DamageKind::Generic
                 | DamageKind::InWall
+                | DamageKind::Freeze
                 | DamageKind::OutOfWorld
         )
     }
@@ -1330,6 +1334,10 @@ impl Mob {
             .max((f64::from(ticks) * self.burning_time()).ceil() as i32);
         self.ticks_frozen = 0;
     }
+    /// `Entity.isFullyFrozen`.
+    pub fn is_fully_frozen(&self) -> bool {
+        self.ticks_frozen >= crate::motion::PlayerMotion::TICKS_REQUIRED_TO_FREEZE
+    }
 
     /// What other mobs see of this one this tick (`player`: the player's
     /// UUID, which villagers' reputation is keyed by).
@@ -1808,6 +1816,15 @@ impl Mob {
         {
             amount *= 0.75;
         }
+        // LivingEntity.hurtServer: `#freeze_hurts_extra_types` take five times.
+        if source.kind == DamageKind::Freeze
+            && matches!(
+                self.species(),
+                Species::Strider | Species::Blaze | Species::MagmaCube
+            )
+        {
+            amount *= 5.0;
+        }
         let (worn, worn_toughness) = self.worn_armor();
         if !source.bypasses_armor() && self.kind.armor + worn > 0.0 {
             // CombatRules.getDamageAfterAbsorb
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 258c1ccc7..1163c24c1 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -528,6 +528,7 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         {
             m.damage(1.0, Damage::of(DamageKind::Drown));
         }
+        freeze_tick(m, w);
     }
     tick_effects(m);
     if m.species() == Species::Illusioner {
@@ -557,6 +558,57 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     // Entity.baseTick ends with Leashable.tickLeash.
     super::leash::tick(m, w, events);
 }
+/// `LivingEntity.aiStep`'s "freezing" with `InsideBlockEffectType.FREEZE`:
+/// powder snow builds `ticks_frozen` up, anywhere else it melts twice as
+/// fast, and a fully frozen mob takes one freeze damage every 40 ticks.
+fn freeze_tick(m: &mut Mob, w: &MobWorld) {
+    let in_snow = in_powder_snow(m, w);
+    if !in_snow && m.ticks_frozen == 0 {
+        return;
+    }
+    let can_freeze = can_freeze(m, w);
+    if in_snow && can_freeze {
+        m.ticks_frozen =
+            (m.ticks_frozen + 1).min(crate::motion::PlayerMotion::TICKS_REQUIRED_TO_FREEZE);
+    } else {
+        m.ticks_frozen = (m.ticks_frozen - 2).max(0);
+    }
+    if m.age.is_multiple_of(40) && m.is_fully_frozen() && can_freeze {
+        m.damage(1.0, Damage::of(DamageKind::Freeze));
+    }
+}
+/// Whether the mob's box (shrunk by `1.0E-5`, as in `Entity.checkInsideBlocks`)
+/// touches powder snow.
+fn in_powder_snow(m: &Mob, w: &MobWorld) -> bool {
+    let b = m.bounds().deflate(Vec3::new(1e-5, 1e-5, 1e-5));
+    let (min, max) = (b.min_position(), b.max_position());
+    for x in min.x.floor() as i32..=max.x.floor() as i32 {
+        for y in min.y.floor() as i32..=max.y.floor() as i32 {
+            for z in min.z.floor() as i32..=max.z.floor() as i32 {
+                if &*w.facts.get(w.world.block(x, y, z)).name == "minecraft:powder_snow" {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}
+/// `LivingEntity.canFreeze`: not a `#freeze_immune_entity_types` mob and no
+/// worn piece in `#freeze_immune_wearables`.
+fn can_freeze(m: &Mob, w: &MobWorld) -> bool {
+    if w.data
+        .entity_has("minecraft:freeze_immune_entity_types", &m.kind.id)
+    {
+        return false;
+    }
+    let immune = w
+        .items
+        .and_then(|i| i.item_tags.get("minecraft:freeze_immune_wearables"));
+    ![&m.extra.head, &m.extra.chest, &m.extra.legs, &m.extra.feet]
+        .into_iter()
+        .flatten()
+        .any(|item| immune.is_some_and(|t| t.contains(&**item)))
+}
 /// `Mob.playAmbientSound` on demand: a spawn egg or a mob bucket just placed `m`.
 pub fn ambient_sound(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     play_ambient(m, w, events);
diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs
index 077fd38a6..0a6622cab 100644
--- a/crates/horizon-client/src/mobs/render.rs
+++ b/crates/horizon-client/src/mobs/render.rs
@@ -833,10 +833,15 @@ pub fn base_transform_at(m: &Mob, alpha: f32, origin: glam::Mat4) -> glam::Mat4
     base *= species_scale(m, alpha);
     base * glam::Mat4::from_translation(glam::Vec3::new(0.0, -1.501, 0.0))
 }
-/// `LivingEntityRenderer.isShaking`: converting zombies, piglins and
-/// hoglins, and a zombie villager being cured.
+/// `LivingEntityRenderer.isShaking`: a fully frozen mob (the skeleton's own
+/// `isShaking` is its stray conversion only), converting zombies, piglins
+/// and hoglins, a zombie villager being cured and a cold strider.
 fn shaking(m: &Mob) -> bool {
+    if m.is_fully_frozen() && m.species() != Species::Skeleton {
+        return true;
+    }
     match m.species() {
+        Species::Strider => super::strider::suffocating(m),
         Species::ZombieVillager => super::zombie_villager::is_converting(m),
         Species::Zombie | Species::Husk => m.extra.counter2 > 0,
         Species::Piglin | Species::PiglinBrute | Species::Hoglin => {
diff --git a/crates/horizon-client/src/mobs/sulfur_cube.rs b/crates/horizon-client/src/mobs/sulfur_cube.rs
index 00b846b86..e97134505 100644
--- a/crates/horizon-client/src/mobs/sulfur_cube.rs
+++ b/crates/horizon-client/src/mobs/sulfur_cube.rs
@@ -297,6 +297,7 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage, amount: f32) -> bool {
             | DamageKind::Fall
             | DamageKind::Sting
             | DamageKind::Cactus
+            | DamageKind::Freeze
     );
     if immune {
         if let Some(from) = source.from {

From a45d0de43eef252c6c0b45fad21e2e1bf70bf7bb Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:48:27 +0100
Subject: [PATCH 340/475] Server-thread clients animate warden, sniffer,
 breeze, camel and shulker

A client of a server (single player's window included) never got the
animation state these mobs compute on the server: no pose, no sniffer
state, no shulker peek or wall face, no camel sit or dash, no warden
tendril, attack or sonic boom events.

Send Entity.DATA_POSE and the species' synched data from mob_meta,
broadcast the warden's entity events 4, 61 and 62, read both in the
remote mob code, and run the client animation steps in
mobs::sync::client_tick.
---
 crates/horizon-client/src/game/creatures.rs   |  3 +
 crates/horizon-client/src/game/lan.rs         | 63 +++++++++++++-
 crates/horizon-client/src/game/remote.rs      |  7 ++
 .../src/game/remote_mob_data.rs               | 27 +++++-
 crates/horizon-client/src/mobs.rs             |  9 ++
 crates/horizon-client/src/mobs/breeze.rs      | 22 +++++
 crates/horizon-client/src/mobs/camel.rs       | 49 ++++++++++-
 crates/horizon-client/src/mobs/shulker.rs     | 11 +++
 crates/horizon-client/src/mobs/sniffer.rs     | 38 +++++----
 crates/horizon-client/src/mobs/sync.rs        | 85 +++++++++++++++++++
 crates/horizon-client/src/mobs/warden.rs      | 69 ++++++++++++---
 .../horizon-client/src/mobs/warden_brain.rs   |  5 ++
 12 files changed, 354 insertions(+), 34 deletions(-)
 create mode 100644 crates/horizon-client/src/mobs/sync.rs

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index f6961ab13..0ea8dd4d0 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -897,6 +897,9 @@ impl Game<'_> {
             match e {
                 MobEvent::SquidCycle { mob, at } => self.lan_entity_event(mob as i32, 19, at),
                 MobEvent::RabbitHop { mob, at } => self.lan_entity_event(mob as i32, 1, at),
+                MobEvent::EntityEvent { mob, event, at } => {
+                    self.lan_entity_event(mob as i32, event, at)
+                }
                 MobEvent::Sound(name, at, volume, pitch)
                 | MobEvent::LocalSound(name, at, volume, pitch) => {
                     self.audio
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index e39fa3a68..6e00df8fe 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -161,6 +161,7 @@ fn mob_meta(
     m: &Mob,
     hub: &Hub,
     player_entity: Option<i32>,
+    game_time: i64,
     meta: &mut Vec<(u8, i32, Value)>,
     defaults: &mut Vec<(u8, i32, Value)>,
 ) {
@@ -168,6 +169,12 @@ fn mob_meta(
     if m.fire_ticks > 0 {
         meta.push((0, serializer::BYTE, Value::Byte(1)));
     }
+    // Entity.DATA_POSE: the pose the species keeps in its own fields (a
+    // pose back at standing goes out by the entity's own default).
+    let pose = horizon_client::mobs::sync::pose_id(m);
+    if pose != 0 {
+        meta.push((6, serializer::POSE, Value::Id(i32::from(pose))));
+    }
     if let Some(name) = &m.custom_name {
         meta.push((
             2,
@@ -357,6 +364,41 @@ fn mob_meta(
             }
             defaults.push((17, serializer::BYTE, Value::Byte(0)));
         }
+        // Warden.CLIENT_ANGER_LEVEL: the heartbeat's pace.
+        "minecraft:warden" => {
+            let anger = e.warden.as_ref().map_or(0, |w| w.client_anger);
+            if anger != 0 {
+                meta.push((16, serializer::INT, Value::Int(anger)));
+            }
+            defaults.push((16, serializer::INT, Value::Int(0)));
+        }
+        // Sniffer.DATA_STATE (after AgeableMob's two).
+        "minecraft:sniffer" => {
+            if e.variant != 0 {
+                meta.push((
+                    18,
+                    serializer::SNIFFER_STATE,
+                    Value::Id(i32::from(e.variant)),
+                ));
+            }
+            defaults.push((18, serializer::SNIFFER_STATE, Value::Id(0)));
+        }
+        // Shulker.DATA_ATTACH_FACE_ID, DATA_PEEK_ID and DATA_COLOR_ID (16
+        // for none).
+        "minecraft:shulker" => {
+            if e.variant3 != 0 {
+                meta.push((16, serializer::DIRECTION, Value::Id(i32::from(e.variant3))));
+            }
+            defaults.push((16, serializer::DIRECTION, Value::Id(0)));
+            if e.counter != 0 {
+                meta.push((17, serializer::BYTE, Value::Byte(e.counter as i8)));
+            }
+            defaults.push((17, serializer::BYTE, Value::Byte(0)));
+            if e.color != 16 {
+                meta.push((18, serializer::BYTE, Value::Byte(e.color as i8)));
+            }
+            defaults.push((18, serializer::BYTE, Value::Byte(16)));
+        }
         // Enderman.DATA_CARRY_STATE.
         "minecraft:enderman" => {
             if let Some(state) = e.carried {
@@ -369,6 +411,18 @@ fn mob_meta(
         }
         _ => {}
     }
+    // Camel.DASH and LAST_POSE_CHANGE_TICK (after AbstractHorse's flags).
+    if horizon_client::mobs::camel::is_camel(m.species()) {
+        if e.flag2 {
+            meta.push((19, serializer::BOOLEAN, Value::Bool(true)));
+        }
+        defaults.push((19, serializer::BOOLEAN, Value::Bool(false)));
+        let tick = horizon_client::mobs::camel::synced_pose_tick(m, game_time);
+        if tick != 0 {
+            meta.push((20, serializer::LONG, Value::Long(tick)));
+        }
+        defaults.push((20, serializer::LONG, Value::Long(0)));
+    }
 }
 
 /// The equipment a mob shows (ClientboundSetEquipmentPacket slots: main hand,
@@ -877,7 +931,14 @@ impl Game<'_> {
             e.on_ground = m.on_ground;
             e.velocity = [m.velocity.x, m.velocity.y, m.velocity.z];
             e.needs_sync = m.needs_sync;
-            mob_meta(m, hub, player_entity, &mut e.meta, &mut e.defaults);
+            mob_meta(
+                m,
+                hub,
+                player_entity,
+                self.world.game_time,
+                &mut e.meta,
+                &mut e.defaults,
+            );
             mob_equipment(m, hub, &mut e.equipment);
             self.mob_attributes(m, &mut e.attributes);
             e.leash = leash;
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..5994af375 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -2135,6 +2135,10 @@ impl Game<'_> {
                 {
                     m.health = 0.0;
                 }
+                // The events that start a mob's animation (the warden's).
+                if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
+                    horizon_client::mobs::sync::entity_event(m, p.event as u8);
+                }
                 if p.event == super::totem::TOTEM_EVENT {
                     self.remote_totem(p.id);
                 }
@@ -3484,6 +3488,7 @@ impl Game<'_> {
                 m.fluids = fluids;
             }
         }
+        let game_time = self.world.game_time;
         let Some(r) = self.remote.as_mut() else {
             return;
         };
@@ -3589,6 +3594,8 @@ impl Game<'_> {
             if m.species() == horizon_client::mobs::Species::Bat {
                 horizon_client::mobs::bat::setup_animation_states(m);
             }
+            // The animation states a server computes in its own `ai_step`.
+            horizon_client::mobs::sync::client_tick(m, game_time);
         }
         for o in self.orbs.iter_mut().filter(|_| running) {
             o.previous = o.position;
diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs
index c6702dfb6..bd452ba85 100644
--- a/crates/horizon-client/src/game/remote_mob_data.rs
+++ b/crates/horizon-client/src/game/remote_mob_data.rs
@@ -4,7 +4,7 @@
 //! own simulation, which a client of a server doesn't run.
 use super::Game;
 use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES};
-use horizon_client::mobs::{Mob, Species, Who, bat, tame};
+use horizon_client::mobs::{Mob, Species, Who, bat, camel, sniffer, sync, tame};
 use horizon_protocol::entity_data::Value;
 use horizon_protocol::registry::Builtin;
 
@@ -20,6 +20,8 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
             // client, which draws the flames. A client doesn't count the
             // fire down: the flag goes off when the server's fire is out.
             (0, Value::Byte(flags)) => m.fire_ticks = i32::from(flags & 1),
+            // Entity.DATA_POSE: the pose the species animates by.
+            (6, Value::Id(pose)) => sync::set_pose(m, (*pose).clamp(0, 17) as u8),
             // LivingEntity.DATA_LIVING_ENTITY_FLAGS: using an item 1, in the
             // off hand 2. The flag starts and stops the use; the client ticks
             // the count itself (a bow's pull follows it).
@@ -79,6 +81,29 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
             (Species::Slime | Species::MagmaCube, 18, Value::Int(size)) => {
                 m.extra.size = (*size).clamp(1, 127);
             }
+            // Warden.CLIENT_ANGER_LEVEL: the heartbeat's pace.
+            (Species::Warden, 16, Value::Int(anger)) => {
+                if let Some(st) = m.extra.warden.as_mut() {
+                    st.client_anger = *anger;
+                }
+            }
+            // Sniffer.DATA_STATE (after AgeableMob's two): the animation
+            // follows it in `sync::client_tick`.
+            (Species::Sniffer, 18, Value::Id(state)) => {
+                sniffer::set_state(m, (*state).clamp(0, 6) as u8);
+            }
+            // Shulker.DATA_ATTACH_FACE_ID, DATA_PEEK_ID and DATA_COLOR_ID.
+            (Species::Shulker, 16, Value::Id(face)) => m.extra.variant3 = (*face).clamp(0, 5) as u8,
+            (Species::Shulker, 17, Value::Byte(peek)) => m.extra.counter = i32::from(*peek),
+            (Species::Shulker, 18, Value::Byte(color)) => m.extra.color = *color as u8,
+            // Camel.DASH and LAST_POSE_CHANGE_TICK (after AbstractHorse's
+            // flags).
+            (Species::Camel | Species::CamelHusk, 19, Value::Bool(dashing)) => {
+                camel::set_dashing(m, *dashing);
+            }
+            (Species::Camel | Species::CamelHusk, 20, Value::Long(tick)) => {
+                camel::set_synced_pose_tick(m, *tick);
+            }
             // Pillager.IS_CHARGING_CROSSBOW: the charge pose (Raider's
             // IS_CELEBRATING takes 16).
             (Species::Pillager, 17, Value::Bool(charging)) => m.extra.flag = *charging,
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index f4086216d..3daeeb10a 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -65,6 +65,7 @@ pub mod spawning;
 pub mod species;
 pub mod strider;
 pub mod sulfur_cube;
+pub mod sync;
 pub mod tame;
 pub mod trader;
 pub mod transport_items;
@@ -776,6 +777,8 @@ pub struct Extra {
     pub memories: Vec<(&'static str, i64, i64)>,
     /// A camel's `LAST_POSE_CHANGE_TICK`.
     pub pose_change_tick: i64,
+    /// `Entity.DATA_POSE` as a mob of a server has it (`sync::pose_id`).
+    pub pose: u8,
     /// The school leader a fish follows, and a tropical fish that swims alone.
     pub leader: Option<u32>,
     pub lone: bool,
@@ -885,6 +888,12 @@ pub enum MobEvent {
         mob: u32,
         at: [f64; 3],
     },
+    /// `Level.broadcastEntityEvent` for a mob: guests run `sync::entity_event`.
+    EntityEvent {
+        mob: u32,
+        event: i8,
+        at: [f64; 3],
+    },
     Sound(&'static str, [f64; 3], f32, f32),
     /// `ChestBlockEntity.startOpen` / `stopOpen` by a copper golem: the
     /// chest's opener count goes up or down (interaction range 3).
diff --git a/crates/horizon-client/src/mobs/breeze.rs b/crates/horizon-client/src/mobs/breeze.rs
index 5d78fa8ab..dee48f3d0 100644
--- a/crates/horizon-client/src/mobs/breeze.rs
+++ b/crates/horizon-client/src/mobs/breeze.rs
@@ -31,6 +31,28 @@ pub fn pose(m: &Mob) -> u8 {
 pub(super) fn set_pose(m: &mut Mob, pose: u8) {
     m.extra.variant3 = pose;
 }
+/// `Pose.id` of the pose (`sync::pose_id`), and its inverse.
+pub fn pose_id(m: &Mob) -> u8 {
+    match pose(m) {
+        SHOOTING => 16,
+        INHALING => 17,
+        LONG_JUMPING => 6,
+        SLIDING => 15,
+        _ => 0,
+    }
+}
+pub(super) fn set_pose_id(m: &mut Mob, id: u8) {
+    set_pose(
+        m,
+        match id {
+            16 => SHOOTING,
+            17 => INHALING,
+            6 => LONG_JUMPING,
+            15 => SLIDING,
+            _ => STANDING,
+        },
+    );
+}
 /// `Breeze.getFiringYPosition`.
 pub fn firing_y(m: &Mob) -> f64 {
     m.position.y + f64::from(m.height()) / 2.0 + f64::from(0.3_f32)
diff --git a/crates/horizon-client/src/mobs/camel.rs b/crates/horizon-client/src/mobs/camel.rs
index 21ebe9e16..c350c483f 100644
--- a/crates/horizon-client/src/mobs/camel.rs
+++ b/crates/horizon-client/src/mobs/camel.rs
@@ -45,6 +45,25 @@ pub fn sitting(m: &Mob) -> bool {
 fn in_transition(m: &Mob) -> bool {
     pose_time(m) < if sitting(m) { SIT_DOWN } else { STAND_UP }
 }
+/// `Camel.getPoseTime` of a client mob from the `LAST_POSE_CHANGE_TICK` it
+/// was sent and the client's game time, and whether that value says it sits.
+fn client_pose(m: &Mob, game_time: i64) -> (i64, bool) {
+    let tick = m.extra.pose_change_tick;
+    (game_time - tick.abs(), tick < 0)
+}
+/// The camel's `LAST_POSE_CHANGE_TICK` as the server sends it: in game time
+/// (a mob counts its own age), negative while sitting.
+pub fn synced_pose_tick(m: &Mob, game_time: i64) -> i64 {
+    let tick = (game_time - pose_time(m)).max(0);
+    if sitting(m) { -tick.max(1) } else { tick }
+}
+/// `Entity.onSyncedDataUpdated` for the pose tick of a client mob: its sign
+/// is whether it sits. `client_tick` keeps `egg_time` (in the mob's age, for
+/// `sitting` and `refuse_to_move`) with it.
+pub fn set_synced_pose_tick(m: &mut Mob, tick: i64) {
+    m.extra.pose_change_tick = tick;
+    m.extra.egg_time = if tick < 0 { -1 } else { 0 };
+}
 /// `Camel.refuseToMove`: sitting or getting up or down.
 pub fn refuse_to_move(m: &Mob) -> bool {
     sitting(m) || in_transition(m)
@@ -166,7 +185,29 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
         m.ai.zza = 0.0;
         m.ai.nav.stop();
     }
-    // setupAnimationStates.
+    animation_states(m, pose_time(m), sitting(m));
+}
+/// `Camel.tick` on a client that is not the server: the dash cooldown, which
+/// the dash flag starts, and the keyframe states from the synced pose tick.
+pub fn client_tick(m: &mut Mob, game_time: i64) {
+    if m.extra.anim_ticks > 0 {
+        m.extra.anim_ticks -= 1;
+    }
+    let (pose_time, sitting) = client_pose(m, game_time);
+    let since = (i64::from(m.age) - pose_time).max(0) as i32;
+    m.extra.egg_time = if sitting { -since.max(1) } else { since };
+    animation_states(m, pose_time, sitting);
+}
+/// `Camel.onSyncedDataUpdated(DASH)`: a dash starts the cooldown unless it
+/// runs. Not on the first tick.
+pub fn set_dashing(m: &mut Mob, dashing: bool) {
+    if m.age > 0 && m.extra.anim_ticks == 0 {
+        m.extra.anim_ticks = DASH_COOLDOWN;
+    }
+    m.extra.flag2 = dashing;
+}
+/// `Camel.setupAnimationStates` for a pose time and whether it sits.
+fn animation_states(m: &mut Mob, pose_time: i64, sitting: bool) {
     let age = m.age as f32;
     if m.extra.ints[0] <= 0 {
         m.extra.ints[0] = m.random.next_int_bound(40).unwrap_or(0) + 80;
@@ -175,9 +216,9 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
         m.extra.ints[0] -= 1;
     }
     // isCamelVisuallySitting: (poseTime < 0) != sitting.
-    let visually_sitting = (pose_time(m) < 0) != sitting(m);
-    let sitting_down = sitting(m) && pose_time(m) < SIT_DOWN && pose_time(m) >= 0;
-    let transition = in_transition(m) && pose_time(m) >= 0;
+    let visually_sitting = (pose_time < 0) != sitting;
+    let sitting_down = sitting && (0..SIT_DOWN).contains(&pose_time);
+    let transition = (0..if sitting { SIT_DOWN } else { STAND_UP }).contains(&pose_time);
     let dashing = m.extra.flag2;
     let st = &mut m.anim.states;
     if visually_sitting {
diff --git a/crates/horizon-client/src/mobs/shulker.rs b/crates/horizon-client/src/mobs/shulker.rs
index 6f0edc2d7..4c4c159aa 100644
--- a/crates/horizon-client/src/mobs/shulker.rs
+++ b/crates/horizon-client/src/mobs/shulker.rs
@@ -143,6 +143,10 @@ pub fn tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
             }
         }
     }
+    peek_step(m);
+}
+/// `Shulker.updatePeekAmount`: the lid eases to the raw peek.
+fn peek_step(m: &mut Mob) {
     let a = &mut m.anim;
     let target = m.extra.counter as f32 * 0.01;
     let cur = a.v[PEEK];
@@ -152,6 +156,13 @@ pub fn tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         a.v[PEEK] = (cur + 0.05).clamp(0.0, target);
     }
 }
+/// `Shulker.tick` on a client that is not the server: the lid eases to the
+/// peek it was sent, and its body stays square (`ShulkerBodyRotationControl`).
+pub fn client_tick(m: &mut Mob) {
+    m.anim.vo = m.anim.v;
+    peek_step(m);
+    m.body_yaw = 0.0;
+}
 /// `Shulker.hurtServer` before the damage: arrows bounce off a closed shell.
 pub fn accepts(m: &Mob, source: &Damage) -> bool {
     !(m.extra.counter == 0 && source.kind == DamageKind::Arrow)
diff --git a/crates/horizon-client/src/mobs/sniffer.rs b/crates/horizon-client/src/mobs/sniffer.rs
index c0c8d8155..72aa76cc2 100644
--- a/crates/horizon-client/src/mobs/sniffer.rs
+++ b/crates/horizon-client/src/mobs/sniffer.rs
@@ -74,23 +74,8 @@ pub fn head_block(m: &Mob) -> [i32; 3] {
 /// the dropped seed and the water malus.
 pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
     use super::path::PathType;
-    let age = m.age as f32;
     let current = state(m);
-    if current != m.extra.scratch[0] as u8 {
-        // resetAnimations, then the state's own.
-        for s in &mut m.anim.states[..5] {
-            s.stop();
-        }
-        match current {
-            FEELING_HAPPY => m.anim.states[0].start_if_stopped(age),
-            SCENTING => m.anim.states[1].start_if_stopped(age),
-            SNIFFING => m.anim.states[2].start_if_stopped(age),
-            DIGGING => m.anim.states[3].start_if_stopped(age),
-            RISING => m.anim.states[4].start_if_stopped(age),
-            _ => {}
-        }
-        m.extra.scratch[0] = i32::from(current);
-    }
+    animate(m);
     if current == DIGGING && now(m) == m.extra.ints[3] {
         let h = head_block(m);
         events.push(MobEvent::GiftLoot {
@@ -110,6 +95,27 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
     let wet = m.fluids.in_water || m.fire_ticks > 0;
     m.set_malus(PathType::Water, if wet { 0.0 } else { -1.0 });
 }
+/// `Sniffer.onSyncedDataUpdated(DATA_STATE)`: the animation states of the
+/// state it changed to (on a client, each tick for the state it has).
+pub fn animate(m: &mut Mob) {
+    let age = m.age as f32;
+    let current = state(m);
+    if current != m.extra.scratch[0] as u8 {
+        // resetAnimations, then the state's own.
+        for s in &mut m.anim.states[..5] {
+            s.stop();
+        }
+        match current {
+            FEELING_HAPPY => m.anim.states[0].start_if_stopped(age),
+            SCENTING => m.anim.states[1].start_if_stopped(age),
+            SNIFFING => m.anim.states[2].start_if_stopped(age),
+            DIGGING => m.anim.states[3].start_if_stopped(age),
+            RISING => m.anim.states[4].start_if_stopped(age),
+            _ => {}
+        }
+        m.extra.scratch[0] = i32::from(current);
+    }
+}
 /// The brain memory holding the explored positions
 /// (`SNIFFER_EXPLORED_POSITIONS`).
 pub fn to_nbt(m: &Mob, map: &mut horizon_world::nbt::Compound) {
diff --git a/crates/horizon-client/src/mobs/sync.rs b/crates/horizon-client/src/mobs/sync.rs
new file mode 100644
index 000000000..d1c5b6609
--- /dev/null
+++ b/crates/horizon-client/src/mobs/sync.rs
@@ -0,0 +1,85 @@
+//! A server's mobs as a client animates them. The server thread, a LAN host
+//! and a dedicated server run each mob's animation state (`ai::tick`); a
+//! client of a server only gets synched data and entity events, and runs the
+//! animation steps vanilla runs on the client (`Entity.onSyncedDataUpdated`,
+//! `handleEntityEvent` and the per tick animation states). The server's half
+//! is `game/lan.rs` (`mob_meta`, with `pose_id` here for index 6) and
+//! `MobEvent::EntityEvent`; the client's half is `game/remote_mob_data.rs`,
+//! `game/remote.rs` (`C::EntityEvent`) and `client_tick` here.
+//!
+//! To animate another species for a client:
+//! - send its synched data in `mob_meta` and read it in
+//!   `remote_mob_data::apply`;
+//! - send its poses in `pose_id` and read them in `set_pose`;
+//! - broadcast its entity events with `MobEvent::EntityEvent` and handle
+//!   them in `entity_event`;
+//! - run its client side animation in `client_tick`, sharing the function
+//!   with the server's `ai_step` where the server computes the same.
+use super::{Mob, Species, breeze, camel, shulker, sniffer, warden};
+
+// `Pose.id` of the poses mobs take.
+pub const STANDING: u8 = 0;
+pub const LONG_JUMPING: u8 = 6;
+pub const SITTING: u8 = 10;
+pub const ROARING: u8 = 11;
+pub const SNIFFING: u8 = 12;
+pub const EMERGING: u8 = 13;
+pub const DIGGING: u8 = 14;
+pub const SLIDING: u8 = 15;
+pub const SHOOTING: u8 = 16;
+pub const INHALING: u8 = 17;
+
+/// `Entity.DATA_POSE` (index 6) of a mob of a server: the pose its species
+/// keeps in its own fields.
+pub fn pose_id(m: &Mob) -> u8 {
+    match m.species() {
+        Species::Warden => warden::pose_id(m),
+        Species::Breeze => breeze::pose_id(m),
+        Species::Camel | Species::CamelHusk if camel::sitting(m) => SITTING,
+        _ => STANDING,
+    }
+}
+
+/// `Entity.onSyncedDataUpdated(DATA_POSE)` on a client.
+pub fn set_pose(m: &mut Mob, id: u8) {
+    m.extra.pose = id;
+    match m.species() {
+        Species::Warden => warden::set_pose_id(m, id),
+        Species::Breeze => breeze::set_pose_id(m, id),
+        _ => {}
+    }
+}
+
+/// The per tick animation steps of a client's mobs (after `m.age` moved on),
+/// for the species whose server runs them in `ai_step`. `game_time` is the
+/// client level's.
+pub fn client_tick(m: &mut Mob, game_time: i64) {
+    match m.species() {
+        Species::Warden => warden::client_tick(m),
+        Species::Sniffer => sniffer::animate(m),
+        Species::Breeze => breeze::ai_step(m),
+        Species::Camel | Species::CamelHusk => camel::client_tick(m, game_time),
+        Species::Shulker => shulker::client_tick(m),
+        _ => {}
+    }
+}
+
+/// `handleEntityEvent` of the mob types that start animations by an event
+/// (`ClientboundEntityEventPacket` for a mob of a client).
+pub fn entity_event(m: &mut Mob, event: u8) {
+    let age = m.age as f32;
+    if m.species() == Species::Warden {
+        match event {
+            // Attack: the roar ends, the swing starts.
+            4 => {
+                m.anim.states[warden::ROAR].stop();
+                m.anim.states[warden::ATTACK].start(age);
+            }
+            // The tendrils twitch.
+            61 => m.anim.v[warden::TENDRIL] = 10.0,
+            // The sonic boom.
+            62 => m.anim.states[warden::SONIC_BOOM].start(age),
+            _ => {}
+        }
+    }
+}
diff --git a/crates/horizon-client/src/mobs/warden.rs b/crates/horizon-client/src/mobs/warden.rs
index 11161ef7c..9092c9e8f 100644
--- a/crates/horizon-client/src/mobs/warden.rs
+++ b/crates/horizon-client/src/mobs/warden.rs
@@ -67,6 +67,29 @@ impl Pose {
         }
     }
 }
+/// `Pose.id` of the poses a warden takes (`sync::pose_id`).
+pub fn pose_id(m: &Mob) -> u8 {
+    match pose(m) {
+        Pose::Standing => 0,
+        Pose::Roaring => 11,
+        Pose::Sniffing => 12,
+        Pose::Emerging => 13,
+        Pose::Digging => 14,
+    }
+}
+/// `Entity.onSyncedDataUpdated(DATA_POSE)` on a client.
+pub(super) fn set_pose_id(m: &mut Mob, id: u8) {
+    set_pose(
+        m,
+        match id {
+            11 => Pose::Roaring,
+            12 => Pose::Sniffing,
+            13 => Pose::Emerging,
+            14 => Pose::Digging,
+            _ => Pose::Standing,
+        },
+    );
+}
 /// The warden's pose (kept in `Extra.counter` so it can be read while the
 /// brain is being ticked).
 pub fn pose(m: &Mob) -> Pose {
@@ -434,6 +457,11 @@ pub fn do_push(m: &mut Mob, w: &MobWorld, who: Who, events: &mut Vec<MobEvent>)
 pub(super) fn do_hurt_target(m: &mut Mob, target: Who, w: &MobWorld, events: &mut Vec<MobEvent>) {
     m.anim.states[ROAR].stop();
     m.anim.states[ATTACK].start(m.age as f32);
+    events.push(MobEvent::EntityEvent {
+        mob: m.id,
+        event: 4,
+        at: at(m),
+    });
     let pitch = voice_pitch(m);
     sound(m, "entity.warden.attack_impact", 10.0, pitch, events);
     warden_brain::mem(m).sonic_boom_cooldown.set_ttl((), 40);
@@ -546,6 +574,11 @@ fn receive_vibration(m: &mut Mob, w: &MobWorld, info: Info, events: &mut Vec<Mob
     warden_brain::mem(m).vibration_cooldown.set_ttl((), 40);
     // Entity event 61: the tendrils twitch.
     m.anim.v[TENDRIL] = 10.0;
+    events.push(MobEvent::EntityEvent {
+        mob: m.id,
+        event: 61,
+        at: at(m),
+    });
     let pitch = voice_pitch(m);
     sound(m, "entity.warden.tendril_clicks", 5.0, pitch, events);
     let origin = [
@@ -731,13 +764,7 @@ pub(super) fn tick_sonic_boom(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEve
 /// of the warden: a level event sound here), the tendril and heart
 /// animations, digging crumbs, and keyframes that ended.
 pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
-    let Some(st) = m.extra.warden.as_ref() else {
-        return;
-    };
-    let client_anger = st.client_anger;
-    let delay = heart_beat_delay(client_anger);
-    if i64::from(m.age) % i64::from(delay) == 0 {
-        m.anim.v[HEART] = 10.0;
+    if heartbeat(m) {
         events.push(MobEvent::LevelEventSound {
             sound: "entity.warden.heartbeat",
             at: at(m),
@@ -745,12 +772,30 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
             spread: 0.2,
         });
     }
-    // The animation values count down after the sync of the last tick.
-    for slot in [TENDRIL, HEART] {
-        if m.anim.v[slot] > 0.0 {
-            m.anim.v[slot] -= 1.0;
-        }
+    animate(m, events);
+}
+/// The heart's beat on its clock, from the client's anger level: whether
+/// this tick has one (its sound is the caller's).
+fn heartbeat(m: &mut Mob) -> bool {
+    let Some(st) = m.extra.warden.as_ref() else {
+        return false;
+    };
+    let delay = heart_beat_delay(st.client_anger);
+    let beat = i64::from(m.age) % i64::from(delay) == 0;
+    if beat {
+        m.anim.v[HEART] = 10.0;
     }
+    beat
+}
+/// `Warden.tick` on a client that is not the server: the heart and tendril
+/// animations and the keyframes that ended. Its sounds and particles come
+/// from the server.
+pub fn client_tick(m: &mut Mob) {
+    m.anim.vo = m.anim.v;
+    heartbeat(m);
+    animate(m, &mut Vec::new());
+}
+fn animate(m: &mut Mob, events: &mut Vec<MobEvent>) {
     let digging_clock = |m: &Mob, slot: usize| {
         m.anim.states[slot]
             .millis(m.age as f32)
diff --git a/crates/horizon-client/src/mobs/warden_brain.rs b/crates/horizon-client/src/mobs/warden_brain.rs
index 8caafefc9..667bbedf0 100644
--- a/crates/horizon-client/src/mobs/warden_brain.rs
+++ b/crates/horizon-client/src/mobs/warden_brain.rs
@@ -937,6 +937,11 @@ impl B {
                 mm.sonic_boom_sound_delay.set_ttl((), SONIC_SOUND_DELAY);
                 // Entity event 62: the sonic boom keyframes start.
                 m.anim.states[warden::SONIC_BOOM].start(m.age as f32);
+                cx.events.push(MobEvent::EntityEvent {
+                    mob: m.id,
+                    event: 62,
+                    at: [m.position.x, m.position.y, m.position.z],
+                });
                 sound(m, "entity.warden.sonic_charge", 3.0, 1.0, cx.events);
                 true
             }

From c05dc8af22482a04f7a692e5f289d5edca0e4d83 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:49:24 +0100
Subject: [PATCH 341/475] Use vanilla's head turn limits for guardian, shulker,
 ravager, camel and sitting wolf, and draw a parrot in water as flying

---
 crates/horizon-client/src/mobs/body_anim.rs |  3 ++-
 crates/horizon-client/src/mobs/control.rs   | 12 ++++++++++--
 crates/horizon-client/src/mobs/goals.rs     |  4 ++--
 crates/horizon-client/src/mobs/species.rs   |  4 ++++
 crates/horizon-client/src/mobs/tame.rs      | 12 ++----------
 5 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/crates/horizon-client/src/mobs/body_anim.rs b/crates/horizon-client/src/mobs/body_anim.rs
index bbb44c5ab..7344e6dd3 100644
--- a/crates/horizon-client/src/mobs/body_anim.rs
+++ b/crates/horizon-client/src/mobs/body_anim.rs
@@ -980,9 +980,10 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool {
         Species::Parrot => {
             let flap = m.anim.flap_o + (m.anim.flap - m.anim.flap_o) * s.partial;
             let speed = m.anim.flap_speed_o + (m.anim.flap_speed - m.anim.flap_speed_o) * s.partial;
+            // `Parrot.isFlying` is `!onGround`, in water too.
             let pose = if m.extra.sitting {
                 ParrotPose::Sitting
-            } else if !m.on_ground && !m.fluids.in_water {
+            } else if !m.on_ground {
                 ParrotPose::Flying
             } else {
                 ParrotPose::Standing
diff --git a/crates/horizon-client/src/mobs/control.rs b/crates/horizon-client/src/mobs/control.rs
index 3df557362..47839143c 100644
--- a/crates/horizon-client/src/mobs/control.rs
+++ b/crates/horizon-client/src/mobs/control.rs
@@ -1,6 +1,6 @@
 //! Mob controls: `MoveControl` (with the flying and smooth-swimming
 //! variants), `LookControl`, `JumpControl` and `BodyRotationControl`.
-use super::{Mob, MobWorld, living::wrap};
+use super::{Mob, MobWorld, Species, living::wrap};
 use horizon_core::geometry::trig;
 
 /// `2.5000003E-7F` widened: the squared distance controls treat as arrived.
@@ -113,8 +113,16 @@ pub struct BodyRotation {
     last_stable_head: f32,
 }
 impl Mob {
+    /// `Mob.getMaxHeadXRot`, with `Wolf`'s 20 degrees while sitting.
+    pub fn max_head_x_rot(&self) -> f32 {
+        if self.species() == Species::Wolf && self.extra.sitting {
+            20.0
+        } else {
+            self.kind.max_head_x_rot
+        }
+    }
     pub fn look_at(&mut self, at: [f64; 3]) {
-        let (y, x) = (self.kind.head_rot_speed, self.kind.max_head_x_rot);
+        let (y, x) = (self.kind.head_rot_speed, self.max_head_x_rot());
         self.ai.look.set_look_at(at, y, x);
     }
     pub fn look_at_speed(&mut self, at: [f64; 3], y_speed: f32, x_max: f32) {
diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs
index 541398bc5..c370f2e43 100644
--- a/crates/horizon-client/src/mobs/goals.rs
+++ b/crates/horizon-client/src/mobs/goals.rs
@@ -1741,7 +1741,7 @@ impl Goal for Tempt {
     }
     fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
         let Some(p) = cx.w.player.clone() else { return };
-        let (y, x) = (m.kind.max_head_y_rot + 20.0, m.kind.max_head_x_rot);
+        let (y, x) = (m.kind.max_head_y_rot + 20.0, m.max_head_x_rot());
         m.look_at_speed(p.eye, y, x);
         if m.distance_sqr(p.position) < self.stop_distance * self.stop_distance {
             m.nav_stop();
@@ -1850,7 +1850,7 @@ impl Goal for Breed {
         let Some(p) = self.partner.and_then(|p| cx.w.seen(p)).cloned() else {
             return;
         };
-        let x = m.kind.max_head_x_rot;
+        let x = m.max_head_x_rot();
         m.look_at_speed([p.position.x, p.eye_y, p.position.z], 10.0, x);
         m.nav_move_to_entity(
             cx.w,
diff --git a/crates/horizon-client/src/mobs/species.rs b/crates/horizon-client/src/mobs/species.rs
index f48a21fe9..047c1f882 100644
--- a/crates/horizon-client/src/mobs/species.rs
+++ b/crates/horizon-client/src/mobs/species.rs
@@ -1629,6 +1629,7 @@ impl Def {
         match self.species {
             Species::Dolphin | Species::Axolotl => 1.0,
             Species::Slime | Species::MagmaCube | Species::SulfurCube => 0.0,
+            Species::Guardian | Species::ElderGuardian | Species::Shulker => 180.0,
             _ => 40.0,
         }
     }
@@ -1640,6 +1641,9 @@ impl Def {
             Species::Sniffer => 50.0,
             Species::Goat => 15.0,
             Species::Armadillo => 32.0,
+            Species::Ravager => 45.0,
+            Species::Camel | Species::CamelHusk => 30.0,
+            Species::Shulker => 180.0,
             _ => 75.0,
         }
     }
diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs
index 1e725df80..3361a1f12 100644
--- a/crates/horizon-client/src/mobs/tame.rs
+++ b/crates/horizon-client/src/mobs/tame.rs
@@ -360,7 +360,7 @@ impl Goal for FollowOwner {
         };
         let far = m.distance_sqr(at) >= 144.0;
         if !far {
-            let max = max_head_x_rot(m);
+            let max = m.max_head_x_rot();
             m.look_at_speed([at.x, eye, at.z], 10.0, max);
         }
         self.recalc -= 1;
@@ -507,7 +507,7 @@ impl Goal for Beg {
     }
     fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
         if let Some(p) = &cx.w.player {
-            let max = max_head_x_rot(m);
+            let max = m.max_head_x_rot();
             m.look_at_speed([p.position.x, p.eye[1], p.position.z], 10.0, max);
         }
         self.ticks -= 1;
@@ -683,14 +683,6 @@ pub fn texture(m: &Mob) -> String {
     let baby = if m.is_baby() { "_baby" } else { "" };
     format!("entity/wolf/{file}{state}{baby}")
 }
-/// `Wolf.getMaxHeadXRot`: 20 degrees while sitting.
-fn max_head_x_rot(m: &Mob) -> f32 {
-    if m.extra.sitting {
-        20.0
-    } else {
-        m.kind.max_head_x_rot
-    }
-}
 
 /// Cat variants (`CatVariants`): registry name, texture file.
 pub const CAT_VARIANTS: [&str; 11] = [

From 348054d26e848f42f9dec6cf0d38586e225c181d Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:52:16 +0100
Subject: [PATCH 342/475] Draw F3+B hitboxes for every entity

---
 crates/horizon-client/src/game/debug_keys.rs | 167 ++++++++++++++++++-
 crates/horizon-client/src/game/fireworks.rs  |   2 +-
 crates/horizon-client/src/game/fishing.rs    |   8 +-
 crates/horizon-client/src/game/trident.rs    |   2 +-
 crates/horizon-client/src/gizmos.rs          |  13 ++
 5 files changed, 184 insertions(+), 8 deletions(-)

diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs
index 16e7fc6e7..1428ae9b2 100644
--- a/crates/horizon-client/src/game/debug_keys.rs
+++ b/crates/horizon-client/src/game/debug_keys.rs
@@ -13,7 +13,7 @@ use horizon_client::{
     save::VERSION_NAME,
     text::Text,
 };
-use horizon_core::geometry::Axis;
+use horizon_core::geometry::{Axis, Vec3};
 use winit::keyboard::KeyCode;
 
 /// `ChatFormatting.YELLOW` and `RED`.
@@ -766,7 +766,8 @@ impl Game<'_> {
         }
         let lerp = |a: f64, b: f64| a + f64::from(alpha) * (b - a);
         let lerpf = |a: f32, b: f32| a + alpha * (b - a);
-        for m in &self.mobs {
+        let guests = self.lan.iter().flat_map(|h| h.models.values());
+        for m in self.mobs.iter().chain(guests) {
             if m.removed || m.invisible || m.has_effect("minecraft:invisibility") {
                 continue;
             }
@@ -796,6 +797,159 @@ impl Game<'_> {
             // EntityType.ITEM: 0.25 by 0.25, eyes at 0.2125.
             g.hitbox(pos, (0.25, 0.25), 0.2125, false, (0.0, 0.0));
         }
+        // The other entities (EntityTypes sizes; eyes at 0.85 of the height
+        // unless the type sets one). `at` is the interpolated position.
+        let at = |previous: Vec3, now: Vec3| {
+            [
+                lerp(previous.x, now.x),
+                lerp(previous.y, now.y),
+                lerp(previous.z, now.z),
+            ]
+        };
+        for p in &self.paintings {
+            let (min, max) = p.bounds();
+            let centre = std::array::from_fn(|i| (min[i] + max[i]) / 2.0);
+            g.entity_box(min, max, centre, 0.425, false, step_view(p.step()));
+        }
+        for f in self.item_frames.iter().filter(|f| !f.invisible) {
+            let (min, max) = f.bounds();
+            let centre = std::array::from_fn(|i| (min[i] + max[i]) / 2.0);
+            g.entity_box(min, max, centre, 0.0, false, step_view(f.step()));
+        }
+        for c in &self.cushions {
+            let (min, max) = c.bounds();
+            let p = c.position;
+            g.entity_box(min, max, [p.x, p.y, p.z], 0.2125, false, (0.0, c.yaw));
+        }
+        for a in self.armor_stands.iter().filter(|a| !a.invisible) {
+            // ArmorStand.getDimensions: a marker has none, a small one is
+            // half scale with its eyes at 0.9875.
+            let (size, eye) = match (a.marker, a.small) {
+                (true, _) => ((0.0, 0.0), 0.0),
+                (_, true) => ((0.25, 0.9875), 0.9875),
+                _ => ((0.5, 1.975), 1.7775),
+            };
+            let p = a.position;
+            g.hitbox([p.x, p.y, p.z], size, eye, true, (0.0, a.yaw));
+        }
+        for b in &self.boats {
+            let h = super::boats::HEIGHT as f32;
+            g.hitbox(
+                at(b.previous, b.position),
+                (super::boats::WIDTH as f32, h),
+                h,
+                false,
+                (0.0, b.yaw),
+            );
+        }
+        for c in &self.carts {
+            let (w, h) = (
+                super::minecarts::WIDTH as f32,
+                super::minecarts::HEIGHT as f32,
+            );
+            g.hitbox(
+                at(c.previous, c.position),
+                (w, h),
+                h * 0.85,
+                false,
+                (0.0, c.yaw),
+            );
+        }
+        for o in &self.orbs {
+            g.hitbox(
+                at(o.previous, o.position),
+                (0.5, 0.5),
+                0.425,
+                false,
+                (0.0, 0.0),
+            );
+        }
+        for f in &self.falling {
+            g.hitbox(
+                at(f.previous, f.position),
+                (0.98, 0.98),
+                0.833,
+                false,
+                (0.0, 0.0),
+            );
+        }
+        for t in &self.tnts {
+            g.hitbox(
+                at(t.previous, t.position),
+                (0.98, 0.98),
+                0.15,
+                false,
+                (0.0, 0.0),
+            );
+        }
+        for c in &self.crystals {
+            let p = c.position;
+            g.hitbox([p.x, p.y, p.z], (2.0, 2.0), 1.7, false, (0.0, 0.0));
+        }
+        for p in &self.creatures.projectiles {
+            use horizon_client::projectiles::ProjectileKind as K;
+            let (size, eye) = match p.kind {
+                K::Arrow { .. } => (0.5, 0.13),
+                K::Snowball | K::Egg | K::EnderPearl | K::LlamaSpit | K::Potion { .. } => {
+                    (0.25, 0.2125)
+                }
+                K::SmallFireball | K::ShulkerBullet { .. } | K::WitherSkull { .. } => {
+                    (0.3125, 0.265_625)
+                }
+                K::WindCharge | K::BreezeWindCharge => (0.3125, 0.0),
+                K::LargeFireball { .. } => (1.0, 0.85),
+            };
+            g.hitbox(
+                at(p.previous, p.position),
+                (size, size),
+                eye,
+                false,
+                (p.pitch, p.yaw),
+            );
+        }
+        for t in &self.tridents {
+            g.hitbox(
+                at(t.previous, t.position),
+                (0.5, 0.5),
+                0.13,
+                false,
+                (t.pitch, t.yaw),
+            );
+        }
+        for r in &self.rockets {
+            // Projectile.updateRotation: the look follows the motion.
+            let v = r.velocity;
+            let yaw = v.x.atan2(v.z).to_degrees() as f32;
+            let pitch = v.y.atan2(v.x.hypot(v.z)).to_degrees() as f32;
+            g.hitbox(
+                at(r.previous, r.position),
+                (0.25, 0.25),
+                0.2125,
+                false,
+                (pitch, yaw),
+            );
+        }
+        for h in self
+            .hook
+            .iter()
+            .map(|h| (h.previous, h.position))
+            .chain(self.remote_hooks.iter().map(|h| (h.previous, h.position)))
+        {
+            g.hitbox(at(h.0, h.1), (0.25, 0.25), 0.2125, false, (0.0, 0.0));
+        }
+        for b in &self.bolts {
+            g.hitbox(b.at, (0.0, 0.0), 0.0, false, (0.0, 0.0));
+        }
+        // The dragon: 16 by 8, a living entity; its parts follow.
+        if let Some(d) = &self.dragon {
+            g.hitbox(
+                at(d.previous, d.position),
+                (16.0, 8.0),
+                6.8,
+                true,
+                (0.0, d.yaw),
+            );
+        }
         // The dragon's parts.
         for (id, b) in self.special_targets() {
             if (super::dragon::SPECIAL..super::dragon::SPECIAL + 8).contains(&id) {
@@ -828,3 +982,12 @@ impl Game<'_> {
         g
     }
 }
+
+/// The (x, y) rotations whose view vector is the step of a direction.
+fn step_view(step: [i32; 3]) -> (f32, f32) {
+    let [x, y, z] = step.map(f64::from);
+    (
+        (-y).asin().to_degrees() as f32,
+        (-x.atan2(z)).to_degrees() as f32,
+    )
+}
diff --git a/crates/horizon-client/src/game/fireworks.rs b/crates/horizon-client/src/game/fireworks.rs
index 38fd74ed8..5aa540fcd 100644
--- a/crates/horizon-client/src/game/fireworks.rs
+++ b/crates/horizon-client/src/game/fireworks.rs
@@ -23,7 +23,7 @@ pub(super) struct Rocket {
     /// The entity id a server tracks it by (0 until it is tracked).
     pub id: u32,
     pub(super) position: Vec3,
-    previous: Vec3,
+    pub(super) previous: Vec3,
     pub(super) velocity: Vec3,
     life: i32,
     lifetime: i32,
diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs
index 39f9e5ffe..b308b9f1d 100644
--- a/crates/horizon-client/src/game/fishing.rs
+++ b/crates/horizon-client/src/game/fishing.rs
@@ -30,8 +30,8 @@ enum State {
 pub(super) struct Hook {
     /// Its entity id, which a server's players track it under.
     id: u32,
-    position: Vec3,
-    previous: Vec3,
+    pub(super) position: Vec3,
+    pub(super) previous: Vec3,
     velocity: Vec3,
     state: State,
     life: i32,
@@ -770,8 +770,8 @@ impl Game<'_> {
 pub(super) struct RemoteHook {
     id: u32,
     owner: u32,
-    position: Vec3,
-    previous: Vec3,
+    pub(super) position: Vec3,
+    pub(super) previous: Vec3,
 }
 
 impl Hook {
diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs
index d934e85aa..af3dc418b 100644
--- a/crates/horizon-client/src/game/trident.rs
+++ b/crates/horizon-client/src/game/trident.rs
@@ -21,7 +21,7 @@ pub(super) struct ThrownTrident {
     pub id: u32,
     pub(super) stack: ItemStack,
     pub(super) position: Vec3,
-    previous: Vec3,
+    pub(super) previous: Vec3,
     pub(super) velocity: Vec3,
     pub(super) yaw: f32,
     pub(super) pitch: f32,
diff --git a/crates/horizon-client/src/gizmos.rs b/crates/horizon-client/src/gizmos.rs
index d4125710e..70e2b87f3 100644
--- a/crates/horizon-client/src/gizmos.rs
+++ b/crates/horizon-client/src/gizmos.rs
@@ -204,6 +204,19 @@ impl Gizmos {
             position[1] + f64::from(size.1),
             position[2] + half,
         ];
+        self.entity_box(min, max, position, eye_height, living, view);
+    }
+    /// The same for an entity whose box is not centred on its position
+    /// (a painting or an item frame): `min` and `max` are the box.
+    pub fn entity_box(
+        &mut self,
+        min: [f64; 3],
+        max: [f64; 3],
+        position: [f64; 3],
+        eye_height: f32,
+        living: bool,
+        view: (f32, f32),
+    ) {
         self.cuboid(min, max, WHITE, STROKE_WIDTH);
         if living {
             let eye = min[1] + f64::from(eye_height);

From 43e407562fdfe02f05986b7721b638a033ad092a Mon Sep 17 00:00:00 2001
From: masa-masa-0314 <348336850+masa-masa-0314@users.noreply.github.com>
Date: Tue, 27 Oct 2026 05:54:10 +0800
Subject: [PATCH 343/475] Items: animate the armour glint from
 enchanted_glint_armor

Enchanted worn armour lost its animation: mobs/render.rs gave every
armour vertex [0, 0] for glint_uv, while the entity shader samples the
glint at that coordinate for overlay 7, so the armour showed a single
texel instead of the scrolling pattern.

Armour layers now carry overlay 13 (ARMOR_GLINT) and the layer's model
UV. entity.wgsl applies ARMOR_ENTITY_GLINT_TEXTURING (scale 0.16) and
samples misc/enchanted_glint_armor through the same repeating, linear
GlintSampler as items, matching ARMOR_CUTOUT_NO_CULL_GLINT. The scroll
clock (millis * glintSpeed * 8 modulo the offsets' common period) rides
in globals.time.w, so armour and items move together.

Addresses the review comment on #2296.

Co-Authored-By: ZCode <agent@zcode.dev>
---
 crates/horizon-client/src/entity.wgsl       | 40 ++++++++++++++---
 crates/horizon-client/src/game.rs           |  8 ++++
 crates/horizon-client/src/game/item_draw.rs |  8 ++++
 crates/horizon-client/src/gfx.rs            | 48 ++++++++++++++++++++-
 crates/horizon-client/src/hud.rs            | 17 +++++---
 crates/horizon-client/src/item_render.rs    | 19 ++++++--
 crates/horizon-client/src/mobs/render.rs    | 19 ++++++--
 7 files changed, 139 insertions(+), 20 deletions(-)

diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl
index 993f86947..388d4358c 100644
--- a/crates/horizon-client/src/entity.wgsl
+++ b/crates/horizon-client/src/entity.wgsl
@@ -14,7 +14,8 @@ struct Globals {
     // Atlas rects (u0, v0, width, height) of end_sky.png and end_portal.png.
     end_portal_sprites: array<vec4<f32>, 2>,
     // x: vanilla's GameTime ((game time % 24000 + partial tick) / 24000)
-    // y: Nether cardinal lighting, z: how many dynamic_lights are set.
+    // y: Nether cardinal lighting, z: how many dynamic_lights are set,
+    // w: the glint scroll clock (`Glint::scroll_ticks`).
     time: vec4<f32>,
     crumbling_sprite: vec4<f32>,
     // Selection outline parameters (read by terrain.wgsl).
@@ -30,6 +31,9 @@ struct Globals {
 // enchanted_glint_item on its own repeating texture (vanilla's GlintSampler).
 @group(0) @binding(5) var glint_tex: texture_2d<f32>;
 @group(0) @binding(6) var glint_sampler: sampler;
+// The armour layers' GlintSampler: vanilla samples enchanted_glint_armor with
+// the same repeating, linearly filtered sampler as the item glint.
+@group(0) @binding(7) var glint_armor_tex: texture_2d<f32>;
 struct Out {
     @builtin(position) clip: vec4<f32>,
     @location(0) uv: vec2<f32>,
@@ -47,7 +51,8 @@ struct Out {
     // entity.vsh's lightMapColor, multiplied in after the overlay.
     @location(9) light_color: vec4<f32>,
     @location(10) @interpolate(flat) weather_rect: vec4<f32>,
-    // The `GLINT_TEXTURING` sample for overlay 7 (item foil).
+    // The `GLINT_TEXTURING` sample for overlay 7 (item foil), or the model UV
+    // `ARMOR_ENTITY_GLINT_TEXTURING` scrolls for overlay 13 (armour).
     @location(11) glint_uv: vec2<f32>,
 }
 // Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed.
@@ -176,6 +181,27 @@ fn linear_fog(d: f32, start: f32, end: f32) -> f32 {
     if d >= end { return 1.0; }
     return (d - start) / (end - start);
 }
+// TextureTransform.setupGlintTexturing(0.16), ARMOR_ENTITY_GLINT_TEXTURING.
+// globals.time.w is (Util.getMillis() * glintSpeed * 8) modulo 330000, the
+// common period of both offsets.
+fn armor_glint_uv(model: vec2<f32>) -> vec2<f32> {
+    let ticks = globals.time.w;
+    let offset0 = (ticks % 110000.0) / 110000.0;
+    let offset1 = (ticks % 30000.0) / 30000.0;
+    let angle = 0.17453292;
+    let c = cos(angle);
+    let s = sin(angle);
+    let scaled = model * 0.16;
+    return vec2(scaled.x * c - scaled.y * s - offset0,
+                scaled.x * s + scaled.y * c + offset1);
+}
+// RenderPipelines.GLINT: the source colour is scaled by itself, so `GlintAlpha`
+// is squared along with the sample.
+fn glint_over(color: vec4<f32>, glint: vec4<f32>) -> vec4<f32> {
+    let alpha = globals.fog_ends.w;
+    let g = alpha * glint;
+    return vec4(color.rgb + g.rgb * g.rgb, max(color.a, alpha));
+}
 // CRUMBLING_UV_BEGIN
 fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>, dimensions: vec2<u32>) -> vec2<f32> {
     let size = vec2<f32>(dimensions);
@@ -216,9 +242,13 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
     if in.overlay == 7u || in.overlay == 8u {
         // Enchantment glint: item.fsh's GLINT path, sampled from
         // enchanted_glint_item at the `GLINT_TEXTURING` UV.
-        let alpha = globals.fog_ends.w;
-        let glint = alpha * textureSample(glint_tex, glint_sampler, in.glint_uv);
-        color = vec4(color.rgb + glint.rgb * glint.rgb, max(color.a, alpha));
+        color = glint_over(color, textureSample(glint_tex, glint_sampler, in.glint_uv));
+    } else if in.overlay == 13u {
+        // Enchanted armour: enchanted_glint_armor at the scrolling model UV.
+        color = glint_over(
+            color,
+            textureSample(glint_armor_tex, glint_sampler, armor_glint_uv(in.glint_uv)),
+        );
     }
     let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
                 linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index f4663c844..d3531f87b 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -10806,6 +10806,7 @@ impl Game<'_> {
             debug_crosshair: &debug_crosshair,
             hud: &hud,
             glint_alpha: self.settings.file.double("glintStrength") as f32,
+            glint_ticks: self.glint_ticks(),
             clouds: (!title
                 && self.dim == Dim::Overworld
                 && horizon_client::clouds::visible(&self.settings.clouds, sky.cloud_color[3]))
@@ -13386,6 +13387,11 @@ fn build_renderer(
         &assets.animations,
         (&atlas.pixels, atlas.width, atlas.height),
         (&atlas.glint.0, atlas.glint.1, atlas.glint.2),
+        (
+            &atlas.glint_armor.0,
+            atlas.glint_armor.1,
+            atlas.glint_armor.2,
+        ),
         (&pack.forcefield.2, pack.forcefield.0),
         &gui.panorama,
         prepared,
@@ -13444,6 +13450,7 @@ fn loading_renderer(
         &[],
         (pixels, width, height),
         (glint_pixels, glint_width, glint_height),
+        (glint_pixels, glint_width, glint_height),
         (&FORCEFIELD[..], 1),
         panorama,
         None,
@@ -13491,6 +13498,7 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> {
         debug_crosshair: &[],
         hud,
         glint_alpha: 0.75,
+        glint_ticks: 0.0,
         nether_lighting: false,
         entities: &[],
         entity_spans: &[],
diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs
index 2dac91f77..a4bb41d01 100644
--- a/crates/horizon-client/src/game/item_draw.rs
+++ b/crates/horizon-client/src/game/item_draw.rs
@@ -314,6 +314,14 @@ impl Game<'_> {
                 scale: 0.5,
             })
     }
+    /// The glint scroll phase shared by world items and armour
+    /// (`item_render::Glint::scroll_ticks`).
+    pub(super) fn glint_ticks(&self) -> f32 {
+        item_render::Glint::scroll_ticks(
+            self.started.elapsed().as_secs_f32() * 1000.0,
+            self.settings.file.double("glintSpeed") as f32,
+        )
+    }
     /// Submit a resolved item under `pose` (camera-relative) at `light`
     /// (packed lightmap coordinates).
     pub(super) fn submit_item_world(
diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index 339f7e7c2..ecdf577c0 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -178,7 +178,7 @@ struct Globals {
     /// Atlas rects (u0, v0, width, height) of end_sky.png and end_portal.png.
     end_portal_sprites: [[f32; 4]; 2],
     /// x: vanilla's `GameTime` uniform; y: nether cardinal lighting; z: how many
-    /// `dynamic_lights` are set; w unused.
+    /// `dynamic_lights` are set; w: the glint scroll clock (`Glint::scroll_ticks`).
     time: [f32; 4],
     /// Atlas rect of a destroy stage (entity.wgsl takes only its size: every stage's is the same,
     /// and each crack carries its own stage's origin).
@@ -260,6 +260,9 @@ pub struct Frame<'a> {
     /// `GlintAlpha` (accessibility Glint Strength); the entity shader uses it
     /// for held/world items, independent of what the HUD batch last drew.
     pub glint_alpha: f32,
+    /// The glint scroll clock (`Glint::scroll_ticks`): entity.wgsl's
+    /// `ARMOR_ENTITY_GLINT_TEXTURING` phase.
+    pub glint_ticks: f32,
     /// CardinalLighting.Type.NETHER, otherwise DEFAULT.
     pub nether_lighting: bool,
     /// Camera-relative entity geometry textured from the shared atlas.
@@ -1024,6 +1027,7 @@ impl Renderer {
         animations: &[SpriteAnimation],
         hud_atlas: (&[u8], u32, u32),
         glint: (&[u8], u32, u32),
+        glint_armor: (&[u8], u32, u32),
         forcefield: (&[u8], u32),
         panorama_faces: &panorama::Faces,
         prepared: Option<PreparedTextures>,
@@ -1609,6 +1613,29 @@ impl Renderer {
             min_filter: wgpu::FilterMode::Linear,
             ..Default::default()
         });
+        // ARMOR_ENTITY_GLINT_TEXTURING's sampler is vanilla's GlintSampler: the
+        // same repeat and linear filtering as the item glint.
+        let (glint_armor_pixels, glint_armor_width, glint_armor_height) = glint_armor;
+        let glint_armor_texture = device.create_texture_with_data(
+            &queue,
+            &wgpu::TextureDescriptor {
+                label: Some("Enchanted armor glint"),
+                size: wgpu::Extent3d {
+                    width: glint_armor_width,
+                    height: glint_armor_height,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: wgpu::TextureFormat::Rgba8Unorm,
+                usage: wgpu::TextureUsages::TEXTURE_BINDING,
+                view_formats: &[],
+            },
+            wgpu::util::TextureDataOrder::LayerMajor,
+            glint_armor_pixels,
+        );
+        let glint_armor_view = glint_armor_texture.create_view(&Default::default());
         let mut hud = HudRenderer::new(
             &device,
             config.format.remove_srgb_suffix(),
@@ -1675,6 +1702,15 @@ impl Renderer {
                     vf,
                     wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                 ),
+                entry(
+                    7,
+                    vf,
+                    wgpu::BindingType::Texture {
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                ),
             ],
         });
         let weather = weather::Weather::new(
@@ -1719,6 +1755,10 @@ impl Renderer {
                     binding: 6,
                     resource: wgpu::BindingResource::Sampler(&glint_sampler),
                 },
+                wgpu::BindGroupEntry {
+                    binding: 7,
+                    resource: wgpu::BindingResource::TextureView(&glint_armor_view),
+                },
             ],
         });
         let hand_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
@@ -1753,6 +1793,10 @@ impl Renderer {
                     binding: 6,
                     resource: wgpu::BindingResource::Sampler(&glint_sampler),
                 },
+                wgpu::BindGroupEntry {
+                    binding: 7,
+                    resource: wgpu::BindingResource::TextureView(&glint_armor_view),
+                },
             ],
         });
         let entity_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
@@ -3557,7 +3601,7 @@ impl Renderer {
                 frame.shader_game_time,
                 f32::from(frame.nether_lighting),
                 frame.dynamic_lights.len().min(crate::dynamic_light::MAX) as f32,
-                0.0,
+                frame.glint_ticks,
             ],
             outline_params: outline_params(self.config.width, self.config.height),
             dynamic_lights: {
diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs
index 7f0d31ab0..86b2b9507 100644
--- a/crates/horizon-client/src/hud.rs
+++ b/crates/horizon-client/src/hud.rs
@@ -70,6 +70,8 @@ pub struct HudAtlas {
     /// `misc/enchanted_glint_item` as its own image: vanilla's `GlintSampler`
     /// repeats it per pixel, which one sprite inside this atlas cannot.
     pub glint: (Vec<u8>, u32, u32),
+    /// `misc/enchanted_glint_armor`, the armour layers' `GlintSampler`.
+    pub glint_armor: (Vec<u8>, u32, u32),
     white: Rect,
 }
 /// Atlas rows reserved for glyphs rasterized at run time.
@@ -529,7 +531,8 @@ impl HudAtlas {
             }
         }
         let white = sprites["horizon/white"];
-        let glint = Self::glint_texture(root, defaults);
+        let glint = Self::glint_texture(root, defaults, "enchanted_glint_item");
+        let glint_armor = Self::glint_texture(root, defaults, "enchanted_glint_armor");
         let font = crate::font::Font::load(
             root,
             &sprites,
@@ -547,16 +550,18 @@ impl HudAtlas {
             flags,
             fire_animations,
             glint,
+            glint_armor,
             font,
             white,
         })
     }
-    /// `misc/enchanted_glint_item.png` on its own, or a transparent texel if
-    /// the resource pack lacks it.
-    fn glint_texture(root: &Path, defaults: &Path) -> (Vec<u8>, u32, u32) {
-        let mut path = root.join("assets/minecraft/textures/misc/enchanted_glint_item.png");
+    /// `misc/<name>.png` on its own, or a transparent texel if the resource
+    /// pack lacks it.
+    fn glint_texture(root: &Path, defaults: &Path, name: &str) -> (Vec<u8>, u32, u32) {
+        let relative = format!("assets/minecraft/textures/misc/{name}.png");
+        let mut path = root.join(&relative);
         if !path.exists() && defaults != root {
-            path = defaults.join("assets/minecraft/textures/misc/enchanted_glint_item.png");
+            path = defaults.join(&relative);
         }
         decode(&path).map_or((vec![0; 4], 1, 1), |(w, h, pixels)| (pixels, w, h))
     }
diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs
index 76b13dbca..fe110d426 100644
--- a/crates/horizon-client/src/item_render.rs
+++ b/crates/horizon-client/src/item_render.rs
@@ -60,18 +60,29 @@ pub struct Glint {
     /// `Util.getMillis()`.
     pub millis: f32,
     /// The transform's scale: `GLINT_TEXTURING`'s 8.0 for GUI items,
-    /// `ENTITY_GLINT_TEXTURING`'s 0.5 for items in the world.
+    /// `ENTITY_GLINT_TEXTURING`'s 0.5 for items in the world and
+    /// `ARMOR_ENTITY_GLINT_TEXTURING`'s 0.16 for armour (entity.wgsl).
     pub scale: f32,
 }
 impl Glint {
+    /// `Util.getMillis() * glintSpeed * 8.0` as vanilla's long.
+    fn ticks(millis: f32, speed: f32) -> i64 {
+        (f64::from(millis) * f64::from(speed) * 8.0) as i64
+    }
+    /// The scroll clock modulo the common period of both offsets (110000 and
+    /// 30000 divide 330000), for `globals.time.w`: the entity shader derives
+    /// `ARMOR_ENTITY_GLINT_TEXTURING` from it.
+    pub fn scroll_ticks(millis: f32, speed: f32) -> f32 {
+        (Self::ticks(millis, speed) % 330_000) as f32
+    }
     /// `TextureTransform.setupGlintTexturing(scale)` applied to the model UV:
     /// translation(-o0, o1) * rotateZ(PI/18) * scale. The result repeats:
     /// the shader samples the dedicated glint texture with vanilla's
     /// repeating `GlintSampler`, so the UVs stay unwrapped.
     pub fn uv(&self, model: [f32; 2]) -> [f32; 2] {
-        let millis = (f64::from(self.millis) * f64::from(self.speed) * 8.0) as i64;
-        let offset0 = (millis % 110000) as f32 / 110000.0;
-        let offset1 = (millis % 30000) as f32 / 30000.0;
+        let ticks = Self::ticks(self.millis, self.speed);
+        let offset0 = (ticks % 110_000) as f32 / 110_000.0;
+        let offset1 = (ticks % 30_000) as f32 / 30_000.0;
         let angle = std::f32::consts::PI / 18.0;
         let (sin, cos) = angle.sin_cos();
         [
diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs
index 8620d88f5..d3fbac520 100644
--- a/crates/horizon-client/src/mobs/render.rs
+++ b/crates/horizon-client/src/mobs/render.rs
@@ -14,6 +14,12 @@ use std::f32::consts::PI;
 /// A texture lookup into the shared atlas (name without namespace -> uv rect).
 pub type Atlas<'a> = &'a dyn Fn(&str) -> Option<[f32; 4]>;
 
+/// The overlay code of an enchanted armour layer's glint. 7 and 8 are the
+/// item glint and 9 to 12 Horizon's End-portal and breaking overlays, so 13
+/// marks the `ARMOR_ENTITY_GLINT_TEXTURING` sample: entity.wgsl transforms
+/// the model UV and reads `enchanted_glint_armor`.
+pub const ARMOR_GLINT: u32 = 13;
+
 /// One draw of a model with a texture.
 pub struct Layer {
     pub model: String,
@@ -958,6 +964,13 @@ fn draw_normals(
             let normal = poly.vertex_normal(normals);
             for v in poly.vertices {
                 let pos = m.transform_point3(glam::Vec3::new(v[0], v[1], v[2]) / 16.0);
+                // The armour glint scrolls the layer's model UV in the shader;
+                // the item path already passed its transformed UV.
+                let glint_uv = if overlay == ARMOR_GLINT {
+                    [v[3], v[4]]
+                } else {
+                    [0.0, 0.0]
+                };
                 out.push(Vertex {
                     normal,
                     pos: pos.to_array(),
@@ -968,7 +981,7 @@ fn draw_normals(
                     layer: overlay,
                     color,
                     light,
-                    glint_uv: [0.0, 0.0],
+                    glint_uv,
                 });
             }
         }
@@ -1129,9 +1142,9 @@ fn render_visible(
             light
         };
         // EquipmentLayerRenderer draws armour with OverlayTexture.NO_OVERLAY: never
-        // the hurt tint, the glint (7) when enchanted.
+        // the hurt tint, the armour glint (13) when enchanted.
         let overlay = match armor_slot(&layer.model) {
-            Some(slot) if super::gear::enchanted(m, slot) => 7,
+            Some(slot) if super::gear::enchanted(m, slot) => ARMOR_GLINT,
             Some(_) => 0,
             None => overlay,
         };

From b0783dac38d9fa238ecd2a38aadc0049936506a2 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 22:54:33 +0100
Subject: [PATCH 344/475] launcher: Sculk's banner at the foot of the sidebar,
 seen without scrolling

On Home it sat under every row, so nobody saw it without scrolling. It now
sits small (228 px wide) above the Discord and Website links on every page
but Servers, which keeps the large one.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 launcher/src/main.rs    | 8 ++++++--
 launcher/src/partner.rs | 6 +++---
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 50e62756d..9438f1af0 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -1749,6 +1749,11 @@ impl Launcher {
             }
             _ => {}
         }
+        // Sculk's banner, small, above the links: seen without scrolling, on every page but Servers, which
+        // shows it large.
+        if self.page != Page::Servers {
+            foot = foot.child(partner::banner("partner-side", theme::SIDEBAR - 20., &t).mb(px(8.)));
+        }
         if !self.links.discord.is_empty() {
             foot = foot.child(link(
                 "discord",
@@ -2131,8 +2136,7 @@ impl Launcher {
         if let Some(crash) = self.crash.clone() {
             page = page.child(self.crash_notice(crash, cx));
         }
-        // Below everything the player needs to start, so it never moves Play.
-        page.child(partner::banner("partner-home", 560., &t))
+        page
     }
 
     /// "Horizon crashed": the report and the logs, and where to report it.
diff --git a/launcher/src/partner.rs b/launcher/src/partner.rs
index eea1a3524..5e1cdb695 100644
--- a/launcher/src/partner.rs
+++ b/launcher/src/partner.rs
@@ -1,5 +1,5 @@
-//! Sculk's banner: a server host that sponsors Horizon (Ludovic, 2026-10-26), on the Servers page
-//! and under Home's rows. The picture is in the binary, never fetched; a click opens Sculk's page in
+//! Sculk's banner: a server host that sponsors Horizon (Ludovic, 2026-10-26), large on the Servers page
+//! and small at the foot of the sidebar on the other pages, where it shows without scrolling. The picture is in the binary, never fetched; a click opens Sculk's page in
 //! the browser. A "Partner" label above it says it is an ad.
 use crate::theme::Theme;
 use gpui::{div, img, prelude::*, px, ClickEvent, Div, Image, ImageFormat, Stateful};
@@ -19,7 +19,7 @@ static BANNER: LazyLock<Arc<Image>> = LazyLock::new(|| {
 });
 
 /// The banner `width` logical pixels wide, under its label. Hovering lifts it a little and turns the
-/// label to ink. The narrowest window (960) leaves the page 648 pixels, so it always fits.
+/// label to ink. The narrowest window (960) leaves the page 648 pixels, so the Servers one always fits.
 pub fn banner(id: &'static str, width: f32, t: &Theme) -> Stateful<Div> {
     let t = *t;
     let el = div()

From 12bf15cfd7658e118b29a1f695f64554b140168f Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 22:58:09 +0100
Subject: [PATCH 345/475] launcher: the sidebar's partner banner can be hidden
 once it has been seen

A "Hide" shows beside its label after the banner has been on screen for
3 minutes, counted over every start (settings: partner_seen_secs, saved
each minute). Hiding it is kept (partner_hidden); the Servers page keeps
its own banner.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 launcher/src/backend.rs |  7 +++++
 launcher/src/main.rs    | 57 ++++++++++++++++++++++++++++++++++++++---
 launcher/src/partner.rs |  4 +++
 3 files changed, 65 insertions(+), 3 deletions(-)

diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs
index 85818a67c..55a78193a 100644
--- a/launcher/src/backend.rs
+++ b/launcher/src/backend.rs
@@ -2545,6 +2545,13 @@ pub struct Settings {
     /// first-run question, or on the Play page once if they answered that before it existed.
     #[serde(default)]
     pub ping_notice_seen: bool,
+    /// Seconds the sidebar's partner banner has been on screen, over every start, up to
+    /// `partner::SEEN_BEFORE_HIDE`: only then can the player hide it.
+    #[serde(default)]
+    pub partner_seen_secs: u64,
+    /// The player hid the sidebar's partner banner. The Servers page keeps its own.
+    #[serde(default)]
+    pub partner_hidden: bool,
 }
 
 impl Settings {
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 9438f1af0..7cc6d0ccd 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -248,6 +248,32 @@ impl Launcher {
             }
         })
         .detach();
+        // Counts the time the sidebar's partner banner is on screen, until it may be hidden.
+        cx.spawn(async move |this, cx| loop {
+            cx.background_executor()
+                .timer(Duration::from_secs(10))
+                .await;
+            let counting = this.update(cx, |this, cx| {
+                let s = &mut this.settings;
+                if s.partner_hidden || s.partner_seen_secs >= partner::SEEN_BEFORE_HIDE {
+                    return false;
+                }
+                if this.page != Page::Servers {
+                    s.partner_seen_secs += 10;
+                    if s.partner_seen_secs % 60 == 0
+                        || s.partner_seen_secs >= partner::SEEN_BEFORE_HIDE
+                    {
+                        s.save();
+                        cx.notify();
+                    }
+                }
+                true
+            });
+            if !matches!(counting, Ok(true)) {
+                break;
+            }
+        })
+        .detach();
         let mut settings = Settings::load();
         if settings.minecraft_dir.is_none() {
             settings.minecraft_dir = backend::default_minecraft_dir();
@@ -1750,9 +1776,34 @@ impl Launcher {
             _ => {}
         }
         // Sculk's banner, small, above the links: seen without scrolling, on every page but Servers, which
-        // shows it large.
-        if self.page != Page::Servers {
-            foot = foot.child(partner::banner("partner-side", theme::SIDEBAR - 20., &t).mb(px(8.)));
+        // shows it large. After a while on screen a "Hide" beside its label puts it away for good.
+        if self.page != Page::Servers && !self.settings.partner_hidden {
+            let mut side = div().relative().mb(px(8.)).child(partner::banner(
+                "partner-side",
+                theme::SIDEBAR - 20.,
+                &t,
+            ));
+            if self.settings.partner_seen_secs >= partner::SEEN_BEFORE_HIDE {
+                let hide = div()
+                    .id("partner-hide")
+                    .absolute()
+                    .top(px(0.))
+                    .right(px(0.))
+                    .cursor_pointer()
+                    .child(
+                        text(theme::MICRO)
+                            .text_color(t.muted)
+                            .hover(move |s| s.text_color(t.ink))
+                            .child("HIDE"),
+                    )
+                    .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                        this.settings.partner_hidden = true;
+                        this.settings.save();
+                        cx.notify();
+                    }));
+                side = side.child(keyboard(hide, &t));
+            }
+            foot = foot.child(side);
         }
         if !self.links.discord.is_empty() {
             foot = foot.child(link(
diff --git a/launcher/src/partner.rs b/launcher/src/partner.rs
index 5e1cdb695..c4feac7b8 100644
--- a/launcher/src/partner.rs
+++ b/launcher/src/partner.rs
@@ -7,6 +7,10 @@ use std::sync::{Arc, LazyLock};
 
 pub const URL: &str = "https://my.sculkhosting.com/ref/horizon";
 
+/// How long the sidebar's banner stays on screen, counted over every start, before a "Hide" shows
+/// beside its label: long enough to be seen, then the player may put it away for good.
+pub const SEEN_BEFORE_HIDE: u64 = 180;
+
 /// 1200×441: twice the widest it is shown at, for Retina screens. Its transparent edges let the
 /// characters stand out of the card.
 const WIDTH: f32 = 1200.;

From 26aef75d7cea8a22c846be52f6263b9cab6ccf5b Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 22:58:52 +0100
Subject: [PATCH 346/475] Shape and reorder right-to-left text before drawing
 it

---
 Cargo.lock                                    |   7 +
 crates/horizon-client/Cargo.toml              |   1 +
 crates/horizon-client/src/bidi.rs             | 306 ++++++++++++++++++
 .../horizon-client/src/block_entity_render.rs |   2 +
 crates/horizon-client/src/font.rs             |  11 +-
 crates/horizon-client/src/game/names.rs       |   4 +-
 crates/horizon-client/src/hud.rs              |   2 +
 crates/horizon-client/src/lang.rs             |  19 +-
 crates/horizon-client/src/lib.rs              |   1 +
 9 files changed, 348 insertions(+), 5 deletions(-)
 create mode 100644 crates/horizon-client/src/bidi.rs

diff --git a/Cargo.lock b/Cargo.lock
index bbbac4b2c..ecce142eb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1396,6 +1396,7 @@ dependencies = [
  "sha1",
  "sha2",
  "symphonia",
+ "unicode-bidi",
  "ureq",
  "wgpu",
  "winit",
@@ -3741,6 +3742,12 @@ version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
 
+[[package]]
+name = "unicode-bidi"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.26"
diff --git a/crates/horizon-client/Cargo.toml b/crates/horizon-client/Cargo.toml
index f1011c534..1613fd08c 100644
--- a/crates/horizon-client/Cargo.toml
+++ b/crates/horizon-client/Cargo.toml
@@ -60,6 +60,7 @@ gilrs = { version = "0.11", optional = true }
 horizon-dualsense = { path = "../horizon-dualsense", optional = true }
 # HTTPS to the Minecraft services (online-mode session join).
 ureq = { version = "2", default-features = false, features = ["tls"] }
+unicode-bidi = "0.3.18"
 
 [target.'cfg(unix)'.dependencies]
 # The server thread's CPU time per tick (`HORIZON_SPIKES`, spans.rs).
diff --git a/crates/horizon-client/src/bidi.rs b/crates/horizon-client/src/bidi.rs
new file mode 100644
index 000000000..c07b69c6d
--- /dev/null
+++ b/crates/horizon-client/src/bidi.rs
@@ -0,0 +1,306 @@
+//! Right-to-left text (`FormattedBidiReorder.reorder`, behind
+//! `Language.getVisualOrder`): the logical text a player types becomes the
+//! glyphs a font draws left to right. Arabic letters are shaped into their
+//! joined presentation forms (ICU's `ArabicShaping` with `LETTERS_SHAPE`), the
+//! text is reordered by the Unicode bidirectional algorithm, and characters in
+//! right-to-left runs are mirrored. Left-to-right text comes back unchanged.
+use crate::text::{Span, Text};
+use std::borrow::Cow;
+use unicode_bidi::{
+    BidiClass, Direction, Level, ParagraphBidiInfo, bidi_class, get_base_direction,
+};
+
+/// How a letter joins its neighbours, as ICU's shaper sees it: `Right` joins
+/// the letter before it only, `Dual` both neighbours, `Mark` is skipped over
+/// (diacritics) and `None` never joins.
+#[derive(Clone, Copy, PartialEq)]
+enum Join {
+    None,
+    Right,
+    Dual,
+    Mark,
+}
+use Join::{Dual, Mark, Right};
+
+/// ICU's joining table (`araLink`): code point ranges and their class, with the
+/// lam-alef ligatures at the end. Anything else is `Join::None`.
+const JOINS: &[(u32, u32, Join)] = &[
+    (0x0622, 0x0625, Right),
+    (0x0626, 0x0626, Dual),
+    (0x0627, 0x0627, Right),
+    (0x0628, 0x0628, Dual),
+    (0x0629, 0x0629, Right),
+    (0x062A, 0x062E, Dual),
+    (0x062F, 0x0632, Right),
+    (0x0633, 0x063A, Dual),
+    (0x0640, 0x0647, Dual),
+    (0x0648, 0x0649, Right),
+    (0x064A, 0x064A, Dual),
+    (0x064B, 0x0656, Mark),
+    (0x0670, 0x0670, Mark),
+    (0x0671, 0x0673, Right),
+    (0x0675, 0x0677, Right),
+    (0x0678, 0x0687, Dual),
+    (0x0688, 0x0699, Right),
+    (0x069A, 0x06B9, Dual),
+    (0x06BA, 0x06BA, Right),
+    (0x06BB, 0x06BF, Dual),
+    (0x06C0, 0x06C0, Right),
+    (0x06C1, 0x06C1, Dual),
+    (0x06C2, 0x06CB, Right),
+    (0x06CC, 0x06CC, Dual),
+    (0x06CD, 0x06CD, Right),
+    (0x06CE, 0x06D1, Dual),
+    (0x06D2, 0x06D3, Right),
+    (0x200D, 0x200D, Dual),
+    (0x206D, 0x206F, Mark),
+    (0xFEF5, 0xFEFC, Right),
+];
+
+/// Letters that have joined forms and the code point of the isolated one; the
+/// final, initial and medial forms follow it (a right-joining letter has the
+/// isolated and final only). The lam-alef ligatures are their own letters.
+#[rustfmt::skip]
+const FORMS: &[(u32, u32)] = &[
+    (0x0622, 0xFE81), (0x0623, 0xFE83), (0x0624, 0xFE85), (0x0625, 0xFE87), (0x0626, 0xFE89),
+    (0x0627, 0xFE8D), (0x0628, 0xFE8F), (0x0629, 0xFE93), (0x062A, 0xFE95), (0x062B, 0xFE99),
+    (0x062C, 0xFE9D), (0x062D, 0xFEA1), (0x062E, 0xFEA5), (0x062F, 0xFEA9), (0x0630, 0xFEAB),
+    (0x0631, 0xFEAD), (0x0632, 0xFEAF), (0x0633, 0xFEB1), (0x0634, 0xFEB5), (0x0635, 0xFEB9),
+    (0x0636, 0xFEBD), (0x0637, 0xFEC1), (0x0638, 0xFEC5), (0x0639, 0xFEC9), (0x063A, 0xFECD),
+    (0x0641, 0xFED1), (0x0642, 0xFED5), (0x0643, 0xFED9), (0x0644, 0xFEDD), (0x0645, 0xFEE1),
+    (0x0646, 0xFEE5), (0x0647, 0xFEE9), (0x0648, 0xFEED), (0x0649, 0xFEEF), (0x064A, 0xFEF1),
+    (0x0679, 0xFB66), (0x067A, 0xFB5E), (0x067B, 0xFB52), (0x067E, 0xFB56), (0x0686, 0xFB7A),
+    (0x0688, 0xFB88), (0x068C, 0xFB84), (0x068D, 0xFB82), (0x068E, 0xFB86), (0x0691, 0xFB8C),
+    (0x0698, 0xFB8A), (0x06A9, 0xFB8E), (0x06AF, 0xFB92), (0x06BA, 0xFB9E), (0x06BB, 0xFBA0),
+    (0x06BE, 0xFBAA), (0x06C0, 0xFBA4), (0x06C1, 0xFBA6), (0x06C5, 0xFBE0), (0x06C6, 0xFBD9),
+    (0x06C7, 0xFBD7), (0x06C8, 0xFBDB), (0x06C9, 0xFBE2), (0x06CB, 0xFBDE), (0x06CC, 0xFBFC),
+    (0x06D0, 0xFBE4), (0x06D2, 0xFBAE), (0x06D3, 0xFBB0), (0xFEF5, 0xFEF5), (0xFEF7, 0xFEF7),
+    (0xFEF9, 0xFEF9), (0xFEFB, 0xFEFB),
+];
+
+/// `Bidi_Mirroring_Glyph` (`UCharacter.getMirror`): each pair is two
+/// neighbouring characters that mirror each other.
+const MIRRORED: &str = "\
+        ()<>[]{}«»༺༻༼༽᚛᚜‹›⁅⁆⁽⁾₍₎∈∋∉∌∊∍∕⧵∟⯾∠⦣∡⦛∢⦠∤⫮∼∽≃⋍≅≌≒≓\
+        ≔≕≤≥≦≧≨≩≪≫≮≯≰≱≲≳≴≵≶≷≸≹≺≻≼≽≾≿⊀⊁⊂⊃⊄⊅⊆⊇⊈⊉⊊⊋⊏⊐⊑⊒⊘⦸⊢⊣⊦⫞\
+        ⊨⫤⊩⫣⊫⫥⊰⊱⊲⊳⊴⊵⊶⊷⊸⟜⋉⋊⋋⋌⋐⋑⋖⋗⋘⋙⋚⋛⋜⋝⋞⋟⋠⋡⋢⋣⋤⋥⋦⋧⋨⋩⋪⋫⋬⋭⋰⋱⋲⋺\
+        ⋳⋻⋴⋼⋶⋽⋷⋾⌈⌉⌊⌋〈〉❨❩❪❫❬❭❮❯❰❱❲❳❴❵⟃⟄⟅⟆⟈⟉⟋⟍⟕⟖⟝⟞⟢⟣⟤⟥⟦⟧⟨⟩⟪⟫\
+        ⟬⟭⟮⟯⦃⦄⦅⦆⦇⦈⦉⦊⦋⦌⦍⦐⦎⦏⦑⦒⦓⦔⦕⦖⦗⦘⦤⦥⦨⦩⦪⦫⦬⦭⦮⦯⧀⧁⧄⧅⧏⧐⧑⧒⧔⧕⧘⧙⧚⧛\
+        ⧨⧩⧸⧹⧼⧽⨫⨬⨭⨮⨴⨵⨼⨽⩤⩥⩹⩺⩻⩼⩽⩾⩿⪀⪁⪂⪃⪄⪅⪆⪇⪈⪉⪊⪋⪌⪍⪎⪏⪐⪑⪒⪓⪔⪕⪖⪗⪘⪙⪚\
+        ⪛⪜⪝⪞⪟⪠⪡⪢⪦⪧⪨⪩⪪⪫⪬⪭⪯⪰⪱⪲⪳⪴⪵⪶⪷⪸⪹⪺⪻⪼⪽⪾⪿⫀⫁⫂⫃⫄⫅⫆⫇⫈⫉⫊⫋⫌⫍⫎⫏⫐\
+        ⫑⫒⫓⫔⫕⫖⫬⫭⫷⫸⫹⫺⸂⸃⸄⸅⸉⸊⸌⸍⸜⸝⸠⸡⸢⸣⸤⸥⸦⸧⸨⸩⹕⹖⹗⹘⹙⹚⹛⹜〈〉《》「」『』【】\
+        〔〕〖〗〘〙〚〛﹙﹚﹛﹜﹝﹞﹤﹥（）＜＞［］｛｝｟｠｢｣";
+
+fn join(c: char) -> Join {
+    let c = c as u32;
+    JOINS
+        .iter()
+        .find(|&&(from, to, _)| (from..=to).contains(&c))
+        .map_or(Join::None, |&(_, _, join)| join)
+}
+
+/// The letter whose joined form `c` is (ICU shapes the forms again), or `c`.
+fn letter_of(c: char) -> char {
+    let c32 = c as u32;
+    if !matches!(c32, 0xFB50..=0xFDFF | 0xFE70..=0xFEFC) {
+        return c;
+    }
+    if (0xFE70..0xFE80).contains(&c32) {
+        // The diacritics' forms pair up from fathatan on.
+        return char::from_u32(0x064B + (c32 - 0xFE70) / 2).unwrap_or(c);
+    }
+    FORMS
+        .iter()
+        .find(|&&(letter, iso)| {
+            let forms = if join(char::from_u32(letter).unwrap_or(c)) == Dual {
+                4
+            } else {
+                2
+            };
+            (iso..iso + forms).contains(&c32)
+        })
+        .and_then(|&(letter, _)| char::from_u32(letter))
+        .unwrap_or(c)
+}
+
+/// `ArabicShaping(LETTERS_SHAPE).shape`: lam followed by an alef (diacritics
+/// may sit between) becomes one ligature, then every letter takes the isolated,
+/// final, initial or medial form its neighbours call for. Diacritics take the
+/// tatweel form between two joined letters. The text can only get shorter.
+fn shape(text: &[char]) -> Vec<char> {
+    let letters: Vec<char> = text.iter().map(|&c| letter_of(c)).collect();
+    let mut chars = Vec::with_capacity(letters.len());
+    let mut i = 0;
+    while i < letters.len() {
+        if letters[i] == '\u{644}' {
+            let mut at = i + 1;
+            while letters.get(at).is_some_and(|&c| join(c) == Mark) {
+                at += 1;
+            }
+            let alef = letters.get(at).and_then(|&c| {
+                ['\u{622}', '\u{623}', '\u{625}', '\u{627}']
+                    .iter()
+                    .position(|&a| a == c)
+            });
+            if let Some(alef) = alef {
+                chars.push(char::from_u32(0xFEF5 + 2 * alef as u32).unwrap_or('\u{644}'));
+                chars.extend_from_slice(&letters[i + 1..at]);
+                i = at + 1;
+                continue;
+            }
+        }
+        chars.push(letters[i]);
+        i += 1;
+    }
+    // Whether the nearest letter before joins the next one, and the joins of
+    // the nearest letter after.
+    let mut joins_next = false;
+    let mut out = Vec::with_capacity(chars.len());
+    for (i, &c) in chars.iter().enumerate() {
+        let next_joins = chars[i + 1..]
+            .iter()
+            .map(|&n| join(n))
+            .find(|&j| j != Mark)
+            .is_some_and(|j| j != Join::None);
+        let kind = join(c);
+        let shaped = match kind {
+            Join::None => {
+                joins_next = false;
+                c
+            }
+            Mark => match c as u32 {
+                m @ 0x064B..=0x0652 => {
+                    let iso = 0xFE70 + 2 * (m - 0x064B);
+                    let tatweel = joins_next && next_joins && !matches!(m, 0x064C | 0x064D);
+                    char::from_u32(iso + u32::from(tatweel)).unwrap_or(c)
+                }
+                _ => c,
+            },
+            Right | Dual => {
+                let to_next = kind == Dual && next_joins;
+                let form = match (joins_next, to_next) {
+                    (false, false) => 0,
+                    (true, false) => 1,
+                    (false, true) => 2,
+                    (true, true) => 3,
+                };
+                joins_next = kind == Dual;
+                FORMS
+                    .binary_search_by_key(&(c as u32), |&(letter, _)| letter)
+                    .ok()
+                    .and_then(|at| char::from_u32(FORMS[at].1 + form))
+                    .unwrap_or(c)
+            }
+        };
+        out.push(shaped);
+    }
+    out
+}
+
+/// `UCharacter.getMirror`.
+fn mirror(c: char) -> char {
+    if bidi_class(c) != BidiClass::ON {
+        return c;
+    }
+    let mut pairs = MIRRORED.chars();
+    while let (Some(a), Some(b)) = (pairs.next(), pairs.next()) {
+        if c == a {
+            return b;
+        }
+        if c == b {
+            return a;
+        }
+    }
+    c
+}
+
+/// Whether a character can change anything: right-to-left letters and numbers,
+/// the explicit direction controls and the diacritics that shaping turns into
+/// letters. Without any, left-to-right text keeps its order.
+fn directional(c: char) -> bool {
+    c as u32 >= 0x0590
+        && (matches!(c as u32, 0x064B..=0x0652)
+            || matches!(
+                bidi_class(c),
+                BidiClass::R
+                    | BidiClass::AL
+                    | BidiClass::AN
+                    | BidiClass::LRE
+                    | BidiClass::RLE
+                    | BidiClass::LRO
+                    | BidiClass::RLO
+                    | BidiClass::PDF
+                    | BidiClass::LRI
+                    | BidiClass::RLI
+                    | BidiClass::FSI
+                    | BidiClass::PDI
+            ))
+}
+
+/// Whether `chars` keep their order and shapes: left-to-right text without
+/// anything directional, in a language that reads left to right by default.
+fn unchanged(mut chars: impl Iterator<Item = char>, default_rtl: bool) -> bool {
+    !default_rtl && !chars.any(directional)
+}
+
+/// `FormattedBidiReorder.reorder`: `chars` shaped, in visual order, with each
+/// character's position in the shaped text. A character's style is the one at
+/// its position in the shaped text, as `SubStringSource` takes it (the text
+/// shrinks at a lam-alef ligature).
+fn reorder(chars: &[char], default_rtl: bool) -> Vec<(char, usize)> {
+    let shaped = shape(chars);
+    let plain: String = shaped.iter().collect();
+    // DEFAULT_RTL only changes text without a strong character.
+    let level =
+        (default_rtl && get_base_direction(plain.as_str()) == Direction::Mixed).then(Level::rtl);
+    let info = ParagraphBidiInfo::new(&plain, level);
+    let levels = info.reordered_levels_per_char(0..plain.len());
+    ParagraphBidiInfo::reorder_visual(&levels)
+        .into_iter()
+        .map(|i| {
+            let c = if levels[i].is_rtl() {
+                mirror(shaped[i])
+            } else {
+                shaped[i]
+            };
+            (c, i)
+        })
+        .collect()
+}
+
+/// `Language.getVisualOrder` of a text (its `§` codes already resolved), for
+/// the current language's direction.
+pub fn visual(text: &Text) -> Cow<'_, Text> {
+    let default_rtl = crate::lang::bidirectional();
+    if unchanged(text.chars().map(|(c, _)| c), default_rtl) {
+        return Cow::Borrowed(text);
+    }
+    let chars: Vec<char> = text.chars().map(|(c, _)| c).collect();
+    let styles: Vec<_> = text.chars().map(|(_, style)| style).collect();
+    let mut out = Text::default();
+    for (c, at) in reorder(&chars, default_rtl) {
+        match out.spans.last_mut() {
+            Some(span) if span.style == *styles[at] => span.text.push(c),
+            _ => out.spans.push(Span {
+                text: c.to_string(),
+                style: styles[at].clone(),
+            }),
+        }
+    }
+    Cow::Owned(out)
+}
+
+/// The same for a plain string.
+pub fn visual_str(s: &str) -> Cow<'_, str> {
+    let default_rtl = crate::lang::bidirectional();
+    if unchanged(s.chars(), default_rtl) {
+        return Cow::Borrowed(s);
+    }
+    let chars: Vec<char> = s.chars().collect();
+    Cow::Owned(
+        reorder(&chars, default_rtl)
+            .into_iter()
+            .map(|(c, _)| c)
+            .collect(),
+    )
+}
diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs
index 28a876d80..a312fe9f7 100644
--- a/crates/horizon-client/src/block_entity_render.rs
+++ b/crates/horizon-client/src/block_entity_render.rs
@@ -610,7 +610,9 @@ fn sign_text_calls(
         .iter()
         .enumerate()
         .map(|(i, line)| {
+            // The line that fits, in the order it is drawn (getVisualOrder).
             let shown = first_line(line, data.max_line_width(), &advance);
+            let shown = crate::bidi::visual_str(&shown).into_owned();
             TextCall {
                 matrix: m,
                 x: -((width(&shown) as i32) / 2) as f32,
diff --git a/crates/horizon-client/src/font.rs b/crates/horizon-client/src/font.rs
index d0e8c8499..2bb712612 100644
--- a/crates/horizon-client/src/font.rs
+++ b/crates/horizon-client/src/font.rs
@@ -889,12 +889,17 @@ impl Font {
         if s.contains('§') {
             return self.width_text(&Text::legacy(s));
         }
-        s.chars().map(|c| self.glyph(c).advance).sum::<f32>().ceil()
+        crate::bidi::visual_str(s)
+            .chars()
+            .map(|c| self.glyph(c).advance)
+            .sum::<f32>()
+            .ceil()
     }
     /// Font.width of a component: `§` codes in the spans are formatting,
-    /// not glyphs.
+    /// not glyphs. Right-to-left text is measured as it is drawn, shaped.
     pub fn width_text(&self, t: &Text) -> f32 {
-        t.resolved()
+        let t = t.resolved();
+        crate::bidi::visual(&t)
             .chars()
             .map(|(c, s)| self.advance(c, s))
             .sum::<f32>()
diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs
index 9f7561e53..6b5324e3a 100644
--- a/crates/horizon-client/src/game/names.rs
+++ b/crates/horizon-client/src/game/names.rs
@@ -338,7 +338,9 @@ impl Game<'_> {
             let (r, u) = (right.as_vec3() * 0.025, up.as_vec3() * 0.025);
             // Text space: x right, y down (scale 0.025, -0.025).
             let at = |x: f32, y: f32| o + r * x - u * y;
-            let chars: Vec<(char, u32)> = text
+            // Component.getVisualOrderText.
+            let shown = horizon_client::bidi::visual(text);
+            let chars: Vec<(char, u32)> = shown
                 .spans
                 .iter()
                 .flat_map(|s| {
diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs
index 2b6acda41..850093780 100644
--- a/crates/horizon-client/src/hud.rs
+++ b/crates/horizon-client/src/hud.rs
@@ -912,6 +912,8 @@ impl HudBatch {
         // StringDecomposer.iterateFormatted inside Font.drawInternal:
         // `§` codes inside a span restyle what follows and are not drawn.
         let text = text.resolved();
+        // Language.getVisualOrder: shaped and reordered for right-to-left text.
+        let text = crate::bidi::visual(&text);
         let font = &atlas.font;
         let alpha = (color >> 24) as u8;
         let mut glyphs = Vec::new();
diff --git a/crates/horizon-client/src/lang.rs b/crates/horizon-client/src/lang.rs
index cb96cc373..093a87929 100644
--- a/crates/horizon-client/src/lang.rs
+++ b/crates/horizon-client/src/lang.rs
@@ -4,7 +4,10 @@
 //! language used by every screen.
 use std::{
     collections::{BTreeMap, HashMap},
-    sync::{Arc, RwLock},
+    sync::{
+        Arc, RwLock,
+        atomic::{AtomicBool, Ordering},
+    },
 };
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -23,11 +26,16 @@ impl LanguageInfo {
 #[derive(Default)]
 pub struct Language {
     pub code: String,
+    /// `LanguageInfo.bidirectional`: text without a strong character reads
+    /// right to left (`ClientLanguage.defaultRightToLeft`).
+    bidirectional: bool,
     map: HashMap<String, String>,
 }
 pub const DEFAULT: &str = "en_us";
 
 static CURRENT: RwLock<Option<Arc<Language>>> = RwLock::new(None);
+/// The current language's `bidirectional`, read for every drawn string.
+static BIDIRECTIONAL: AtomicBool = AtomicBool::new(false);
 
 /// A source of resource files: the prepared root plus packs, highest priority last.
 pub trait ResourceSource {
@@ -130,8 +138,12 @@ impl Language {
         {
             apply_deprecated(&mut map, &bytes);
         }
+        let bidirectional = available(sources)
+            .iter()
+            .any(|info| info.code == code && info.bidirectional);
         Self {
             code: code.to_owned(),
+            bidirectional,
             map,
         }
     }
@@ -193,11 +205,16 @@ pub fn available(sources: &[&dyn ResourceSource]) -> Vec<LanguageInfo> {
 }
 
 pub fn set(language: Language) {
+    BIDIRECTIONAL.store(language.bidirectional, Ordering::Relaxed);
     *CURRENT.write().unwrap_or_else(|e| e.into_inner()) = Some(Arc::new(language));
 }
 pub fn current() -> Option<Arc<Language>> {
     CURRENT.read().unwrap_or_else(|e| e.into_inner()).clone()
 }
+/// `ClientLanguage.defaultRightToLeft` of the current language.
+pub fn bidirectional() -> bool {
+    BIDIRECTIONAL.load(Ordering::Relaxed)
+}
 pub fn code() -> String {
     current().map_or_else(|| DEFAULT.to_owned(), |l| l.code.clone())
 }
diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs
index ebfbdea58..2adc13cd6 100644
--- a/crates/horizon-client/src/lib.rs
+++ b/crates/horizon-client/src/lib.rs
@@ -15,6 +15,7 @@ pub mod auto_jump;
 pub mod banner;
 pub mod beehive;
 pub mod benchmark;
+pub mod bidi;
 pub mod biome;
 pub mod block_entities;
 pub mod block_entity_anim;

From faeff96cf939e46bfb587ab41ec95ee988240919 Mon Sep 17 00:00:00 2001
From: Murillo Deolino <88172584+Murilinho145SG@users.noreply.github.com>
Date: Mon, 26 Oct 2026 18:59:32 -0300
Subject: [PATCH 347/475] Add Wayland launcher window controls

Co-Authored-By: Codex <noreply@openai.com>
---
 launcher/src/main.rs     |  15 ++-
 launcher/src/titlebar.rs | 236 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 240 insertions(+), 11 deletions(-)

diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 50e62756d..75cf1ddfe 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -1369,9 +1369,9 @@ fn megabytes(bytes: u64) -> String {
 // ----- Pages -------------------------------------------------------------------------------------
 
 impl Launcher {
-    /// The top bar: the mark and the name over the sidebar (in the title bar on Windows), the
-    /// pages with their icons, then the account playing and the Settings button.
-    fn topbar(&mut self, cx: &mut Context<Self>) -> Div {
+    /// The top bar: the mark and name over the sidebar (in the title bar on Windows and Linux
+    /// client-side decorations), the pages with their icons, then the account and Settings.
+    fn topbar(&mut self, window: &Window, cx: &mut Context<Self>) -> Div {
         let t = self.theme;
         let mut nav = div().flex().flex_none().h_full().gap(px(2.));
         for (page, label, icon) in Page::ALL {
@@ -1508,8 +1508,8 @@ impl Launcher {
             .bg(t.side)
             .border_b_2()
             .border_color(t.outline)
-            // Where the title bar is drawn here (Windows), it carries the mark and the name.
-            .when(!titlebar::DRAWN, |bar| {
+            // Custom title bars carry the mark and name above the sidebar.
+            .when(!titlebar::draws_brand(window), |bar| {
                 bar.child(
                     div()
                         .flex()
@@ -3445,7 +3445,7 @@ impl Render for Launcher {
             window.focus(&self.root_focus);
         }
         let stone = self.art.stone(t.page_rgb, t.dark, window.scale_factor());
-        let topbar = self.topbar(cx);
+        let topbar = self.topbar(window, cx);
         let sidebar = self.sidebar(cx);
         let mut root = div()
             .id("root")
@@ -3586,6 +3586,7 @@ impl Render for Launcher {
             .bg(t.side)
             .children(titlebar::render(&t, window))
             .child(root.flex_1().min_h_0())
+            .children(titlebar::resize_handles(window))
     }
 }
 
@@ -3715,6 +3716,8 @@ fn main() {
                     window_bounds: Some(WindowBounds::Windowed(bounds)),
                     window_min_size: Some(size(px(960.), px(600.))),
                     titlebar: Some(titlebar::options()),
+                    #[cfg(target_os = "linux")]
+                    window_decorations: Some(gpui::WindowDecorations::Client),
                     app_id: Some("horizon-launcher".into()),
                     ..Default::default()
                 },
diff --git a/launcher/src/titlebar.rs b/launcher/src/titlebar.rs
index a023f7d7d..dbf0f966e 100644
--- a/launcher/src/titlebar.rs
+++ b/launcher/src/titlebar.rs
@@ -1,12 +1,25 @@
-//! Custom Windows chrome. Other platforms keep their native window decorations; on macOS,
-//! `apply_appearance` repaints that chrome (the title bar) to match the chosen look.
+//! Window chrome: Windows and Linux client-side decorations are custom drawn; macOS and Linux
+//! server-side decorations use the platform's native chrome.
 use crate::theme::Theme;
 use gpui::{Div, TitlebarOptions, Window};
 use horizon_launcher::backend::Appearance;
 
-/// Whether the launcher draws its own title bar (`render`) rather than the system.
+/// Whether Windows uses a transparent native title bar for the launcher's custom chrome.
 pub const DRAWN: bool = cfg!(target_os = "windows");
 
+pub fn draws_brand(window: &Window) -> bool {
+    #[cfg(target_os = "linux")]
+    return matches!(
+        window.window_decorations(),
+        gpui::Decorations::Client { .. }
+    );
+    #[cfg(not(target_os = "linux"))]
+    {
+        let _ = window;
+        DRAWN
+    }
+}
+
 pub fn options() -> TitlebarOptions {
     TitlebarOptions {
         title: Some("Horizon".into()),
@@ -15,15 +28,228 @@ pub fn options() -> TitlebarOptions {
     }
 }
 
-#[cfg(not(target_os = "windows"))]
+#[cfg(all(not(target_os = "windows"), not(target_os = "linux")))]
 pub fn render(_theme: &Theme, _window: &Window) -> Option<Div> {
     None
 }
 
+/// Draw the launcher's Linux title bar when the platform uses client-side decorations.
+#[cfg(target_os = "linux")]
+pub fn render(theme: &Theme, window: &Window) -> Option<Div> {
+    use crate::{blocks, mark};
+    use gpui::{div, prelude::*, px, Decorations, FontWeight, MouseButton};
+
+    if matches!(window.window_decorations(), Decorations::Server) {
+        return None;
+    }
+
+    let controls = window.window_controls();
+    let drag = div()
+        .id("window-drag")
+        .flex()
+        .flex_1()
+        .h_full()
+        .items_center()
+        .gap(px(8.))
+        .px(px(12.))
+        .on_mouse_down(MouseButton::Left, |_, window, _| window.start_window_move())
+        .child(mark(16., theme))
+        .child(blocks::pixel(13., FontWeight::MEDIUM).child("Horizon"));
+
+    let mut bar = div()
+        .flex()
+        .flex_none()
+        .items_center()
+        .h(px(32.))
+        .bg(theme.side)
+        .text_color(theme.muted)
+        .border_b_1()
+        .border_color(theme.outline)
+        .child(drag);
+
+    if controls.minimize {
+        let color = theme.ink_soft;
+        let hover = theme.raised;
+        bar = bar.child(
+            div()
+                .id("window-minimize")
+                .flex()
+                .flex_none()
+                .items_center()
+                .justify_center()
+                .w(px(46.))
+                .h_full()
+                .cursor_pointer()
+                .hover(move |style| style.bg(hover))
+                .child(div().w(px(10.)).h(px(1.)).bg(color))
+                .on_click(|_, window, _| window.minimize_window()),
+        );
+    }
+
+    if controls.maximize {
+        let color = theme.ink_soft;
+        let hover = theme.raised;
+        let maximized = window.is_maximized();
+        let square = || {
+            div()
+                .absolute()
+                .size(px(10.))
+                .border_1()
+                .border_color(color)
+        };
+        let icon = div().relative().size(px(14.));
+        let icon = if maximized {
+            icon.child(
+                div()
+                    .absolute()
+                    .left(px(4.))
+                    .top_0()
+                    .size(px(10.))
+                    .border_t_1()
+                    .border_r_1()
+                    .border_color(color),
+            )
+            .child(square().left(px(1.)).top(px(3.)))
+        } else {
+            icon.child(square().left(px(2.)).top(px(2.)))
+        };
+        bar = bar.child(
+            div()
+                .id("window-maximize")
+                .flex()
+                .flex_none()
+                .items_center()
+                .justify_center()
+                .w(px(46.))
+                .h_full()
+                .cursor_pointer()
+                .hover(move |style| style.bg(hover))
+                .child(icon)
+                .on_click(|_, window, _| window.zoom_window()),
+        );
+    }
+
+    let close_hover = theme.page;
+    let close_bg = theme.danger;
+    Some(
+        bar.child(
+            div()
+                .id("window-close")
+                .group("linux-window-close")
+                .flex()
+                .flex_none()
+                .items_center()
+                .justify_center()
+                .w(px(46.))
+                .h_full()
+                .cursor_pointer()
+                .hover(move |style| style.bg(close_bg).text_color(close_hover))
+                .child(
+                    blocks::icon("close", 14., theme.ink_soft)
+                        .group_hover("linux-window-close", move |style| {
+                            style.text_color(close_hover)
+                        }),
+                )
+                .on_click(|_, window, _| window.remove_window()),
+        ),
+    )
+}
+
+#[cfg(target_os = "linux")]
+pub fn resize_handles(window: &Window) -> Option<Div> {
+    use gpui::{div, prelude::*, px, CursorStyle, Decorations, MouseButton, ResizeEdge};
+
+    if matches!(window.window_decorations(), Decorations::Server) || window.is_maximized() {
+        return None;
+    }
+
+    let handle = |id, edge, cursor| {
+        div()
+            .id(id)
+            .absolute()
+            .cursor(cursor)
+            .on_mouse_down(MouseButton::Left, move |_, window, _| {
+                window.start_window_resize(edge)
+            })
+    };
+
+    Some(
+        div()
+            .absolute()
+            .size_full()
+            .child(
+                handle("resize-left", ResizeEdge::Left, CursorStyle::ResizeLeft)
+                    .left_0()
+                    .top(px(8.))
+                    .bottom(px(8.))
+                    .w(px(5.)),
+            )
+            .child(
+                handle("resize-right", ResizeEdge::Right, CursorStyle::ResizeRight)
+                    .right_0()
+                    .top(px(8.))
+                    .bottom(px(8.))
+                    .w(px(5.)),
+            )
+            .child(
+                handle("resize-bottom", ResizeEdge::Bottom, CursorStyle::ResizeDown)
+                    .bottom_0()
+                    .left(px(8.))
+                    .right(px(8.))
+                    .h(px(5.)),
+            )
+            .child(
+                handle(
+                    "resize-top-left",
+                    ResizeEdge::TopLeft,
+                    CursorStyle::ResizeUpLeftDownRight,
+                )
+                .left_0()
+                .top_0()
+                .size(px(8.)),
+            )
+            .child(
+                handle(
+                    "resize-top-right",
+                    ResizeEdge::TopRight,
+                    CursorStyle::ResizeUpRightDownLeft,
+                )
+                .right_0()
+                .top_0()
+                .size(px(8.)),
+            )
+            .child(
+                handle(
+                    "resize-bottom-left",
+                    ResizeEdge::BottomLeft,
+                    CursorStyle::ResizeUpRightDownLeft,
+                )
+                .left_0()
+                .bottom_0()
+                .size(px(8.)),
+            )
+            .child(
+                handle(
+                    "resize-bottom-right",
+                    ResizeEdge::BottomRight,
+                    CursorStyle::ResizeUpLeftDownRight,
+                )
+                .right_0()
+                .bottom_0()
+                .size(px(8.)),
+            ),
+    )
+}
+
+#[cfg(not(target_os = "linux"))]
+pub fn resize_handles(_: &Window) -> Option<Div> {
+    None
+}
+
 /// macOS keeps the window's appearance on the system setting, so a launcher set to Dark still
 /// draws a light title bar on a light desktop. Pin the NSWindow's appearance to the choice
 /// instead (`theme::pinned_dark`: `System` clears the pin, handing the chrome back to the
-/// system). Elsewhere the chrome is ours (Windows) or the system's (Linux).
+/// system). Windows uses custom chrome; Linux draws it only when the compositor requests it.
 #[cfg(target_os = "macos")]
 pub fn apply_appearance(window: &Window, choice: Appearance) {
     use objc2_app_kit::{

From e544924504808587d7a3375186dc05c7e9458879 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 23:03:39 +0100
Subject: [PATCH 348/475] Draw entity outlines for the Glowing effect

Glowing entities are drawn as team-coloured silhouettes into an outline
target with no depth test, then vanilla's entity_outline chain (sobel,
box blur across and up) is blended over the frame after the hand.
Mobs, players, item entities and projectiles get outlines. The server
sends shared flag 6 for mobs and items, and the remote client reads it.
---
 crates/horizon-client/src/entity.wgsl         |   7 +
 crates/horizon-client/src/game.rs             |   9 +
 crates/horizon-client/src/game/creatures.rs   |  28 +-
 crates/horizon-client/src/game/glowing.rs     |  53 +++
 crates/horizon-client/src/game/item_draw.rs   |   7 +-
 crates/horizon-client/src/game/lan.rs         |  18 +-
 crates/horizon-client/src/game/perspective.rs |  10 +
 crates/horizon-client/src/game/remote.rs      |  30 +-
 crates/horizon-client/src/gfx.rs              |  29 +-
 .../horizon-client/src/gfx/entity_outline.rs  | 311 ++++++++++++++++++
 .../src/gfx/entity_outline.wgsl               |  60 ++++
 crates/horizon-client/src/mobs.rs             |   5 +
 12 files changed, 558 insertions(+), 9 deletions(-)
 create mode 100644 crates/horizon-client/src/game/glowing.rs
 create mode 100644 crates/horizon-client/src/gfx/entity_outline.rs
 create mode 100644 crates/horizon-client/src/gfx/entity_outline.wgsl

diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl
index 79e11719f..fd8966de2 100644
--- a/crates/horizon-client/src/entity.wgsl
+++ b/crates/horizon-client/src/entity.wgsl
@@ -219,6 +219,13 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
     return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
 }
 
+// rendertype_outline.fsh: the vertex colour (the team colour; outline vertices carry no
+// normal, so no cardinal light) wherever the texture is not fully clear.
+@fragment fn fs_outline(in: Out) -> @location(0) vec4<f32> {
+    if textureSample(atlas, atlas_sampler, in.uv).a == 0.0 { discard; }
+    return vec4(in.color.rgb, 1.0);
+}
+
 @fragment fn fs_celestial(in: Out) -> @location(0) vec4<f32> {
     let color = textureSample(atlas, atlas_sampler, in.uv) * in.color * in.light_color;
     return color;
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index f9edd98bb..c40e04090 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -65,6 +65,7 @@ mod game_mode;
 mod game_rules_screen;
 mod gamemode_switcher;
 mod ghasts;
+mod glowing;
 mod golems;
 mod growth;
 mod hand;
@@ -1323,6 +1324,8 @@ struct Game<'a> {
     /// Runs of `entity_vertices` by entity, for a shader pack's per-entity draws; recorded only
     /// while `pack_ids` is set (game/shader_packs.rs).
     entity_spans: std::cell::RefCell<Vec<horizon_client::gfx::pack_draw::EntitySpan>>,
+    /// The glowing entities' silhouettes this frame (game/glowing.rs).
+    glowing_vertices: std::cell::RefCell<Vec<Vertex>>,
     /// The shader pack's entity and block entity ids, while one draws entities.
     pack_ids: Option<shader_packs::PackIds>,
     started: Instant,
@@ -10805,6 +10808,7 @@ impl Game<'_> {
         let mut entities = std::mem::take(&mut self.entity_vertices);
         entities.clear();
         self.see_through_vertices.clear();
+        self.glowing_vertices.get_mut().clear();
         if !title {
             entities = horizon_client::spans::time("entity_geometry", || {
                 self.entity_geometry(camera, alpha, entities)
@@ -10872,6 +10876,7 @@ impl Game<'_> {
         // map_patches any earlier leaves them a frame behind.
         hud.patches.append(&mut self.map_patches);
         let entity_spans = std::mem::take(self.entity_spans.get_mut());
+        let glowing = std::mem::take(self.glowing_vertices.get_mut());
         let frame = Frame {
             weather: &weather,
             weather_time: horizon_client::weather::Time::new(self.world.game_time, alpha as f32),
@@ -10937,6 +10942,7 @@ impl Game<'_> {
             }),
             entities: &entities,
             entity_spans: &entity_spans,
+            glowing: &glowing,
             dynamic_lights: &self.dynamic_lights,
             lightning: horizon_client::gfx::lightning::Input {
                 bolts: &bolts,
@@ -10992,6 +10998,7 @@ impl Game<'_> {
         // Restore storage even when rendering fails (for example, a lost surface).
         self.entity_vertices = entities;
         *self.entity_spans.get_mut() = entity_spans;
+        *self.glowing_vertices.get_mut() = glowing;
         self.see_through_vertices = see_through;
         result
     }
@@ -12639,6 +12646,7 @@ impl<'a> Game<'a> {
             luminance: None,
             see_through_vertices: Vec::new(),
             entity_spans: Default::default(),
+            glowing_vertices: Default::default(),
             pack_ids: None,
             health_hud: hud_layout::HealthHud::default(),
             started: now,
@@ -13600,6 +13608,7 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> {
         nether_lighting: false,
         entities: &[],
         entity_spans: &[],
+        glowing: &[],
         dynamic_lights: &[],
         clouds: None,
         lightning: Default::default(),
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index f6961ab13..eb8b69337 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -3262,8 +3262,10 @@ impl Game<'_> {
         let scale = f64::from(self.settings.entity_distance);
         for mob in &self.mobs {
             let entity_start = out.len();
-            // Entity.DATA_SHARED_FLAGS_ID invisible: only the name tag draws.
-            if mob.invisible {
+            let outline = self.mob_outline(mob);
+            // Entity.DATA_SHARED_FLAGS_ID invisible: only the name tag draws (and
+            // the outline of a glowing mob, LivingEntityRenderer.getRenderType).
+            if mob.invisible && outline.is_none() {
                 continue;
             }
             let d = glam::DVec3::new(mob.position.x, mob.position.y, mob.position.z) - camera;
@@ -3325,9 +3327,18 @@ impl Game<'_> {
                 out,
             );
             self.mob_block_geometry(mob, camera, alpha, packed, out);
+            if let Some(rgb) = outline {
+                self.mark_outline(&out[entity_start..], rgb);
+                if mob.invisible {
+                    out.truncate(entity_start);
+                    continue;
+                }
+            }
             // Glowing outlines and a guardian's beam remain visible independently
             // of whether the body is hidden behind terrain.
-            if !mob.glowing && horizon_client::mobs::guardian::beam(mob, alpha as f32).is_none() {
+            if outline.is_none()
+                && horizon_client::mobs::guardian::beam(mob, alpha as f32).is_none()
+            {
                 self.cull_entity_vertices(out, entity_start);
             }
             // GuardianRenderer: the laser to the locked target.
@@ -3375,7 +3386,15 @@ impl Game<'_> {
             super::pickups::Taken::Arrow(a) => Some((&**a, super::pickups::position(p, alpha))),
             _ => None,
         });
+        // A glowing projectile's outline: what it drew up to the next one.
+        let mut glowing = None;
         for (a, at) in live.chain(taken) {
+            if let Some((start, rgb)) = glowing.take() {
+                self.mark_outline(&out[start..], rgb);
+            }
+            if a.id != 0 && self.entity_glowing(a.id) {
+                glowing = Some((out.len(), super::glowing::team_color(self.mob_team(a.id))));
+            }
             let p = glam::DVec3::from_array(at) - camera;
             let c = p.as_vec3();
             let light = self.world.light(
@@ -3483,6 +3502,9 @@ impl Game<'_> {
                 });
             }
         }
+        if let Some((start, rgb)) = glowing {
+            self.mark_outline(&out[start..], rgb);
+        }
     }
 }
 /// `Bucketable.getBucketItemStack` and `getPickupSound` of a mob that a water
diff --git a/crates/horizon-client/src/game/glowing.rs b/crates/horizon-client/src/game/glowing.rs
new file mode 100644
index 000000000..8c78dbd77
--- /dev/null
+++ b/crates/horizon-client/src/game/glowing.rs
@@ -0,0 +1,53 @@
+//! Glowing entities (`EntityRenderer.extractRenderState`'s outlineColor): which entities
+//! appear glowing, in which team colour, and their silhouettes for the renderer's entity
+//! outline (`OutlineBufferSource`).
+use super::{Game, Vertex};
+use horizon_client::{mobs::Mob, scoreboard as sb};
+
+/// `Entity.getTeamColor`: the team's colour, else white.
+pub(super) fn team_color(team: Option<&sb::Team>) -> u32 {
+    team.and_then(|t| t.color.as_deref())
+        .and_then(sb::team_color_rgb)
+        .unwrap_or(0xFF_FFFF)
+}
+
+impl Game<'_> {
+    /// `Entity.isCurrentlyGlowing` of an entity that is not living (an item, a projectile):
+    /// its `Glowing` tag, or shared flag 6 as a server sent it.
+    pub(super) fn entity_glowing(&self, id: u32) -> bool {
+        self.remote_glowing(id).unwrap_or_else(|| {
+            self.persist_raw(id)
+                .and_then(|t| horizon_client::save::number(t.get("Glowing")))
+                .is_some_and(|b| b != 0)
+        })
+    }
+
+    /// `Minecraft.shouldEntityAppearGlowing` of a mob or another player, with its outline
+    /// colour (`getTeamColor`; another player's team goes by name).
+    pub(super) fn mob_outline(&self, m: &Mob) -> Option<u32> {
+        if !m.is_currently_glowing() {
+            return None;
+        }
+        let team = if &*m.kind.id == "minecraft:player" {
+            let names = self.remote_player_names();
+            let name = names.into_iter().find(|(id, _)| *id == m.id);
+            name.and_then(|(_, name)| self.score.board.players_team(&name))
+        } else {
+            self.mob_team(m.id)
+        };
+        Some(team_color(team))
+    }
+
+    /// Adds one glowing entity's geometry to the outline pass in `rgb`, the textures'
+    /// alpha kept (`OutlineBufferSource`'s team-coloured copy of each draw).
+    pub(super) fn mark_outline(&self, vertices: &[Vertex], rgb: u32) {
+        let color = horizon_client::mobs::render::abgr(rgb);
+        self.glowing_vertices
+            .borrow_mut()
+            .extend(vertices.iter().map(|v| Vertex {
+                color,
+                normal: [0; 4],
+                ..*v
+            }));
+    }
+}
diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs
index b6b7e2fb7..558ce46e0 100644
--- a/crates/horizon-client/src/game/item_draw.rs
+++ b/crates/horizon-client/src/game/item_draw.rs
@@ -405,7 +405,12 @@ impl Game<'_> {
             ) {
                 self.submit_item_world(&state, copy, vertex_light(packed), out);
             }
-            self.cull_entity_vertices(out, entity_start);
+            if self.entity_glowing(item.id) {
+                let rgb = super::glowing::team_color(self.mob_team(item.id));
+                self.mark_outline(&out[entity_start..], rgb);
+            } else {
+                self.cull_entity_vertices(out, entity_start);
+            }
         }
     }
 }
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..17997c088 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -152,8 +152,11 @@ fn mob_meta(
     defaults: &mut Vec<(u8, i32, Value)>,
 ) {
     let kind = m.kind.id.as_str();
-    if m.fire_ticks > 0 {
-        meta.push((0, serializer::BYTE, Value::Byte(1)));
+    // Entity.DATA_SHARED_FLAGS_ID: on fire 0x01, glowing 0x40
+    // (LivingEntity.updateGlowingStatus).
+    let shared = i8::from(m.fire_ticks > 0) | i8::from(m.is_currently_glowing()) << 6;
+    if shared != 0 {
+        meta.push((0, serializer::BYTE, Value::Byte(shared)));
     }
     if let Some(name) = &m.custom_name {
         meta.push((
@@ -878,6 +881,10 @@ impl Game<'_> {
             e.position = [d.position.x, d.position.y, d.position.z];
             e.on_ground = d.on_ground;
             e.velocity = [d.velocity.x, d.velocity.y, d.velocity.z];
+            // Entity.DATA_SHARED_FLAGS_ID: glowing 0x40 (the Glowing tag).
+            if self.entity_glowing(d.id) {
+                e.meta.push((0, serializer::BYTE, Value::Byte(0x40)));
+            }
             e.meta.push((8, serializer::ITEM_STACK, Value::Item(stack)));
         }
         for o in &self.orbs {
@@ -1470,7 +1477,12 @@ impl Game<'_> {
                 out,
             );
             self.held_item_geometry(m, camera, alpha, packed, true, out);
-            if !m.glowing {
+            // LivingEntity.isCurrentlyGlowing: the guest's Glowing effect.
+            let guest = host.hub.guest(*conn);
+            if m.glowing || guest.is_some_and(|g| g.effects.get("glowing").is_some()) {
+                let team = guest.and_then(|g| self.score.board.players_team(&g.name));
+                self.mark_outline(&out[entity_start..], super::glowing::team_color(team));
+            } else {
                 self.cull_entity_vertices(out, entity_start);
             }
         }
diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs
index caf49883b..72f2d8eec 100644
--- a/crates/horizon-client/src/game/perspective.rs
+++ b/crates/horizon-client/src/game/perspective.rs
@@ -443,6 +443,7 @@ impl Game<'_> {
         let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
         let atlas = &self.gui.atlas;
         let lookup = |name: &str| atlas.sprites.get(name).map(|r| [r.u0, r.v0, r.u1, r.v1]);
+        let start = out.len();
         horizon_client::mobs::render::render_with(
             m,
             alpha as f32,
@@ -456,6 +457,15 @@ impl Game<'_> {
         self.player_elytra_geometry(m, camera, alpha as f32, packed, out);
         self.spin_attack_geometry(m, camera, alpha as f32, packed, out);
         self.held_item_geometry(m, camera, alpha, packed, true, out);
+        // LivingEntity.isCurrentlyGlowing: the Glowing effect. A server's client is
+        // in its team by its profile name.
+        if self.potions.effects.get("glowing").is_some() {
+            let team = match &self.remote {
+                Some(r) => self.score.board.players_team(&r.profile_name),
+                None => self.player_team(),
+            };
+            self.mark_outline(&out[start..], super::glowing::team_color(team));
+        }
     }
     /// `extractEntityInInventoryFollowsMouse`: the player in the box
     /// `[x0, x1) x [y0, y1)`, `size` pixels per block, turned toward the
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..d0070d0cd 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -182,6 +182,9 @@ pub(super) struct Remote {
     online_mode: bool,
     /// Player entities in the level: entity id to profile UUID.
     level_players: HashMap<i32, u128>,
+    /// Entities with shared flag 6 (`Entity.isCurrentlyGlowing` on a client); mobs keep
+    /// theirs in `Mob::glowing`.
+    glowing: std::collections::HashSet<i32>,
     /// The local player's profile UUID (always in the level).
     profile: u128,
     /// The local player's profile name: its score holder and team member.
@@ -468,6 +471,7 @@ impl Game<'_> {
             listed: Default::default(),
             online_mode: false,
             level_players: HashMap::new(),
+            glowing: Default::default(),
             profile: 0,
             profile_name: String::new(),
             destroying: None,
@@ -1466,7 +1470,9 @@ impl Game<'_> {
         self.remove_remote_dragon(id);
         self.remove_remote_object(id as u32);
         self.remove_remote_projectile(id as u32);
+        self.persist.uuids.remove(&(id as u32));
         if let Some(r) = self.remote.as_mut() {
+            r.glowing.remove(&id);
             r.entities.remove(&id);
             r.lerps.remove(&id);
             r.stepped.remove(&id);
@@ -1767,6 +1773,11 @@ impl Game<'_> {
                         r.level_players.remove(&p.id);
                     }
                 }
+                // Entity.getTeam: a mob is on a team by its UUID.
+                self.persist.uuids.insert(
+                    p.id as u32,
+                    horizon_client::lan::playerdata::uuid_ints(p.uuid),
+                );
                 self.spawn_entity(p.id, &kind, p.position, rotation);
                 // Entity.recreateFromPacket: setDeltaMovement(packet.getMovement()).
                 self.remote_motion(p.id, p.velocity);
@@ -1885,7 +1896,10 @@ impl Game<'_> {
                 if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
                     for (index, _, value) in &p.values {
                         match (index, value) {
-                            (0, Value::Byte(flags)) => m.invisible = flags & 0x20 != 0,
+                            (0, Value::Byte(flags)) => {
+                                m.invisible = flags & 0x20 != 0;
+                                m.glowing = flags & 0x40 != 0;
+                            }
                             (2, Value::OptText(name)) => {
                                 let text = name.as_ref().map(horizon_client::entity_nbt::name_text);
                                 m.custom_name =
@@ -1902,6 +1916,15 @@ impl Game<'_> {
                         }
                     }
                 }
+                if let Some((_, _, Value::Byte(flags))) = p.values.iter().find(|v| v.0 == 0)
+                    && let Some(r) = self.remote.as_mut()
+                {
+                    if flags & 0x40 != 0 {
+                        r.glowing.insert(p.id);
+                    } else {
+                        r.glowing.remove(&p.id);
+                    }
+                }
                 self.remote_mob_data(p.id, &p.values);
                 if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32)
                     && m.species() == horizon_client::mobs::Species::Creeper
@@ -5190,6 +5213,11 @@ impl Game<'_> {
             batch.text(atlas, message, (w - tw) / 2.0, 85.0, u32::MAX, true);
         }
     }
+    /// Shared flag 6 of an entity on a server's client (`None` without a server).
+    pub(super) fn remote_glowing(&self, id: u32) -> Option<bool> {
+        let r = self.remote.as_ref()?;
+        Some(r.glowing.contains(&(id as i32)))
+    }
     /// Status for `horizon-ctl status`.
     /// The other players' entities in the level and their names (from the
     /// player list).
diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index 70d882a98..dfd2ca7e7 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -35,6 +35,7 @@ fn entity_shader() -> String {
 #[cfg(test)]
 mod crumbling_tests;
 mod entity_batch;
+mod entity_outline;
 mod weather;
 use entity_batch::EntityBatch;
 pub use entity_batch::{SHADOW_OVERLAY, TRANSLUCENT_PARTICLE_OVERLAY, WATER_MASK_OVERLAY};
@@ -260,6 +261,9 @@ pub struct Frame<'a> {
     pub nether_lighting: bool,
     /// Camera-relative entity geometry textured from the shared atlas.
     pub entities: &'a [Vertex],
+    /// The glowing entities' silhouettes in their team colours (`OutlineBufferSource`),
+    /// outlined through walls after the hand.
+    pub glowing: &'a [Vertex],
     /// Runs of `entities` by entity, while a shader pack draws them (`pack_draw::EntitySpan`).
     pub entity_spans: &'a [pack_draw::EntitySpan],
     pub weather: &'a [crate::weather::Vertex],
@@ -407,6 +411,8 @@ pub struct Renderer {
     celestial_buffer: wgpu::Buffer,
     end_sky: end_sky::EndSky,
     stars: stars::Stars,
+    /// The glowing entities' outline (`LevelRenderer.entityOutlineTarget`).
+    entity_outline: entity_outline::EntityOutline,
     panorama: panorama::Panorama,
     /// `RenderPipelines.WORLD_BORDER` and its buffers.
     border_pipeline: wgpu::RenderPipeline,
@@ -2316,6 +2322,11 @@ impl Renderer {
         let uploads = upload::Uploads::new(&device);
         let section_uploads = upload::Uploads::with_chunk(&device, SECTION_UPLOAD_CHUNK);
         let stars = stars::Stars::new(&device, config.format.remove_srgb_suffix());
+        let entity_outline = entity_outline::EntityOutline::new(
+            &device,
+            (&entity_shader, &entity_layout, &entity_vertex),
+            config.format.remove_srgb_suffix(),
+        );
         let panorama = panorama::Panorama::new(
             &device,
             &queue,
@@ -2386,6 +2397,7 @@ impl Renderer {
             celestial_buffer,
             end_sky: end_sky::EndSky::default(),
             stars,
+            entity_outline,
             panorama,
             border_pipeline,
             border_group,
@@ -4051,6 +4063,13 @@ impl Renderer {
                 bytemuck::cast_slice(all_entities),
             );
         }
+        self.entity_outline.prepare(
+            &self.device,
+            &mut self.uploads,
+            &mut encoder,
+            frame.glowing,
+            [self.config.width, self.config.height],
+        );
         if let Some((rotation, brightness)) = frame.stars {
             self.stars.prepare(
                 &mut self.uploads,
@@ -4078,7 +4097,8 @@ impl Renderer {
             } else {
                 lightning::QUADS
             })
-            .max(weather_quads);
+            .max(weather_quads)
+            .max(frame.glowing.len() as u32 / 4);
         if max_quads > self.index_quads {
             self.index_quads = max_quads.next_power_of_two();
             self.indices = Self::quad_indices(&self.device, self.index_quads);
@@ -4808,6 +4828,13 @@ impl Renderer {
                 0..1,
             );
         }
+        // GameRenderer.render: LevelRenderer.blitEntityOutline after the level and the hand.
+        self.entity_outline.draw(
+            &mut encoder,
+            &view_target,
+            &self.entity_group,
+            &self.indices,
+        );
         if !frame.screen.is_empty() {
             let attachments = [Some(wgpu::RenderPassColorAttachment {
                 view: &view_target,
diff --git a/crates/horizon-client/src/gfx/entity_outline.rs b/crates/horizon-client/src/gfx/entity_outline.rs
new file mode 100644
index 000000000..748622019
--- /dev/null
+++ b/crates/horizon-client/src/gfx/entity_outline.rs
@@ -0,0 +1,311 @@
+//! The entity outline (`LevelRenderer.entityOutlineTarget`): the glowing entities'
+//! silhouettes in their team colours, drawn without depth so walls do not hide them
+//! (`RenderTypes.outline`), the `entity_outline` post chain over them (`entity_sobel`, then
+//! `entity_outline_box_blur` across and up), and `LevelRenderer.blitEntityOutline` onto
+//! the frame after the hand.
+use super::Vertex;
+
+/// `entityOutlineTarget`'s `GpuFormat.RGBA8_UNORM`.
+const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
+
+struct Targets {
+    size: [u32; 2],
+    /// `entityOutlineTarget`.
+    outline: wgpu::TextureView,
+    /// The chain's `swap` target.
+    swap: wgpu::TextureView,
+    /// What each pass reads: the outline (nearest), swap (bilinear), the outline
+    /// (bilinear), swap (nearest).
+    groups: [wgpu::BindGroup; 4],
+}
+
+pub(super) struct EntityOutline {
+    silhouette: wgpu::RenderPipeline,
+    /// Sobel, blur across, blur up (into `FORMAT`) and the blended blit (onto the frame).
+    passes: [wgpu::RenderPipeline; 4],
+    layout: wgpu::BindGroupLayout,
+    nearest: wgpu::Sampler,
+    bilinear: wgpu::Sampler,
+    vertices: wgpu::Buffer,
+    capacity: u64,
+    quads: u32,
+    targets: Option<Targets>,
+}
+
+impl EntityOutline {
+    /// `entity` draws the silhouettes with the entity shader's vertex stage and
+    /// `fs_outline`; `format` is the frame's.
+    pub(super) fn new(
+        device: &wgpu::Device,
+        entity: (
+            &wgpu::ShaderModule,
+            &wgpu::PipelineLayout,
+            &[Option<wgpu::VertexBufferLayout>],
+        ),
+        format: wgpu::TextureFormat,
+    ) -> Self {
+        let (entity_shader, entity_layout, entity_vertex) = entity;
+        // RenderPipelines.OUTLINE_NO_CULL: no depth test, the colour replaced.
+        let silhouette = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("Entity outline silhouettes"),
+            layout: Some(entity_layout),
+            vertex: wgpu::VertexState {
+                module: entity_shader,
+                entry_point: Some("vs_entity"),
+                compilation_options: Default::default(),
+                buffers: entity_vertex,
+            },
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: entity_shader,
+                entry_point: Some("fs_outline"),
+                compilation_options: Default::default(),
+                targets: &[Some(FORMAT.into())],
+            }),
+            multiview_mask: None,
+            cache: None,
+        });
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Entity outline"),
+            source: wgpu::ShaderSource::Wgsl(include_str!("entity_outline.wgsl").into()),
+        });
+        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Entity outline bindings"),
+            entries: &[
+                wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Texture {
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                    count: None,
+                },
+            ],
+        });
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("Entity outline"),
+            bind_group_layouts: &[Some(&layout)],
+            ..Default::default()
+        });
+        let pass = |entry: &str, target: wgpu::ColorTargetState| {
+            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                label: Some(entry),
+                layout: Some(&pipeline_layout),
+                vertex: wgpu::VertexState {
+                    module: &shader,
+                    entry_point: Some("vs_quad"),
+                    compilation_options: Default::default(),
+                    buffers: &[],
+                },
+                primitive: Default::default(),
+                depth_stencil: None,
+                multisample: Default::default(),
+                fragment: Some(wgpu::FragmentState {
+                    module: &shader,
+                    entry_point: Some(entry),
+                    compilation_options: Default::default(),
+                    targets: &[Some(target)],
+                }),
+                multiview_mask: None,
+                cache: None,
+            })
+        };
+        // BlendFunction.ENTITY_OUTLINE_BLIT over the colour only (write mask 7).
+        let blit = wgpu::ColorTargetState {
+            format,
+            blend: Some(wgpu::BlendState {
+                color: wgpu::BlendComponent {
+                    src_factor: wgpu::BlendFactor::SrcAlpha,
+                    dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                    operation: wgpu::BlendOperation::Add,
+                },
+                alpha: wgpu::BlendComponent {
+                    src_factor: wgpu::BlendFactor::Zero,
+                    dst_factor: wgpu::BlendFactor::One,
+                    operation: wgpu::BlendOperation::Add,
+                },
+            }),
+            write_mask: wgpu::ColorWrites::COLOR,
+        };
+        let sampler = |label, filter| {
+            device.create_sampler(&wgpu::SamplerDescriptor {
+                label: Some(label),
+                mag_filter: filter,
+                min_filter: filter,
+                ..Default::default()
+            })
+        };
+        Self {
+            silhouette,
+            passes: [
+                pass("fs_sobel", FORMAT.into()),
+                pass("fs_blur_x", FORMAT.into()),
+                pass("fs_blur_y", FORMAT.into()),
+                pass("fs_blit", blit),
+            ],
+            layout,
+            nearest: sampler("Entity outline nearest", wgpu::FilterMode::Nearest),
+            bilinear: sampler("Entity outline bilinear", wgpu::FilterMode::Linear),
+            vertices: Self::vertex_buffer(device, 256),
+            capacity: 256,
+            quads: 0,
+            targets: None,
+        }
+    }
+
+    fn vertex_buffer(device: &wgpu::Device, capacity: u64) -> wgpu::Buffer {
+        device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Entity outline vertices"),
+            size: capacity * std::mem::size_of::<Vertex>() as u64,
+            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        })
+    }
+
+    /// Uploads this frame's silhouettes (`LevelRenderer.currentFrameRendersEntityOutline`
+    /// when there are any) and sizes the targets like the window.
+    pub(super) fn prepare(
+        &mut self,
+        device: &wgpu::Device,
+        uploads: &mut super::upload::Uploads,
+        encoder: &mut wgpu::CommandEncoder,
+        silhouettes: &[Vertex],
+        size: [u32; 2],
+    ) {
+        self.quads = (silhouettes.len() / 4) as u32;
+        if self.quads == 0 {
+            return;
+        }
+        let vertices = silhouettes.len() as u64;
+        if vertices > self.capacity {
+            self.capacity = vertices.next_power_of_two();
+            self.vertices = Self::vertex_buffer(device, self.capacity);
+        }
+        uploads.buffer(
+            encoder,
+            &self.vertices,
+            0,
+            bytemuck::cast_slice(silhouettes),
+        );
+        if self.targets.as_ref().is_some_and(|t| t.size == size) {
+            return;
+        }
+        let texture = |label| {
+            device
+                .create_texture(&wgpu::TextureDescriptor {
+                    label: Some(label),
+                    size: wgpu::Extent3d {
+                        width: size[0],
+                        height: size[1],
+                        depth_or_array_layers: 1,
+                    },
+                    mip_level_count: 1,
+                    sample_count: 1,
+                    dimension: wgpu::TextureDimension::D2,
+                    format: FORMAT,
+                    usage: wgpu::TextureUsages::RENDER_ATTACHMENT
+                        | wgpu::TextureUsages::TEXTURE_BINDING,
+                    view_formats: &[],
+                })
+                .create_view(&Default::default())
+        };
+        let outline = texture("Entity outline");
+        let swap = texture("Entity outline swap");
+        let group = |view: &wgpu::TextureView, sampler: &wgpu::Sampler| {
+            device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label: Some("Entity outline pass"),
+                layout: &self.layout,
+                entries: &[
+                    wgpu::BindGroupEntry {
+                        binding: 0,
+                        resource: wgpu::BindingResource::TextureView(view),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 1,
+                        resource: wgpu::BindingResource::Sampler(sampler),
+                    },
+                ],
+            })
+        };
+        let groups = [
+            group(&outline, &self.nearest),
+            group(&swap, &self.bilinear),
+            group(&outline, &self.bilinear),
+            group(&swap, &self.nearest),
+        ];
+        self.targets = Some(Targets {
+            size,
+            outline,
+            swap,
+            groups,
+        });
+    }
+
+    /// `LevelRenderer.executeOutline`, the post chain and `blitEntityOutline` onto `frame`.
+    pub(super) fn draw(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        frame: &wgpu::TextureView,
+        entity_group: &wgpu::BindGroup,
+        indices: &wgpu::Buffer,
+    ) {
+        let Some(t) = self.targets.as_ref().filter(|_| self.quads > 0) else {
+            return;
+        };
+        let clear = wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT);
+        {
+            let mut pass = begin(encoder, "Entity outline", &t.outline, clear);
+            pass.set_pipeline(&self.silhouette);
+            pass.set_bind_group(0, entity_group, &[]);
+            pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32);
+            pass.set_vertex_buffer(0, self.vertices.slice(..));
+            pass.draw_indexed(0..self.quads * 6, 0, 0..1);
+        }
+        // post_effect/entity_outline.json; its last pass only copies swap back to the
+        // outline target, so the blit reads swap.
+        let steps = [
+            ("Entity outline sobel", &t.swap, clear),
+            ("Entity outline blur across", &t.outline, clear),
+            ("Entity outline blur up", &t.swap, clear),
+            ("Entity outline blit", frame, wgpu::LoadOp::Load),
+        ];
+        for (i, (label, view, load)) in steps.into_iter().enumerate() {
+            let mut pass = begin(encoder, label, view, load);
+            pass.set_pipeline(&self.passes[i]);
+            pass.set_bind_group(0, &t.groups[i], &[]);
+            pass.draw(0..3, 0..1);
+        }
+    }
+}
+
+fn begin<'e>(
+    encoder: &'e mut wgpu::CommandEncoder,
+    label: &str,
+    view: &wgpu::TextureView,
+    load: wgpu::LoadOp<wgpu::Color>,
+) -> wgpu::RenderPass<'e> {
+    let attachments = [Some(wgpu::RenderPassColorAttachment {
+        view,
+        resolve_target: None,
+        depth_slice: None,
+        ops: wgpu::Operations {
+            load,
+            store: wgpu::StoreOp::Store,
+        },
+    })];
+    encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+        label: Some(label),
+        color_attachments: &attachments,
+        ..Default::default()
+    })
+}
diff --git a/crates/horizon-client/src/gfx/entity_outline.wgsl b/crates/horizon-client/src/gfx/entity_outline.wgsl
new file mode 100644
index 000000000..bd723f11e
--- /dev/null
+++ b/crates/horizon-client/src/gfx/entity_outline.wgsl
@@ -0,0 +1,60 @@
+// The entity_outline post chain (post_effect/entity_outline.json) over the silhouettes of
+// the glowing entities, then RenderTarget.blitAndBlendToTexture onto the frame.
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var source_sampler: sampler;
+
+struct PostOut {
+    @builtin(position) clip: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+};
+
+// screenquad.vsh, with v running down the rows as wgpu's textures do.
+@vertex fn vs_quad(@builtin(vertex_index) i: u32) -> PostOut {
+    let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
+    var out: PostOut;
+    out.clip = vec4(p * 2.0 - 1.0, 0.0, 1.0);
+    out.uv = vec2(p.x, 1.0 - p.y);
+    return out;
+}
+
+fn tap(uv: vec2<f32>) -> vec4<f32> {
+    return textureSampleLevel(source, source_sampler, uv, 0.0);
+}
+
+// entity_sobel.fsh: alpha marks where coverage changes, the colour is the mean of the
+// covered texels around.
+@fragment fn fs_sobel(in: PostOut) -> @location(0) vec4<f32> {
+    let texel = 1.0 / vec2<f32>(textureDimensions(source));
+    let center = tap(in.uv);
+    let left = tap(in.uv - vec2(texel.x, 0.0));
+    let right = tap(in.uv + vec2(texel.x, 0.0));
+    let up = tap(in.uv - vec2(0.0, texel.y));
+    let down = tap(in.uv + vec2(0.0, texel.y));
+    let total = clamp(abs(center.a - left.a) + abs(center.a - right.a)
+        + abs(center.a - up.a) + abs(center.a - down.a), 0.0, 1.0);
+    let color = center.rgb * center.a + left.rgb * left.a + right.rgb * right.a
+        + up.rgb * up.a + down.rgb * down.a;
+    return vec4(color * 0.2, total);
+}
+
+// entity_outline_box_blur.fsh at Radius 2: bilinear taps at -1.5 and 0.5 texels and half
+// a tap at 2; the colour averaged, the alpha summed.
+fn blur(uv: vec2<f32>, step: vec2<f32>) -> vec4<f32> {
+    let blurred = tap(uv + step * -1.5) + tap(uv + step * 0.5) + tap(uv + step * 2.0) / 2.0;
+    return vec4(blurred.rgb / 2.5, blurred.a);
+}
+
+// BlurDir (1, 0).
+@fragment fn fs_blur_x(in: PostOut) -> @location(0) vec4<f32> {
+    return blur(in.uv, vec2(1.0 / f32(textureDimensions(source).x), 0.0));
+}
+
+// BlurDir (0, 1): up the screen in GL's bottom-up textures, towards row 0 here.
+@fragment fn fs_blur_y(in: PostOut) -> @location(0) vec4<f32> {
+    return blur(in.uv, vec2(0.0, -1.0 / f32(textureDimensions(source).y)));
+}
+
+// blit_screen.fsh, blended by RenderPipelines.ENTITY_OUTLINE_BLIT.
+@fragment fn fs_blit(in: PostOut) -> @location(0) vec4<f32> {
+    return tap(in.uv);
+}
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index f4086216d..c666ead1c 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1944,6 +1944,11 @@ impl Mob {
     pub fn has_effect(&self, effect: &str) -> bool {
         self.extra.effects.iter().any(|e| e.0 == effect)
     }
+    /// `LivingEntity.isCurrentlyGlowing`: the Glowing effect or the `Glowing` tag (on a
+    /// server's client, `glowing` holds shared flag 6 instead).
+    pub fn is_currently_glowing(&self) -> bool {
+        self.glowing || self.has_effect("minecraft:glowing")
+    }
     pub fn add_effect(&mut self, effect: &'static str, ticks: i32, amplifier: i32) {
         if let Some(e) = self.extra.effects.iter_mut().find(|e| e.0 == effect) {
             e.1 = e.1.max(ticks);

From 266c7a2cd92116965fd379884591ddab373b3f46 Mon Sep 17 00:00:00 2001
From: FusselTV <github@fussel.tv>
Date: Mon, 26 Oct 2026 14:47:04 +0100
Subject: [PATCH 349/475] Worldgen: finalize structure mobs at placement, as
 vanilla

Structure mobs (bastion piglins, brutes and hoglins, ocean ruin drowned,
village and mansion mobs, witch huts, monuments) were tagged and finalized
at load by the cut-down spawning routine: no STRUCTURE reason (piglin
weapons rerolled), no Mob step (follow range bonus, left-handedness), no
baby hoglins, no brain memories, no drowned nautilus mounts, and draws
from each mob's own random. The decoration region now calls a hook the
game installs in the generator workers, which runs mobs::finalize with
Reason::Structure, the region random in placement order and the level's
difficulty with no inhabited time; jockeys come back as the vehicle with
its Passengers. A mob the hook cannot finalize keeps its tag and is
finalized on load as before, as are mobs of older saves; other entities
drop the tag. The generator gets the level's difficulty as soon as the
level opens, so the spawn area's mobs use it too. mob_to_nbt writes Invulnerable and LeftHanded always, IsBaby
for zombies and piglins, Age for hoglins, the finalized attributes and
memories, and drops the template keys vanilla never saves.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/entity_nbt.rs       | 154 +++++-
 crates/horizon-client/src/game.rs             |   3 +
 crates/horizon-client/src/game/creatures.rs   |   6 +
 crates/horizon-client/src/game/levels.rs      |   1 +
 crates/horizon-client/src/game/persist.rs     |  12 +-
 crates/horizon-client/src/game/raids.rs       |   2 +-
 crates/horizon-client/src/vanillagen.rs       |  16 +-
 .../src/vanillagen/structure_mobs.rs          | 446 ++++++++++++++++++
 .../horizon-world/src/worldgen/generator.rs   |  20 +
 .../src/worldgen/generator_decoration.rs      |  51 +-
 .../src/worldgen/structure/legacy.rs          |   7 +-
 11 files changed, 698 insertions(+), 20 deletions(-)
 create mode 100644 crates/horizon-client/src/vanillagen/structure_mobs.rs

diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 161ca12e9..c49af48c9 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -180,7 +180,6 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         ("Silent", m.silent),
         ("NoGravity", m.no_gravity),
         ("Glowing", m.glowing),
-        ("Invulnerable", m.invulnerable_flag),
     ] {
         if on {
             map.insert(key.into(), Tag::Byte(1));
@@ -188,6 +187,26 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             map.remove(&horizon_world::nbt::JavaString::from(key));
         }
     }
+    map.insert(
+        "Invulnerable".into(),
+        Tag::Byte(i8::from(m.invulnerable_flag)),
+    );
+    map.insert(
+        "LeftHanded".into(),
+        Tag::Byte(i8::from(m.extra.left_handed)),
+    );
+    // Keys of older formats that structure templates still carry.
+    for key in [
+        "HandItems",
+        "ArmorItems",
+        "HandDropChances",
+        "ArmorDropChances",
+        "Dimension",
+        "HurtByTimestamp",
+        "Leashed",
+    ] {
+        map.remove(&horizon_world::nbt::JavaString::from(key));
+    }
     if m.ticks_frozen > 0 {
         map.insert("TicksFrozen".into(), Tag::Int(m.ticks_frozen));
     } else {
@@ -197,7 +216,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         ("AbsorptionAmount", Tag::Float(0)),
         ("FallFlying", Tag::Byte(0)),
         ("CanPickUpLoot", Tag::Byte(i8::from(m.can_pick_up_loot()))),
-        ("LeftHanded", Tag::Byte(0)),
+        ("current_impulse_context_reset_grace_time", Tag::Int(0)),
         (
             "Brain",
             Tag::compound([("memories", Tag::Compound(Compound::new()))]),
@@ -209,7 +228,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
     // Only breedable animals have an age; a loaded creature that was saved without
     // one (a frog) stays without.
     let aged = raw.is_none_or(|r| r.get("Age").is_some());
-    if m.kind.category == "creature" && aged {
+    if (m.kind.category == "creature" || m.species() == crate::mobs::Species::Hoglin) && aged {
         map.insert("Age".into(), Tag::Int(m.extra.age));
         map.insert("AgeLocked".into(), Tag::Byte(i8::from(m.extra.age_locked)));
         map.insert("ForcedAge".into(), Tag::Int(m.extra.forced_age));
@@ -260,6 +279,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
                 .or_insert_with(|| string("minecraft:classic"));
         }
         "minecraft:piglin" | "minecraft:piglin_brute" | "minecraft:hoglin" => {
+            // Only Piglin.addAdditionalSaveData writes CannotHunt.
+            if id == "minecraft:piglin_brute" {
+                map.remove(&"CannotHunt".into());
+            }
             map.insert(
                 "IsImmuneToZombification".into(),
                 Tag::Byte(i8::from(m.extra.flag2)),
@@ -498,8 +521,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
                 )])
             });
         }
-        "minecraft:zombie" => {
-            map.insert("IsBaby".into(), Tag::Byte(i8::from(m.is_baby())));
+        "minecraft:zombie" | "minecraft:husk" | "minecraft:drowned" => {
             for (key, value) in [
                 ("DrownedConversionTime", Tag::Int(-1)),
                 ("InWaterTime", Tag::Int(-1)),
@@ -532,6 +554,21 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             Tag::Byte(i8::from(m.extra.can_break_doors)),
         );
     }
+    if matches!(
+        id,
+        "minecraft:zombie"
+            | "minecraft:husk"
+            | "minecraft:drowned"
+            | "minecraft:zombie_villager"
+            | "minecraft:zombified_piglin"
+            | "minecraft:piglin"
+            | "minecraft:zoglin"
+    ) {
+        map.insert("IsBaby".into(), Tag::Byte(i8::from(m.is_baby())));
+    }
+    if let Some(a) = m.extra.attributes.as_deref() {
+        put_attributes(map, m, a);
+    }
     crate::mobs::raider::write_nbt(m, map);
     crate::mobs::riders::write_nbt(m, map);
     // LivingEntity equipment: what the mob holds now.
@@ -614,6 +651,89 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
     }
     tag
 }
+/// `AttributeMap.pack` for the attributes with a base or permanent modifier
+/// finalizeSpawn set, over the saved list.
+fn put_attributes(map: &mut Compound, m: &Mob, a: &crate::mobs::finalize::Attributes) {
+    use crate::mobs::finalize::{self, Attr, Op};
+    let mut list = match map.get(&"attributes".into()) {
+        Some(Tag::List(l)) => l.clone(),
+        _ => Vec::new(),
+    };
+    for attr in Attr::ALL {
+        let modifiers: Vec<Tag> = a
+            .modifiers
+            .iter()
+            .filter(|x| x.attr == attr)
+            .map(|x| {
+                let op = match x.op {
+                    Op::AddValue => "add_value",
+                    Op::AddMultipliedBase => "add_multiplied_base",
+                    Op::AddMultipliedTotal => "add_multiplied_total",
+                };
+                Tag::compound([
+                    ("id", string(x.id)),
+                    ("amount", Tag::Double(x.amount.to_bits())),
+                    ("operation", string(op)),
+                ])
+            })
+            .collect();
+        if modifiers.is_empty() && !a.bases.iter().any(|(b, _)| *b == attr) {
+            continue;
+        }
+        let id = format!("minecraft:{}", attr.name());
+        let mut entry = vec![
+            ("id", string(&id)),
+            ("base", Tag::Double(finalize::base_value(m, attr).to_bits())),
+        ];
+        if !modifiers.is_empty() {
+            entry.push(("modifiers", Tag::List(modifiers)));
+        }
+        let entry = Tag::compound(entry);
+        match list
+            .iter_mut()
+            .find(|t| text(t.get("id")).as_deref() == Some(id.as_str()))
+        {
+            Some(t) => *t = entry,
+            None => list.push(entry),
+        }
+    }
+    map.insert("attributes".into(), Tag::List(list));
+}
+/// `Brain.Packed`: the memories finalizeSpawn set, over the saved ones.
+pub fn put_brain(map: &mut Compound, m: &Mob, dimension: &str) {
+    if m.extra.memories.is_empty() {
+        return;
+    }
+    let mut memories = match map.get(&"Brain".into()).and_then(|b| b.get("memories")) {
+        Some(Tag::Compound(c)) => c.clone(),
+        _ => Compound::new(),
+    };
+    for &(name, value, ttl) in &m.extra.memories {
+        let value = match name {
+            "hunted_recently" => Tag::Byte(value as i8),
+            "home" => match m.extra.home {
+                Some(p) => Tag::compound([
+                    ("dimension", string(dimension)),
+                    ("pos", Tag::IntArray(p.to_vec())),
+                ]),
+                None => continue,
+            },
+            _ => Tag::Int(value as i32),
+        };
+        let mut memory = vec![("value", value)];
+        if ttl != i64::MAX {
+            memory.push(("ttl", Tag::Long(ttl)));
+        }
+        memories.insert(
+            format!("minecraft:{name}").as_str().into(),
+            Tag::compound(memory),
+        );
+    }
+    map.insert(
+        "Brain".into(),
+        Tag::compound([("memories", Tag::Compound(memories))]),
+    );
+}
 /// `CustomName`: a text component saved as a string or a `{text: ..}` compound.
 fn custom_name(tag: &Tag) -> Option<String> {
     match tag.get("CustomName")? {
@@ -633,6 +753,22 @@ pub fn name_text(tag: &Tag) -> Text {
         t => crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(t)),
     }
 }
+/// Mob.finalizeSpawn's follow range bonus in the saved attributes.
+pub(crate) fn spawn_bonus(tag: &Tag) -> Option<f64> {
+    let Some(Tag::List(attrs)) = tag.get("attributes") else {
+        return None;
+    };
+    let range = attrs
+        .iter()
+        .find(|a| text(a.get("id")).as_deref() == Some("minecraft:follow_range"))?;
+    let Some(Tag::List(modifiers)) = range.get("modifiers") else {
+        return None;
+    };
+    let bonus = modifiers
+        .iter()
+        .find(|x| text(x.get("id")).as_deref() == Some("minecraft:random_spawn_bonus"))?;
+    float(bonus.get("amount"))
+}
 pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -> Option<Mob> {
     let kind = types.get(&self::kind(tag)?)?.clone();
     let position = position(tag)?;
@@ -658,6 +794,11 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
             }
         }
     }
+    if let Some(bonus) = spawn_bonus(tag) {
+        use crate::mobs::finalize::{Attr, Op, add_modifier};
+        let id = "minecraft:random_spawn_bonus";
+        add_modifier(&mut m, Attr::FollowRange, id, bonus, Op::AddMultipliedBase);
+    }
     m.health = float(tag.get("Health")).map_or(m.attrs.max_health, |h| h as f32);
     m.hurt_time = number(tag.get("HurtTime")).unwrap_or(0) as i32;
     // What it holds (equipment.mainhand / offhand), when saved.
@@ -699,7 +840,8 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     m.extra.pick_up_loot = flag(tag, "CanPickUpLoot");
     m.custom_name = custom_name(tag);
     m.custom_name_text = tag.get("CustomName").map(name_text);
-    if m.kind.category == "creature" {
+    m.extra.left_handed = flag(tag, "LeftHanded");
+    if m.kind.category == "creature" || m.species() == crate::mobs::Species::Hoglin {
         m.extra.age = number(tag.get("Age")).unwrap_or(0) as i32;
         m.extra.forced_age = number(tag.get("ForcedAge")).unwrap_or(0) as i32;
         m.extra.age_locked = flag(tag, "AgeLocked");
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index f9edd98bb..bf7425027 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4709,6 +4709,7 @@ impl Game<'_> {
     /// What the tick runs after the local player's own update: effects, the
     /// world's entities and blocks, and the network hub.
     fn tick_world(&mut self, running: bool) -> Result<()> {
+        self.share_spawn_conditions();
         self.update_chunk_tickets();
         horizon_client::spans::time("tick_effects", || self.tick_effects(running));
         // Player.tick's ItemCooldowns.tick for the window's player (a
@@ -8134,6 +8135,7 @@ impl Game<'_> {
         );
         self.session_lock = Some(session_lock);
         self.end.set_locator(locator);
+        self.share_spawn_conditions();
         self.score = Default::default();
         self.fns = Default::default();
         self.bosses = Default::default();
@@ -8272,6 +8274,7 @@ impl Game<'_> {
             seed,
         )?;
         self.end.set_locator(locator);
+        self.share_spawn_conditions();
         Ok((streaming, save))
     }
     /// Change dimension through a portal (Entity.changeDimension with
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index f6961ab13..fa7c6e462 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -430,6 +430,12 @@ impl Game<'_> {
             ),
         }
     }
+    /// What the generator finalizes this level's structure mobs with.
+    pub(super) fn share_spawn_conditions(&self) {
+        if let Some(terrain) = self.end.locator() {
+            terrain.set_spawn_conditions(self.difficulty_id() as u8, self.world.day_time);
+        }
+    }
     /// `ServerLevel.getCurrentDifficultyAt`.
     pub(super) fn local_difficulty(&self, at: [f64; 3]) -> spawning::LocalDifficulty {
         use horizon_world::food::Difficulty;
diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs
index 29bf6d511..df4eaed88 100644
--- a/crates/horizon-client/src/game/levels.rs
+++ b/crates/horizon-client/src/game/levels.rs
@@ -192,6 +192,7 @@ impl Game<'_> {
         let mut locator = self.end.locator();
         swap(&mut locator, &mut p.locator);
         self.end.set_locator(locator);
+        self.share_spawn_conditions();
         swap(&mut self.save, &mut p.save);
         swap(&mut self.block_ticks, &mut p.block_ticks);
         swap(&mut self.tick_chunks, &mut p.tick_chunks);
diff --git a/crates/horizon-client/src/game/persist.rs b/crates/horizon-client/src/game/persist.rs
index b5e650e70..9e727d35d 100644
--- a/crates/horizon-client/src/game/persist.rs
+++ b/crates/horizon-client/src/game/persist.rs
@@ -357,7 +357,8 @@ impl Game<'_> {
     pub(super) fn load_mob(&mut self, tag: Tag, mount: Option<u32>) -> Option<u32> {
         self.next_entity += 1;
         let uuid = entity_nbt::uuid(&tag);
-        // Structure entities placed with finalizeEntities.
+        // Structure mobs that generation left to finish: saves from before
+        // they were finalized at placement, or a placement that could not.
         let mut tag = tag;
         let mut finalize = false;
         if let Tag::Compound(c) = &mut tag {
@@ -449,7 +450,8 @@ impl Game<'_> {
         }
     }
     /// An entity of a type Horizon does not simulate, kept as its compound.
-    fn load_other(&mut self, tag: Tag, kind: &str) -> Option<u32> {
+    fn load_other(&mut self, mut tag: Tag, kind: &str) -> Option<u32> {
+        strip_finalize(&mut tag);
         let position = entity_nbt::position(&tag)?;
         let rotation = match tag.get("Rotation") {
             Some(Tag::List(l)) => {
@@ -1014,3 +1016,9 @@ impl Game<'_> {
         self.save.save_entities(chunks)
     }
 }
+/// Only a mob is finalized; another entity drops the request.
+fn strip_finalize(tag: &mut Tag) {
+    if let Tag::Compound(c) = tag {
+        c.remove(&"horizon:finalize".into());
+    }
+}
diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs
index 743f02f44..da7c79394 100644
--- a/crates/horizon-client/src/game/raids.rs
+++ b/crates/horizon-client/src/game/raids.rs
@@ -235,7 +235,7 @@ impl Game<'_> {
         }
         out
     }
-    fn difficulty_id(&self) -> i32 {
+    pub(super) fn difficulty_id(&self) -> i32 {
         use horizon_world::food::Difficulty;
         match self.world.health_rules.difficulty {
             Difficulty::Peaceful => 0,
diff --git a/crates/horizon-client/src/vanillagen.rs b/crates/horizon-client/src/vanillagen.rs
index 923818a08..76179573e 100644
--- a/crates/horizon-client/src/vanillagen.rs
+++ b/crates/horizon-client/src/vanillagen.rs
@@ -24,7 +24,9 @@ use horizon_world::{
 };
 use std::{path::Path, sync::Arc};
 mod lod;
+mod structure_mobs;
 use lod::VanillaLodSampler;
+use structure_mobs::StructureMobFinalizer;
 
 pub struct VanillaTerrain {
     generator: OverworldGenerator,
@@ -32,6 +34,7 @@ pub struct VanillaTerrain {
     biome_map: Vec<u16>,
     /// Loot tables for generated containers.
     loot: Option<Arc<horizon_world::loot::LootData>>,
+    structure_mobs: Arc<StructureMobFinalizer>,
     /// A worker for structure queries from the game thread.
     query: std::sync::Mutex<Option<GeneratorWorker>>,
     /// Block state id -> block index, the game's block tick type: worldgen
@@ -138,6 +141,10 @@ impl VanillaTerrain {
             generator,
             biome_map,
             loot,
+            structure_mobs: Arc::new(StructureMobFinalizer::new(
+                dir.parent().unwrap_or(dir).to_owned(),
+                dimension,
+            )),
             query: std::sync::Mutex::new(None),
             tick_blocks,
             tick_states,
@@ -147,6 +154,11 @@ impl VanillaTerrain {
             created: std::time::Instant::now(),
         })
     }
+    /// The difficulty (0 peaceful to 3 hard) and overworld clock structure
+    /// mobs are finalized with.
+    pub fn set_spawn_conditions(&self, difficulty: u8, day_time: i64) {
+        self.structure_mobs.set_conditions(difficulty, day_time);
+    }
     /// A proto chunk's blocks, biomes, scheduled ticks and post-processing
     /// marks as a column.
     fn column(&self, chunk: &ProtoChunk) -> Chunk {
@@ -354,7 +366,9 @@ pub fn shared_data(
 impl ChunkGenerator for VanillaTerrain {
     type Worker = GeneratorWorker;
     fn worker(&self) -> GeneratorWorker {
-        self.generator.worker()
+        let mut worker = self.generator.worker();
+        worker.set_structure_mobs(self.structure_mobs.clone());
+        worker
     }
     fn lod_sampler(self: Arc<Self>) -> Box<dyn LodSampler> {
         Box::new(VanillaLodSampler::new(self))
diff --git a/crates/horizon-client/src/vanillagen/structure_mobs.rs b/crates/horizon-client/src/vanillagen/structure_mobs.rs
new file mode 100644
index 000000000..dec5aa92b
--- /dev/null
+++ b/crates/horizon-client/src/vanillagen/structure_mobs.rs
@@ -0,0 +1,446 @@
+//! `Mob.finalizeSpawn(level, level.getCurrentDifficultyAt(pos), STRUCTURE, null)`
+//! of the mobs structures place (StructureTemplate.placeEntities with
+//! finalizeEntities, ocean ruin drowned, mansion illagers, witch huts,
+//! monuments), run as decoration places them, with the WorldGenRegion's random.
+use crate::{
+    enchant::Enchantments,
+    entity_nbt,
+    items::Items,
+    mobs::{
+        Mob, MobType, MobTypes,
+        finalize::{self, Ctx, FinalizeLevel, Reason, SpawnData, SpawnRegistries},
+        spawning::{LocalDifficulty, MOON_BRIGHTNESS},
+    },
+};
+use chrono::Datelike;
+use horizon_core::{
+    geometry::{Aabb, Vec3},
+    random::{LegacyRandom, RandomSource, XoroshiroRandom},
+};
+use horizon_world::{
+    nbt::{Compound, Tag},
+    worldgen::{generator::StructureMobs, structure::legacy::PieceRandom},
+};
+use std::{
+    collections::{HashMap, HashSet},
+    path::PathBuf,
+    sync::{
+        Arc, OnceLock,
+        atomic::{AtomicI64, AtomicU8, Ordering},
+    },
+};
+
+struct Data {
+    types: HashMap<String, Arc<MobType>>,
+    biome_tags: HashMap<String, HashSet<String>>,
+    registries: SpawnRegistries,
+    enchantments: Enchantments,
+    items: Items,
+    camel_husk: (f32, f32),
+}
+fn load(root: &std::path::Path) -> Option<Data> {
+    let types = MobTypes::load(root).ok()?.types;
+    let camel = types.get("minecraft:camel_husk")?;
+    let camel_husk = (camel.width as f32, camel.height as f32);
+    Some(Data {
+        types: types.into_iter().map(|(k, t)| (k, Arc::new(t))).collect(),
+        biome_tags: crate::items::load_tags(root, "worldgen/biome").unwrap_or_default(),
+        registries: SpawnRegistries::load(root),
+        enchantments: Enchantments::load(root),
+        items: Items::tags_only(root).ok()?,
+        camel_husk,
+    })
+}
+
+pub struct StructureMobFinalizer {
+    root: PathBuf,
+    dimension: String,
+    data: OnceLock<Option<Data>>,
+    /// The level's difficulty (0 peaceful to 3 hard) and overworld clock.
+    difficulty: AtomicU8,
+    day_time: AtomicI64,
+}
+impl StructureMobFinalizer {
+    pub fn new(root: PathBuf, dimension: &str) -> Self {
+        Self {
+            root,
+            dimension: dimension.to_owned(),
+            data: OnceLock::new(),
+            difficulty: AtomicU8::new(2),
+            day_time: AtomicI64::new(0),
+        }
+    }
+    pub fn set_conditions(&self, difficulty: u8, day_time: i64) {
+        self.difficulty.store(difficulty, Ordering::Relaxed);
+        self.day_time.store(day_time, Ordering::Relaxed);
+    }
+}
+
+struct Level<'a> {
+    data: &'a Data,
+    biome: &'a str,
+    structures: &'a [String],
+    difficulty: u8,
+    day_time: i64,
+    next_id: u32,
+}
+impl FinalizeLevel for Level<'_> {
+    fn biome(&self, _: [i32; 3]) -> String {
+        self.biome.to_owned()
+    }
+    fn biome_tag(&self, tag: &str, _: [i32; 3]) -> bool {
+        self.data
+            .biome_tags
+            .get(tag)
+            .is_some_and(|b| b.contains(self.biome))
+    }
+    fn structures_with_piece_at(&self, _: [i32; 3]) -> Vec<String> {
+        self.structures.to_vec()
+    }
+    fn moon_phase(&self, _: [i32; 3]) -> usize {
+        self.day_time.div_euclid(24000).rem_euclid(8) as usize
+    }
+    fn spawning_monsters(&self) -> bool {
+        self.difficulty != 0
+    }
+    // No block collision: only a husk's camel asks, and no structure places husks.
+    fn no_collision(&self, _: Aabb) -> bool {
+        true
+    }
+    // WorldGenRegion holds no entities.
+    fn free_chicken(&self, _: Aabb) -> Option<u32> {
+        None
+    }
+    fn ride_chicken(&mut self, _: u32, _: u32) {}
+    fn game_time(&self) -> i64 {
+        self.day_time
+    }
+    fn halloween(&self) -> bool {
+        let today = chrono::Local::now();
+        (today.month(), today.day()) == (10, 31)
+    }
+    fn create(&mut self, kind: &str, _: Reason) -> Option<Mob> {
+        if self.difficulty == 0 && !finalize::allowed_in_peaceful(kind) {
+            return None;
+        }
+        let t = self.data.types.get(kind)?.clone();
+        self.next_id += 1;
+        Some(Mob::new(self.next_id, t, Vec3::ZERO, 0.0))
+    }
+}
+
+fn run<R: RandomSource>(
+    level: &mut Level<'_>,
+    random: &mut R,
+    difficulty: LocalDifficulty,
+    data: &SpawnData<'_>,
+    m: &mut Mob,
+) -> Vec<Mob> {
+    let mut cx = Ctx {
+        level,
+        random,
+        difficulty,
+        data,
+        created: Vec::new(),
+    };
+    cx.finalize(m, Reason::Structure, None);
+    cx.created
+}
+
+/// The saved compound of mob `i` with the mobs riding it under `Passengers`.
+fn tree(mobs: &[(Mob, Option<Tag>)], i: usize, dimension: &str) -> Compound {
+    let (m, raw) = &mobs[i];
+    let Tag::Compound(mut c) = entity_nbt::mob_to_nbt(m, [0; 4], raw.as_ref()) else {
+        return Compound::new();
+    };
+    c.remove(&"UUID".into());
+    entity_nbt::put_brain(&mut c, m, dimension);
+    let riders: Vec<Tag> = (0..mobs.len())
+        .filter(|&j| mobs[j].0.extra.mount == Some(m.id))
+        .map(|j| Tag::Compound(tree(mobs, j, dimension)))
+        .collect();
+    if !riders.is_empty() {
+        c.insert("Passengers".into(), Tag::List(riders));
+    }
+    c
+}
+
+impl StructureMobs for StructureMobFinalizer {
+    fn finalize(
+        &self,
+        nbt: &mut Compound,
+        biome: &str,
+        structures: &[String],
+        random: &mut dyn PieceRandom,
+    ) -> bool {
+        let Some(data) = self.data.get_or_init(|| {
+            let data = load(&self.root);
+            if data.is_none() {
+                log::error!("Horizon: no mob data, structure mobs are finalized when loaded");
+            }
+            data
+        }) else {
+            return false;
+        };
+        let mut raw = Tag::Compound(nbt.clone());
+        if let Tag::Compound(c) = &mut raw {
+            c.remove(&"horizon:finalize".into());
+        }
+        let Some(mut m) = entity_nbt::mob_from_nbt(&raw, &data.types, 1) else {
+            // Not a mob: vanilla finalizes only Mob instances.
+            return true;
+        };
+        let base = self.difficulty.load(Ordering::Relaxed);
+        let day_time = self.day_time.load(Ordering::Relaxed);
+        let mut level = Level {
+            data,
+            biome,
+            structures,
+            difficulty: base,
+            day_time,
+            next_id: 1,
+        };
+        let moon = MOON_BRIGHTNESS[level.moon_phase([0; 3])];
+        // WorldGenRegion.getCurrentDifficultyAt: no inhabited time.
+        let difficulty = LocalDifficulty::new(base, day_time, 0, moon);
+        let spawn = SpawnData {
+            registries: &data.registries,
+            enchantments: &data.enchantments,
+            items: &data.items,
+            camel_husk_size: data.camel_husk,
+        };
+        let any = random.as_any();
+        let created = if let Some(r) = any.downcast_mut::<LegacyRandom>() {
+            run(&mut level, r, difficulty, &spawn, &mut m)
+        } else if let Some(r) = any.downcast_mut::<XoroshiroRandom>() {
+            run(&mut level, r, difficulty, &spawn, &mut m)
+        } else {
+            log::error!("Horizon: unknown region random, structure mobs are finalized when loaded");
+            return false;
+        };
+        let mut mobs = vec![(m, Some(raw))];
+        mobs.extend(created.into_iter().map(|c| (c, None)));
+        let root = mobs
+            .iter()
+            .position(|(m, _)| m.extra.mount.is_none())
+            .unwrap_or(0);
+        *nbt = tree(&mobs, root, &self.dimension);
+        true
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The bastion's crossbow piglin keeps its crossbow (STRUCTURE skips
+    /// createSpawnWeapon) and saves what Piglin.addAdditionalSaveData writes.
+    #[test]
+    fn bastion_crossbow_piglin_finalizes_as_structure() {
+        let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES").map(PathBuf::from) else {
+            return;
+        };
+        let file = root.join("worldgen/structure/minecraft/bastion/mobs/crossbow_piglin.nbt");
+        let mut bytes = Vec::new();
+        std::io::Read::read_to_end(
+            &mut flate2::read::GzDecoder::new(std::fs::File::open(file).unwrap()),
+            &mut bytes,
+        )
+        .unwrap();
+        let limits = horizon_world::nbt::Limits::templates();
+        let template = horizon_world::nbt::read_named(&bytes, limits)
+            .unwrap()
+            .0
+            .tag;
+        let Some(Tag::List(entities)) = template.get("entities") else {
+            panic!("no entities");
+        };
+        let Some(Tag::Compound(mut nbt)) = entities[0].get("nbt").cloned() else {
+            panic!("no nbt");
+        };
+        nbt.remove(&"UUID".into());
+        let hook = StructureMobFinalizer::new(root, "minecraft:the_nether");
+        let mut random = LegacyRandom::new(12345);
+        hook.finalize(&mut nbt, "minecraft:nether_wastes", &[], &mut random);
+        let keys: Vec<String> = {
+            let mut k: Vec<String> = nbt.keys().map(|k| k.to_string_lossy()).collect();
+            k.sort();
+            k
+        };
+        assert_eq!(
+            keys,
+            [
+                "AbsorptionAmount",
+                "Air",
+                "Brain",
+                "CanPickUpLoot",
+                "CannotHunt",
+                "DeathTime",
+                "FallFlying",
+                "Fire",
+                "Health",
+                "HurtTime",
+                "Inventory",
+                "Invulnerable",
+                "IsBaby",
+                "IsImmuneToZombification",
+                "LeftHanded",
+                "Motion",
+                "OnGround",
+                "PersistenceRequired",
+                "PortalCooldown",
+                "Pos",
+                "Rotation",
+                "TimeInOverworld",
+                "attributes",
+                "current_impulse_context_reset_grace_time",
+                "equipment",
+                "fall_distance",
+                "id",
+            ]
+        );
+        let tag = Tag::Compound(nbt);
+        let held = tag.get("equipment").and_then(|e| e.get("mainhand"));
+        assert!(
+            matches!(held.and_then(|h| h.get("id")), Some(Tag::String(s)) if s.to_string_lossy() == "minecraft:crossbow")
+        );
+        let hunted = tag
+            .get("Brain")
+            .and_then(|b| b.get("memories"))
+            .and_then(|m| m.get("minecraft:hunted_recently"));
+        assert!(matches!(
+            hunted.and_then(|h| h.get("ttl")),
+            Some(Tag::Long(600..=2400))
+        ));
+        let Some(Tag::List(attributes)) = tag.get("attributes") else {
+            panic!("no attributes");
+        };
+        assert!(attributes.iter().any(|a| {
+            matches!(a.get("id"), Some(Tag::String(s)) if s.to_string_lossy() == "minecraft:follow_range")
+                && matches!(a.get("modifiers"), Some(Tag::List(m)) if m.len() == 1)
+        }));
+    }
+
+    fn id(t: Option<&Tag>) -> String {
+        match t.and_then(|t| t.get("id")) {
+            Some(Tag::String(s)) => s.to_string_lossy().trim_start_matches("minecraft:").into(),
+            _ => "-".into(),
+        }
+    }
+    /// What a vanilla world saves of a structure mob that finalizeSpawn decides.
+    fn describe(mob: &Tag) -> String {
+        let eq = mob.get("equipment");
+        let gear: Vec<String> = ["mainhand", "head", "chest", "legs", "feet"]
+            .iter()
+            .map(|slot| id(eq.and_then(|e| e.get(slot))))
+            .collect();
+        let ttl = match mob
+            .get("Brain")
+            .and_then(|b| b.get("memories"))
+            .and_then(|m| m.get("minecraft:hunted_recently"))
+            .and_then(|h| h.get("ttl"))
+        {
+            Some(Tag::Long(t)) => t.to_string(),
+            _ => "-".into(),
+        };
+        let bonus = crate::entity_nbt::spawn_bonus(mob).unwrap_or(f64::NAN);
+        let flag = |k: &str| matches!(mob.get(k), Some(Tag::Byte(1)));
+        let riders = match mob.get("Passengers") {
+            Some(Tag::List(p)) => format!(
+                " [{}]",
+                p.iter().map(describe).collect::<Vec<_>>().join("; ")
+            ),
+            _ => String::new(),
+        };
+        format!(
+            "{} {} ttl={ttl} bonus={bonus:.6} left={} baby={}{riders}",
+            id(Some(mob)),
+            gear.join(","),
+            flag("LeftHanded"),
+            flag("IsBaby") || matches!(mob.get("Age"), Some(Tag::Int(a)) if *a < 0),
+        )
+    }
+    /// The described entities of chunk (x, z) after decorating the 3x3 around it.
+    fn chunk_mobs(
+        root: &std::path::Path,
+        seed: i64,
+        dimension: &str,
+        x: i32,
+        z: i32,
+    ) -> Vec<String> {
+        use crate::streaming::{ChunkGenerator, Proto};
+        let assets = crate::assets::Assets::load(root).unwrap();
+        let biomes = crate::biome::Biomes::load(root).unwrap();
+        let terrain = super::super::VanillaTerrain::for_dimension(
+            &root.join("worldgen"),
+            assets.registry,
+            &biomes,
+            seed,
+            dimension,
+        )
+        .unwrap();
+        let mut worker = terrain.worker();
+        let mut region: [Proto; 9] = std::array::from_fn(|i| {
+            terrain.proto(&mut worker, x + i as i32 % 3 - 1, z + i as i32 / 3 - 1)
+        });
+        terrain.decorate(&mut worker, &mut region);
+        let center = std::mem::replace(&mut region[4], Box::new(()));
+        let mut got: Vec<String> = terrain
+            .finish(center)
+            .entities
+            .iter()
+            .map(describe)
+            .collect();
+        got.sort();
+        got
+    }
+    /// Seed 12345's bastion at chunk (-21, 8): the mobs of chunk (-23, 8) as two
+    /// vanilla 26.3 runs saved them (weapons and armour, hunting memory, follow
+    /// range bonus, handedness), from the region random of that chunk. The
+    /// memories are as placed: vanilla saved them 13 brain ticks later.
+    #[test]
+    fn bastion_chunk_mobs_match_vanilla() {
+        let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES").map(PathBuf::from) else {
+            return;
+        };
+        let got = chunk_mobs(&root, 12345, "minecraft:the_nether", -23, 8);
+        let mut expected = [
+            "piglin golden_sword,-,golden_chestplate,-,- ttl=1760 bonus=0.013784",
+            "piglin crossbow,-,-,-,- ttl=806 bonus=-0.011458",
+            "piglin golden_sword,-,-,-,- ttl=1315 bonus=-0.084585",
+            "piglin golden_sword,-,-,-,- ttl=1489 bonus=-0.038292",
+            "piglin_brute golden_axe,-,-,-,- ttl=- bonus=-0.020574",
+            "piglin crossbow,-,-,-,- ttl=1620 bonus=-0.079135",
+            "hoglin -,-,-,-,- ttl=- bonus=-0.012052",
+            "piglin golden_sword,-,-,-,- ttl=783 bonus=-0.077071",
+            "piglin crossbow,-,-,golden_leggings,- ttl=1431 bonus=0.007058",
+        ]
+        .map(|e| format!("{e} left=false baby=false"));
+        expected.sort();
+        assert_eq!(got, expected);
+    }
+
+    /// Seed 12345's ocean ruin at (53, 39, 424): Drowned.finalizeSpawn mounts the
+    /// trident drowned on a zombie nautilus, as vanilla saved chunk (3, 26).
+    #[test]
+    fn ocean_ruin_drowned_match_vanilla() {
+        let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES").map(PathBuf::from) else {
+            return;
+        };
+        let got = chunk_mobs(&root, 12345, "minecraft:overworld", 3, 26);
+        let d = |gear: &str, bonus: &str| {
+            format!("drowned {gear},-,-,-,- ttl=- bonus={bonus} left=false baby=false")
+        };
+        let mut expected = vec![
+            d("-", "0.001996"),
+            format!(
+                "zombie_nautilus -,-,-,-,- ttl=- bonus=-0.044983 left=false baby=false [{}]",
+                d("trident", "-0.045604")
+            ),
+            d("fishing_rod", "-0.059079"),
+            d("-", "0.021658"),
+        ];
+        expected.sort();
+        assert_eq!(got, expected);
+    }
+}
diff --git a/crates/horizon-world/src/worldgen/generator.rs b/crates/horizon-world/src/worldgen/generator.rs
index 7a38608be..3bf0e86b3 100644
--- a/crates/horizon-world/src/worldgen/generator.rs
+++ b/crates/horizon-world/src/worldgen/generator.rs
@@ -1648,6 +1648,22 @@ pub(super) struct WorkerState {
     heights: HashMap<(i32, i32, u8), i32>,
     /// Decorate with structure pieces only (for structure parity checks).
     pub(super) structures_only: bool,
+    pub(super) structure_mobs: Option<Arc<dyn StructureMobs>>,
+}
+/// `Mob.finalizeSpawn(level, difficulty, STRUCTURE, null)` of the entities a
+/// structure places with finalizeEntities, run by the game, which owns mobs.
+pub trait StructureMobs: Send + Sync {
+    /// Finalizes the entity in `nbt` if it is a mob, drawing from the
+    /// region's random. `biome` is the biome at its block, `structures` the
+    /// structures with a piece there. False when it could not: the entity
+    /// keeps its `horizon:finalize` for the game to finish on load.
+    fn finalize(
+        &self,
+        nbt: &mut crate::nbt::Compound,
+        biome: &str,
+        structures: &[String],
+        random: &mut dyn super::structure::legacy::PieceRandom,
+    ) -> bool;
 }
 
 trait SeededPipeline: Send + Sync {
@@ -2464,6 +2480,7 @@ impl OverworldGenerator {
                 carver_biomes: HashMap::new(),
                 timings: StageTimings::default(),
                 structures_only: false,
+                structure_mobs: None,
                 heights: HashMap::new(),
             },
         }
@@ -2590,6 +2607,9 @@ impl GeneratorWorker {
     pub fn set_structures_only(&mut self, only: bool) {
         self.state.structures_only = only;
     }
+    pub fn set_structure_mobs(&mut self, mobs: Arc<dyn StructureMobs>) {
+        self.state.structure_mobs = Some(mobs);
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/horizon-world/src/worldgen/generator_decoration.rs b/crates/horizon-world/src/worldgen/generator_decoration.rs
index fc1cd8bcf..08611a325 100644
--- a/crates/horizon-world/src/worldgen/generator_decoration.rs
+++ b/crates/horizon-world/src/worldgen/generator_decoration.rs
@@ -310,6 +310,7 @@ impl Decoration {
             Err(e) => return Err(resource(e.to_string())),
         };
         let structures_only = worker.structures_only;
+        let references = region[4].structure_starts.clone();
         let mut block_entities = Vec::new();
         for chunk in region.iter_mut() {
             block_entities.append(&mut chunk.block_entities);
@@ -318,6 +319,9 @@ impl Decoration {
             block_entities,
             entities: Vec::new(),
             level_random,
+            structure_mobs: worker.structure_mobs.clone(),
+            starts: references.clone(),
+            biome_names: data.biome_names(),
             blocks: data
                 .feature_resources
                 .as_ref()
@@ -334,7 +338,6 @@ impl Decoration {
         };
         let mut stats = DecorateStats::default();
         let blocks = self.blocks;
-        let references = region[4].structure_starts.clone();
         // ChunkGenerator.getWritableArea: the chunk's minimum Y + 1 to its maximum Y.
         let chunk_box = BoundingBox::new(
             [center.x * 16, min_y + 1, center.z * 16],
@@ -419,15 +422,11 @@ impl Decoration {
         }
         // WorldGenRegion.addFreshEntity: into the chunk holding the position.
         for nbt in std::mem::take(&mut world.entities) {
-            let Some(crate::nbt::Tag::List(p)) = nbt.get(&"Pos".into()) else {
+            let Some(at) = block_of(&nbt) else {
                 continue;
             };
-            let coord = |i: usize| match p.get(i) {
-                Some(crate::nbt::Tag::Double(b)) => f64::from_bits(*b).floor() as i32,
-                _ => 0,
-            };
-            let index = ((coord(2) >> 4).wrapping_sub(center.z) + 1) * 3
-                + (coord(0) >> 4).wrapping_sub(center.x)
+            let index = ((at[2] >> 4).wrapping_sub(center.z) + 1) * 3
+                + (at[0] >> 4).wrapping_sub(center.x)
                 + 1;
             if let Some(chunk) = usize::try_from(index).ok().and_then(|i| region.get_mut(i)) {
                 chunk.entities.push(nbt);
@@ -454,6 +453,9 @@ struct World<'a> {
     block_entities: Vec<([i32; 3], crate::nbt::Compound)>,
     entities: Vec<crate::nbt::Compound>,
     level_random: &'a mut dyn super::structure::legacy::PieceRandom,
+    structure_mobs: Option<Arc<dyn super::generator::StructureMobs>>,
+    starts: Vec<Arc<super::structure::start::StructureStart>>,
+    biome_names: &'a [Arc<str>],
     blocks: Option<&'a BlockBehavior>,
     region: TerrainRegion<'static, GenBlockStates>,
     biomes: BiomeRegion<BiomeId>,
@@ -847,7 +849,27 @@ impl PlacementContext for World<'_> {
                 (0..ny).all(|y| (0..nz).all(|z| shape.is_full(x as i32, y as i32, z as i32)))
             }))
     }
-    fn add_entity(&mut self, nbt: crate::nbt::Compound) -> Result<(), PlacementQueryError> {
+    fn add_entity(&mut self, mut nbt: crate::nbt::Compound) -> Result<(), PlacementQueryError> {
+        if let Some(mobs) = self.structure_mobs.clone()
+            && nbt.contains_key(&"horizon:finalize".into())
+        {
+            let at = block_of(&nbt).unwrap_or([0; 3]);
+            let biome = self
+                .biome_identity(at)
+                .ok()
+                .and_then(|b| self.biome_names.get(b.0 as usize))
+                .map_or("", |n| &**n)
+                .to_owned();
+            let structures: Vec<String> = self
+                .starts
+                .iter()
+                .filter(|s| s.pieces.iter().any(|p| p.bounding_box().is_inside(at)))
+                .map(|s| s.name.clone())
+                .collect();
+            if mobs.finalize(&mut nbt, &biome, &structures, self.level_random) {
+                nbt.remove(&"horizon:finalize".into());
+            }
+        }
         self.entities.push(nbt);
         Ok(())
     }
@@ -1167,3 +1189,14 @@ impl PlacementContext for World<'_> {
         Ok(Some(false))
     }
 }
+
+/// The block an entity's `Pos` is in.
+fn block_of(nbt: &crate::nbt::Compound) -> Option<[i32; 3]> {
+    let Some(crate::nbt::Tag::List(p)) = nbt.get(&"Pos".into()) else {
+        return None;
+    };
+    Some(std::array::from_fn(|i| match p.get(i) {
+        Some(crate::nbt::Tag::Double(b)) => f64::from_bits(*b).floor() as i32,
+        _ => 0,
+    }))
+}
diff --git a/crates/horizon-world/src/worldgen/structure/legacy.rs b/crates/horizon-world/src/worldgen/structure/legacy.rs
index 785b5fb2e..19d121718 100644
--- a/crates/horizon-world/src/worldgen/structure/legacy.rs
+++ b/crates/horizon-world/src/worldgen/structure/legacy.rs
@@ -31,14 +31,19 @@ pub type Markers = Vec<(String, [i32; 3])>;
 pub trait PieceRandom: ProcessorRandom {
     fn boolean(&mut self) -> bool;
     fn double(&mut self) -> f64;
+    /// The concrete random, for callers that need all of `RandomSource`.
+    fn as_any(&mut self) -> &mut dyn std::any::Any;
 }
-impl<R: RandomSource> PieceRandom for R {
+impl<R: RandomSource + 'static> PieceRandom for R {
     fn boolean(&mut self) -> bool {
         self.next_boolean()
     }
     fn double(&mut self) -> f64 {
         self.next_double()
     }
+    fn as_any(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
 }
 
 /// Object-safe world access for piece post-processing.

From 8a5d7bb78d35b6974b97f5487f7d51b047b8ab71 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 23:12:44 +0100
Subject: [PATCH 350/475] Leave the extended Arabic letters unshaped, as ICU
 does

---
 crates/horizon-client/src/bidi.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/crates/horizon-client/src/bidi.rs b/crates/horizon-client/src/bidi.rs
index c07b69c6d..98924027c 100644
--- a/crates/horizon-client/src/bidi.rs
+++ b/crates/horizon-client/src/bidi.rs
@@ -60,6 +60,8 @@ const JOINS: &[(u32, u32, Join)] = &[
 /// Letters that have joined forms and the code point of the isolated one; the
 /// final, initial and medial forms follow it (a right-joining letter has the
 /// isolated and final only). The lam-alef ligatures are their own letters.
+/// ICU leaves the extended letters (پ چ ژ ک گ ی and the rest of U+0679 to
+/// U+06D3) unchanged, so they are in `JOINS` but not here.
 #[rustfmt::skip]
 const FORMS: &[(u32, u32)] = &[
     (0x0622, 0xFE81), (0x0623, 0xFE83), (0x0624, 0xFE85), (0x0625, 0xFE87), (0x0626, 0xFE89),
@@ -69,12 +71,6 @@ const FORMS: &[(u32, u32)] = &[
     (0x0636, 0xFEBD), (0x0637, 0xFEC1), (0x0638, 0xFEC5), (0x0639, 0xFEC9), (0x063A, 0xFECD),
     (0x0641, 0xFED1), (0x0642, 0xFED5), (0x0643, 0xFED9), (0x0644, 0xFEDD), (0x0645, 0xFEE1),
     (0x0646, 0xFEE5), (0x0647, 0xFEE9), (0x0648, 0xFEED), (0x0649, 0xFEEF), (0x064A, 0xFEF1),
-    (0x0679, 0xFB66), (0x067A, 0xFB5E), (0x067B, 0xFB52), (0x067E, 0xFB56), (0x0686, 0xFB7A),
-    (0x0688, 0xFB88), (0x068C, 0xFB84), (0x068D, 0xFB82), (0x068E, 0xFB86), (0x0691, 0xFB8C),
-    (0x0698, 0xFB8A), (0x06A9, 0xFB8E), (0x06AF, 0xFB92), (0x06BA, 0xFB9E), (0x06BB, 0xFBA0),
-    (0x06BE, 0xFBAA), (0x06C0, 0xFBA4), (0x06C1, 0xFBA6), (0x06C5, 0xFBE0), (0x06C6, 0xFBD9),
-    (0x06C7, 0xFBD7), (0x06C8, 0xFBDB), (0x06C9, 0xFBE2), (0x06CB, 0xFBDE), (0x06CC, 0xFBFC),
-    (0x06D0, 0xFBE4), (0x06D2, 0xFBAE), (0x06D3, 0xFBB0), (0xFEF5, 0xFEF5), (0xFEF7, 0xFEF7),
     (0xFEF9, 0xFEF9), (0xFEFB, 0xFEFB),
 ];
 
@@ -102,7 +98,7 @@ fn join(c: char) -> Join {
 /// The letter whose joined form `c` is (ICU shapes the forms again), or `c`.
 fn letter_of(c: char) -> char {
     let c32 = c as u32;
-    if !matches!(c32, 0xFB50..=0xFDFF | 0xFE70..=0xFEFC) {
+    if !matches!(c32, 0xFE70..=0xFEFC) {
         return c;
     }
     if (0xFE70..0xFE80).contains(&c32) {

From 4cad82b4a9cc6e25cce236866c389a5a45594933 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 23:14:31 +0100
Subject: [PATCH 351/475] Draw the variant of rabbits, parrots and axolotls,
 salmon sizes and the baby goat, polar bear, ocelot, turtle and armadillo

RabbitRenderer, ParrotRenderer, AxolotlRenderer and SalmonRenderer pick
their texture or model from the variant the mob already carries, and the
baby models and textures of the other AgeableMobRenderer species are used.
A baby zombie villager uses its own texture.
---
 crates/horizon-client/src/mobs/render.rs | 69 ++++++++++++++++++++++--
 1 file changed, 66 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs
index 077fd38a6..6f39686a3 100644
--- a/crates/horizon-client/src/mobs/render.rs
+++ b/crates/horizon-client/src/mobs/render.rs
@@ -177,8 +177,71 @@ pub fn body(m: &Mob) -> (String, String) {
             "frog#main".into(),
             format!("entity/frog/frog_{}", climate(m)),
         ),
-        S::Rabbit => (
-            baby_or(m, "rabbit#main", "rabbit_baby#main"),
+        // RabbitRenderer.getTextureLocation: the Toast name tag, else the
+        // variant (the killer bunny's id is 99).
+        S::Rabbit => {
+            let name = if m.custom_name.as_deref() == Some("Toast") {
+                "toast"
+            } else {
+                match m.extra.variant {
+                    1 => "white",
+                    2 => "black",
+                    3 => "white_splotched",
+                    4 => "gold",
+                    5 => "salt",
+                    99 => "caerbannog",
+                    _ => "brown",
+                }
+            };
+            (
+                baby_or(m, "rabbit#main", "rabbit_baby#main"),
+                b(&format!("entity/rabbit/rabbit_{name}")),
+            )
+        }
+        // ParrotRenderer.getVariantTexture.
+        S::Parrot => {
+            let name = ["red_blue", "blue", "green", "yellow_blue", "grey"]
+                [usize::from(m.extra.variant).min(4)];
+            (m.kind.model_key(), format!("entity/parrot/parrot_{name}"))
+        }
+        // AxolotlRenderer.getTextureLocation.
+        S::Axolotl => {
+            let name =
+                ["lucy", "wild", "gold", "cyan", "blue"][usize::from(m.extra.variant).min(4)];
+            (
+                baby_or(m, "axolotl#main", "axolotl_baby#main"),
+                b(&format!("entity/axolotl/axolotl_{name}")),
+            )
+        }
+        // SalmonRenderer.submit: the model of the salmon's size.
+        S::Salmon => {
+            let model = match m.extra.variant {
+                0 => "salmon_small#main",
+                2 => "salmon_large#main",
+                _ => "salmon#main",
+            };
+            (model.into(), "entity/fish/salmon".into())
+        }
+        // The baby models and textures of AgeableMobRenderer's other
+        // subclasses.
+        S::Goat => (
+            baby_or(m, "goat#main", "goat_baby#main"),
+            b(&m.kind.texture),
+        ),
+        S::PolarBear => (
+            baby_or(m, "polar_bear#main", "polar_bear_baby#main"),
+            b(&m.kind.texture),
+        ),
+        S::Ocelot => (
+            baby_or(m, "ocelot#main", "ocelot_baby#main"),
+            b(&m.kind.texture),
+        ),
+        S::Turtle => (
+            baby_or(m, "turtle#main", "turtle_baby#main"),
+            b(&m.kind.texture),
+        ),
+        S::Armadillo => (
+            baby_or(m, "armadillo#main", "armadillo_baby#main"),
             b(&m.kind.texture),
         ),
         S::Pig => {
@@ -241,7 +304,7 @@ pub fn body(m: &Mob) -> (String, String) {
         ),
         S::ZombieVillager => (
             baby_or(m, "zombie_villager#main", "zombie_villager_baby#main"),
-            "entity/zombie_villager/zombie_villager".into(),
+            b("entity/zombie_villager/zombie_villager"),
         ),
         S::Villager => (
             baby_or(m, "villager#main", "villager_baby#main"),

From 0d496fdc8fc820d5f299102c57c4c17c8bd5da1a Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 23:14:31 +0100
Subject: [PATCH 352/475] Save and load the variant of axolotls, rabbits,
 parrots, salmon and tropical fish

---
 crates/horizon-client/src/entity_nbt.rs | 67 ++++++++++++++++++++++++-
 1 file changed, 66 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 161ca12e9..1b5b8311f 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -403,7 +403,36 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             crate::mobs::villager::write_nbt(m, map);
         }
         "minecraft:wandering_trader" => put_offers(map, m),
-        "minecraft:axolotl" => write_axolotl_memories(m, map),
+        "minecraft:axolotl" => {
+            write_axolotl_memories(m, map);
+            map.insert(
+                "Variant".into(),
+                Tag::Int(i32::from(m.extra.variant.min(4))),
+            );
+        }
+        // Rabbit.addAdditionalSaveData (the legacy id; 99 is the killer bunny).
+        "minecraft:rabbit" => {
+            map.insert("RabbitType".into(), Tag::Int(i32::from(m.extra.variant)));
+        }
+        "minecraft:parrot" => {
+            map.insert(
+                "Variant".into(),
+                Tag::Int(i32::from(m.extra.variant.min(4))),
+            );
+        }
+        "minecraft:salmon" => {
+            let size = SALMON_SIZES[usize::from(m.extra.variant).min(2)];
+            map.insert("type".into(), string(size));
+        }
+        // TropicalFish.addAdditionalSaveData: the packed variant.
+        "minecraft:tropical_fish" => {
+            let pattern = m.extra.variant.min(11);
+            let packed = i32::from(pattern >= 6)
+                | i32::from(pattern % 6) << 8
+                | i32::from(m.extra.variant2 & 15) << 16
+                | i32::from(m.extra.variant3 & 15) << 24;
+            map.insert("Variant".into(), Tag::Int(packed));
+        }
         "minecraft:allay" => {
             // InventoryCarrier: the fetched stack; the liked player memory.
             let mut inv = Vec::new();
@@ -843,6 +872,7 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     if m.species() == crate::mobs::Species::Axolotl {
         restore_axolotl_memories(&mut m, tag);
     }
+    read_variant(&mut m, tag);
     m.fire_ticks = number(tag.get("Fire")).unwrap_or(0) as i32;
     m.air = number(tag.get("Air")).unwrap_or(300) as i32;
     if m.species() == crate::mobs::Species::Allay {
@@ -2024,6 +2054,41 @@ fn write_axolotl_memories(m: &Mob, map: &mut Compound) {
         }
     }
 }
+/// The variant tags `Axolotl`, `Rabbit`, `Parrot`, `Salmon` and
+/// `TropicalFish` read; a missing tag is the default variant (a medium
+/// salmon, otherwise index 0).
+fn read_variant(m: &mut Mob, tag: &Tag) {
+    use crate::mobs::Species as S;
+    let int = |key| number(tag.get(key)).unwrap_or(0) as i32;
+    match m.species() {
+        S::Axolotl | S::Parrot => m.extra.variant = int("Variant").clamp(0, 4) as u8,
+        // Rabbit.Variant.LEGACY_CODEC: an unknown id is brown.
+        S::Rabbit => {
+            m.extra.variant = match int("RabbitType") {
+                v @ (0..=5 | 99) => v as u8,
+                _ => 0,
+            }
+        }
+        S::Salmon => {
+            m.extra.variant = text(tag.get("type"))
+                .and_then(|t| SALMON_SIZES.iter().position(|v| *v == t))
+                .unwrap_or(1) as u8;
+        }
+        S::TropicalFish => {
+            let packed = int("Variant");
+            let (size, index) = (packed & 0xFF, (packed >> 8) & 0xFF);
+            // TropicalFish.Pattern.byId: an unknown id is a kob.
+            m.extra.variant = if size <= 1 && index < 6 {
+                (size * 6 + index) as u8
+            } else {
+                0
+            };
+            m.extra.variant2 = ((packed >> 16) & 15) as u8;
+            m.extra.variant3 = ((packed >> 24) & 15) as u8;
+        }
+        _ => {}
+    }
+}
 fn restore_axolotl_memories(m: &mut Mob, tag: &Tag) {
     let memories = tag.get("Brain").and_then(|b| b.get("memories"));
     let ttl = memories

From 66607c9eab9a313542e2a149446519b15d55a68f Mon Sep 17 00:00:00 2001
From: masa-masa-0314 <348336850+masa-masa-0314@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:14:36 +0800
Subject: [PATCH 353/475] Items: glint enchanted armour on armour stands

ArmorStandRenderer draws worn armour through the same
HumanoidArmorLayer as a living entity, so its pieces should use the
armour glint when ItemStack.hasFoil() is true. The stand's equipment
loop now checks the stack's enchantment_glint_override component, then
the item's default override, then its enchantments component (vanilla's
Item.isFoil), and draws both the armour and its trim layer with overlay
13. The existing ARMOR_GLINT path supplies the model UV and samples
enchanted_glint_armor through ARMOR_ENTITY_GLINT_TEXTURING.

Co-Authored-By: ZCode <agent@zcode.dev>
---
 crates/horizon-client/src/game/armor_stands.rs | 18 ++++++++++++++++--
 crates/horizon-client/src/item_data.rs         | 13 +++++++++++++
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs
index 92080b70c..dd81ac427 100644
--- a/crates/horizon-client/src/game/armor_stands.rs
+++ b/crates/horizon-client/src/game/armor_stands.rs
@@ -706,6 +706,20 @@ impl Game<'_> {
                 let color = undyed.map_or(0xFFFF_FFFF, |c| {
                     0xFF00_0000 | (c & 0xFF) << 16 | (c & 0xFF00) | (c >> 16) & 0xFF
                 });
+                // ArmorStandRenderer's HumanoidArmorLayer: the armour glint
+                // when `stack.hasFoil()`, as on a living entity.
+                let item_glint = self
+                    .res
+                    .items()
+                    .enchantments
+                    .props
+                    .get(&stack.item)
+                    .is_some_and(|p| p.glint);
+                let overlay = if stack.has_foil(item_glint) {
+                    horizon_client::mobs::render::ARMOR_GLINT
+                } else {
+                    0
+                };
                 let layer_poses = Poses::new(part);
                 horizon_client::mobs::render::draw(
                     part,
@@ -714,7 +728,7 @@ impl Game<'_> {
                     uv,
                     color,
                     packed,
-                    0,
+                    overlay,
                     out,
                 );
                 // EquipmentLayerRenderer: the trim layer over the armour.
@@ -729,7 +743,7 @@ impl Game<'_> {
                         trim,
                         0xFFFF_FFFF,
                         packed,
-                        0,
+                        overlay,
                         out,
                     );
                 }
diff --git a/crates/horizon-client/src/item_data.rs b/crates/horizon-client/src/item_data.rs
index ac624e85b..7499de7e4 100644
--- a/crates/horizon-client/src/item_data.rs
+++ b/crates/horizon-client/src/item_data.rs
@@ -198,6 +198,19 @@ impl ItemStack {
     pub fn has_any_enchantments(&self) -> bool {
         !self.enchantments().is_empty() || !self.stored_enchantments().is_empty()
     }
+    /// `ItemStack.hasFoil`: an explicit `minecraft:enchantment_glint_override`
+    /// component wins, then the item's default override (`item_glint`), then a
+    /// non-empty `minecraft:enchantments` component (`Item.isFoil` is
+    /// `ItemStack.isEnchanted`; stored book enchantments do not count).
+    pub fn has_foil(&self, item_glint: bool) -> bool {
+        if let Some(Tag::Byte(flag)) = self
+            .data()
+            .and_then(|d| d.other("minecraft:enchantment_glint_override"))
+        {
+            return *flag != 0;
+        }
+        item_glint || !self.enchantments().is_empty()
+    }
     pub fn repair_cost(&self) -> u32 {
         self.data().map_or(0, |d| d.repair_cost)
     }

From bf64f868d16bb757a6ce824575dd856a7edfccff Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 23:16:08 +0100
Subject: [PATCH 354/475] Send a mob's body and saddle equipment to the single
 player window

The body slot (horse armour, llama carpet, harness, nautilus armour) was sent as the head slot and the client ignored slots 6 and 7. Send the body item as slot 6 and apply slots 6 and 7 to the fields the renderer reads.
---
 crates/horizon-client/src/game/lan.rs    |  5 ++++-
 crates/horizon-client/src/game/remote.rs | 19 +++++++++++++++----
 2 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index e39fa3a68..14ce1866e 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -379,13 +379,16 @@ fn mob_equipment(
     out: &mut Vec<(u8, Option<horizon_protocol::item::Stack>)>,
 ) {
     let e = &m.extra;
+    // A horse's armour, a llama's carpet, a harness: Horizon keeps the body
+    // slot's item (6) in `head`.
+    let body = horizon_client::mobs::drops::head_is_body(m.species());
     let slots = [
         (0u8, &e.main_hand),
         (1, &e.off_hand),
         (2, &e.feet),
         (3, &e.legs),
         (4, &e.chest),
-        (5, &e.head),
+        (if body { 6 } else { 5 }, &e.head),
     ];
     for (slot, item) in slots {
         if let Some(item) = item {
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..ca0e9b35a 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -2013,13 +2013,22 @@ impl Game<'_> {
             // player holds and wears (EquipmentSlot ordinals).
             C::SetEquipment(p) => {
                 self.remote_object_equipment(p.id, &p.slots);
-                let items: Vec<(u8, Option<Arc<str>>)> = p
+                let items: Vec<(u8, Option<Arc<str>>, Option<ItemStack>)> = p
                     .slots
                     .iter()
-                    .map(|(slot, stack)| (*slot, stack.as_ref().map(|s| self.item_name(s.item))))
+                    .map(|(slot, stack)| {
+                        (
+                            *slot,
+                            stack.as_ref().map(|s| self.item_name(s.item)),
+                            self.to_stack(stack),
+                        )
+                    })
                     .collect();
                 if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
-                    for (slot, item) in items {
+                    // The body slot (6: horse armour, llama carpet, harness)
+                    // is kept in `head`, as Horizon's own mobs do.
+                    let body = horizon_client::mobs::drops::head_is_body(m.species());
+                    for (slot, item, stack) in items {
                         let e = &mut m.extra;
                         match slot {
                             0 => e.main_hand = item,
@@ -2027,7 +2036,9 @@ impl Game<'_> {
                             2 => e.feet = item,
                             3 => e.legs = item,
                             4 => e.chest = item,
-                            5 => e.head = item,
+                            5 if !body => e.head = item,
+                            6 if body => e.head = item,
+                            7 => m.set_saddle(stack),
                             _ => {}
                         }
                     }

From 909f15b90979c4339575e4011c37f2d0588f3464 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 23:22:03 +0100
Subject: [PATCH 355/475] Count the warden tendril and heart animations down
 again

---
 crates/horizon-client/src/mobs/warden.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/horizon-client/src/mobs/warden.rs b/crates/horizon-client/src/mobs/warden.rs
index 9092c9e8f..747443577 100644
--- a/crates/horizon-client/src/mobs/warden.rs
+++ b/crates/horizon-client/src/mobs/warden.rs
@@ -796,6 +796,12 @@ pub fn client_tick(m: &mut Mob) {
     animate(m, &mut Vec::new());
 }
 fn animate(m: &mut Mob, events: &mut Vec<MobEvent>) {
+    // The animation values count down after the sync of the last tick.
+    for slot in [TENDRIL, HEART] {
+        if m.anim.v[slot] > 0.0 {
+            m.anim.v[slot] -= 1.0;
+        }
+    }
     let digging_clock = |m: &Mob, slot: usize| {
         m.anim.states[slot]
             .millis(m.age as f32)

From ef0714a99a7926bb218c4901c107c07701420e6e Mon Sep 17 00:00:00 2001
From: levzzz <86072227+levzzz5154@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:22:24 +0500
Subject: [PATCH 356/475] Lock in the sprint state that outlives the sprint key

Sprint is a state, not a held key: LocalPlayer.aiStep starts it with the
sprint key and stops it only on a vanilla stop condition, so releasing the
key keeps it while forward is held. The server-side overwrite that rewrote
the flag from the held keys is gone, so the underwater swim, the sprint
jump and the flight speed follow the state on main. This adds the
end-to-end regression tests that were missing for those three paths: the
swim speed with the key released, the jump impulse with the key released,
and the flight speed that follows the sprint state and not the sprint key.

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 crates/horizon-client/src/motion.rs | 186 ++++++++++++++++++++++++++++
 1 file changed, 186 insertions(+)

diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index 234390e23..d4beee1ea 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -3944,4 +3944,190 @@ mod tests {
             "{walked} steps over {metres} step-metres"
         );
     }
+    /// Vanilla sprint is a state, not a held key: `LocalPlayer.aiStep` starts
+    /// it with the sprint key and stops it only on a vanilla stop condition.
+    /// Releasing the key while swimming keeps the sprint and its swim speed.
+    #[test]
+    fn a_sprint_survives_the_sprint_key_coming_up_while_swimming() {
+        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = Assets::load(&root).unwrap();
+        let render = assets.reload(&root).unwrap();
+        let binding = crate::collisions::load(&root, assets.registry).unwrap();
+        let resources = MotionResources::load(&root, &assets).unwrap();
+        let water = assets.registry.default_state("minecraft:water").unwrap();
+        let forward = crate::sprint::Keys {
+            forward: true,
+            ..Default::default()
+        };
+        let sprinting = crate::sprint::Keys {
+            sprint: true,
+            ..forward
+        };
+        // The same swim with the sprint key held, and with the key released
+        // once the sprint has started: the speed must not change.
+        let mut swims = Vec::new();
+        for release in [false, true] {
+            let mut scene = World::test_scene(&assets, &render, 3).unwrap();
+            for x in 19..=21 {
+                for y in 4..=8 {
+                    for z in 19..=31 {
+                        scene.set(x, y, z, water).unwrap();
+                    }
+                }
+            }
+            let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
+            let mut w = MotionWorld {
+                entities: &[],
+                player: &mut player,
+                scene: &mut scene,
+                assets: &assets,
+                collision_binding: &binding,
+                resources: &resources,
+            };
+            let mut speed = Vec::new();
+            for tick in 0..12 {
+                // The key comes up on the fourth tick, after the sprint has
+                // started and the player swims.
+                let keys = if release && tick >= 4 {
+                    forward
+                } else {
+                    sprinting
+                };
+                w.controlled_simulation_tick(keys).unwrap();
+                speed.push(w.player.velocity.z);
+            }
+            assert!(
+                w.player.sprinting,
+                "the sprint state survives the sprint key in water"
+            );
+            assert!(w.player.swimming, "a sprinting player in water swims");
+            swims.push(speed);
+        }
+        assert_eq!(
+            swims[0], swims[1],
+            "the swim speed must not drop when the sprint key comes up"
+        );
+    }
+
+    /// Vanilla: `LivingEntity.jumpFromGround` adds its 0.2 forward impulse
+    /// while the sprint state holds, so a jump taken after the sprint key
+    /// comes up is still a sprint jump.
+    #[test]
+    fn a_sprint_jump_keeps_its_impulse_when_the_sprint_key_comes_up() {
+        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = Assets::load(&root).unwrap();
+        let render = assets.reload(&root).unwrap();
+        let binding = crate::collisions::load(&root, assets.registry).unwrap();
+        let resources = MotionResources::load(&root, &assets).unwrap();
+        let mut scene = World::test_scene(&assets, &render, 3).unwrap();
+        let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
+        let mut w = MotionWorld {
+            entities: &[],
+            player: &mut player,
+            scene: &mut scene,
+            assets: &assets,
+            collision_binding: &binding,
+            resources: &resources,
+        };
+        let forward = crate::sprint::Keys {
+            forward: true,
+            ..Default::default()
+        };
+        let sprinting = crate::sprint::Keys {
+            sprint: true,
+            ..forward
+        };
+        for _ in 0..20 {
+            w.controlled_simulation_tick(sprinting).unwrap();
+        }
+        assert!(w.player.ground.on_ground, "the player settles on the floor");
+        assert!(w.player.sprinting, "the sprint key starts the sprint");
+        let running = w.player.velocity.z;
+        // The sprint key comes up and the player jumps.
+        w.controlled_simulation_tick(crate::sprint::Keys {
+            jump: true,
+            ..forward
+        })
+        .unwrap();
+        assert!(
+            w.player.sprinting,
+            "the sprint state survives the sprint key in the air"
+        );
+        assert!(
+            w.player.velocity.z > running + 0.05,
+            "the sprint jump keeps its forward impulse: {:?} vs {running}",
+            w.player.velocity
+        );
+    }
+
+    /// Vanilla `Player.getFlyingSpeed`: a flying player moves at the ability
+    /// speed, doubled while the sprint state holds. The sprint key starts the
+    /// state; releasing it does not change the speed.
+    #[test]
+    fn the_flight_speed_follows_the_sprint_state_not_the_sprint_key() {
+        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = Assets::load(&root).unwrap();
+        let render = assets.reload(&root).unwrap();
+        let binding = crate::collisions::load(&root, assets.registry).unwrap();
+        let resources = MotionResources::load(&root, &assets).unwrap();
+        let mut scene = World::test_scene(&assets, &render, 3).unwrap();
+        let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 10.0, 20.5)).unwrap();
+        let mut w = MotionWorld {
+            entities: &[],
+            player: &mut player,
+            scene: &mut scene,
+            assets: &assets,
+            collision_binding: &binding,
+            resources: &resources,
+        };
+        w.player.may_fly = true;
+        w.player.flying = true;
+        let forward = crate::sprint::Keys {
+            forward: true,
+            ..Default::default()
+        };
+        let sprinting = crate::sprint::Keys {
+            sprint: true,
+            ..forward
+        };
+        assert_eq!(
+            w.flying_speed().unwrap(),
+            0.05,
+            "a flying player without a sprint moves at the ability speed"
+        );
+        // The sprint key starts the sprint, and the state doubles the speed.
+        w.controlled_simulation_tick(sprinting).unwrap();
+        assert!(w.player.sprinting, "the sprint key starts the sprint");
+        assert_eq!(
+            w.flying_speed().unwrap(),
+            0.1,
+            "a sprinting player flies at twice the ability speed"
+        );
+        // Releasing the sprint key keeps the state, so the speed stays.
+        w.controlled_simulation_tick(forward).unwrap();
+        assert!(
+            w.player.sprinting,
+            "the sprint state survives the sprint key in the air"
+        );
+        assert_eq!(
+            w.flying_speed().unwrap(),
+            0.1,
+            "the flight speed follows the sprint state, not the sprint key"
+        );
+    }
 }

From a891037c9f7ee4dbd3b12b6d971305bce3d8ccbb Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 23:24:54 +0100
Subject: [PATCH 357/475] parity: harnesses build horizon-client in the fast
 profile only

Under parity.py the release and fast profiles have identical settings
(PROFILE: no LTO, 16 codegen units, incremental), yet 38 harnesses built
horizon-client in release and 16 others in fast: every run where the client
changed compiled it twice. They all use fast now. Release stays for
horizon-world's probes, which no fast harness builds.

Measured on playhorizon (4 CPUs), all 13 probe builds after 78 merges:
1578 s, of which the release client (bin + client_probe) took 485 s.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tools/test_block_removal_parity.py            | 4 ++--
 tools/test_command_exec_parity.py             | 4 ++--
 tools/test_command_parse_parity.py            | 4 ++--
 tools/test_composter_parity.py                | 4 ++--
 tools/test_crafter_parity.py                  | 4 ++--
 tools/test_dedicated_server_parity.py         | 4 ++--
 tools/test_dispenser_parity.py                | 4 ++--
 tools/test_enchanting_parity.py               | 4 ++--
 tools/test_entity_death_loot_parity.py        | 4 ++--
 tools/test_finalize_spawn_parity.py           | 4 ++--
 tools/test_locator_bar_parity.py              | 4 ++--
 tools/test_mace_parity.py                     | 4 ++--
 tools/test_mob_ai_parity.py                   | 4 ++--
 tools/test_mob_attributes_parity.py           | 4 ++--
 tools/test_natural_spawn_parity.py            | 4 ++--
 tools/test_online_mode_parity.py              | 4 ++--
 tools/test_raid_parity.py                     | 4 ++--
 tools/test_scoreboard_parity.py               | 4 ++--
 tools/test_sculk_parity.py                    | 4 ++--
 tools/test_secure_chat_parity.py              | 4 ++--
 tools/test_server_dimension_players_parity.py | 4 ++--
 tools/test_server_dragon_parity.py            | 4 ++--
 tools/test_server_entities_parity.py          | 4 ++--
 tools/test_server_knockback_parity.py         | 4 ++--
 tools/test_server_ops_feedback_parity.py      | 4 ++--
 tools/test_server_player_targets_parity.py    | 4 ++--
 tools/test_server_resource_pack_parity.py     | 4 ++--
 tools/test_server_world_gen_parity.py         | 4 ++--
 tools/test_spawn_rules_parity.py              | 4 ++--
 tools/test_spawner_parity.py                  | 4 ++--
 tools/test_subtitle_parity.py                 | 4 ++--
 tools/test_team_rules_parity.py               | 4 ++--
 tools/test_trading_parity.py                  | 4 ++--
 tools/test_trial_spawner_parity.py            | 4 ++--
 tools/test_use_item_on_parity.py              | 4 ++--
 tools/test_user_cache_parity.py               | 4 ++--
 tools/test_vault_parity.py                    | 4 ++--
 tools/test_world_spawn_parity.py              | 8 ++++----
 38 files changed, 78 insertions(+), 78 deletions(-)

diff --git a/tools/test_block_removal_parity.py b/tools/test_block_removal_parity.py
index 3185bd4bb..169806f6e 100755
--- a/tools/test_block_removal_parity.py
+++ b/tools/test_block_removal_parity.py
@@ -180,9 +180,9 @@ def main():
            '-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
     d.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
            str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
-    d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    d.run(['cargo', 'build', '-q', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
           env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
-    d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
+    d.run([str(lab.cargo_target() / 'fast/horizon-client'), '--resources', str(resources)], cwd=work,
           env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}'))
     # Loot table names (D) are vanilla's bookkeeping; the drops themselves are compared.
     ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
diff --git a/tools/test_command_exec_parity.py b/tools/test_command_exec_parity.py
index 7993a93a7..230e72890 100644
--- a/tools/test_command_exec_parity.py
+++ b/tools/test_command_exec_parity.py
@@ -79,9 +79,9 @@ def main():
     run(['java', '-Xmx3G', '-Duser.timezone=UTC', '-cp', os.pathsep.join([str(classes), str(jars['server']), dependency_path]),
          'dev.horizonlab.parity.VanillaCommandExecOracle', vanilla_dir / 'universe', script_path, build / 'vanilla.jsonl', SEED], 'java', cwd=vanilla_dir)
 
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], 'compile-rust', cwd=lab.ROOT)
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], 'compile-rust', cwd=lab.ROOT)
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     rust_dir = build / 'rust'
     shutil.rmtree(rust_dir, ignore_errors=True)
     rust_dir.mkdir()
diff --git a/tools/test_command_parse_parity.py b/tools/test_command_parse_parity.py
index 620fb548d..8d8007d0d 100644
--- a/tools/test_command_parse_parity.py
+++ b/tools/test_command_parse_parity.py
@@ -64,9 +64,9 @@ def main():
     registries = json.loads((build / 'registries.json').read_text())
     corpus = corpus_module.corpus(tree, registries)
     (build / 'corpus.txt').write_text(''.join(line + '\n' for line in corpus), encoding='utf-8')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
+    binary = Path(metadata['target_directory']) / 'fast/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
     resources = lab.RESOURCES
     total_failures = 0
     summary = []
diff --git a/tools/test_composter_parity.py b/tools/test_composter_parity.py
index 074b227a8..83b99e9b5 100644
--- a/tools/test_composter_parity.py
+++ b/tools/test_composter_parity.py
@@ -122,9 +122,9 @@ def main():
            '-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
     d.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
            str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
-    d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    d.run(['cargo', 'build', '-q', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
           env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
-    d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
+    d.run([str(lab.cargo_target() / 'fast/horizon-client'), '--resources', str(resources)], cwd=work,
           env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}'))
     ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
     native = h.split_cases((work / 'native.txt').read_text(), ignore)
diff --git a/tools/test_crafter_parity.py b/tools/test_crafter_parity.py
index b9c343d4d..dcb5cd127 100644
--- a/tools/test_crafter_parity.py
+++ b/tools/test_crafter_parity.py
@@ -242,9 +242,9 @@ def main():
            '-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
     d.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
            str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
-    d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    d.run(['cargo', 'build', '-q', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
           env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
-    d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
+    d.run([str(lab.cargo_target() / 'fast/horizon-client'), '--resources', str(resources)], cwd=work,
           env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}'))
     ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
     native = h.split_cases((work / 'native.txt').read_text(), ignore)
diff --git a/tools/test_dedicated_server_parity.py b/tools/test_dedicated_server_parity.py
index 7572ee3e2..9d7080c7f 100644
--- a/tools/test_dedicated_server_parity.py
+++ b/tools/test_dedicated_server_parity.py
@@ -424,11 +424,11 @@ def main():
     oh.run_logged(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-sourcepath',
                    lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                   build, 'compile-java')
-    oh.run_logged(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
+    oh.run_logged(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
                   'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.RESOURCES, '--dedicated', '--nogui']
 
diff --git a/tools/test_dispenser_parity.py b/tools/test_dispenser_parity.py
index a2c6ba036..729d8e8b7 100644
--- a/tools/test_dispenser_parity.py
+++ b/tools/test_dispenser_parity.py
@@ -417,9 +417,9 @@ def main():
          '-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
     run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
          str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
-    run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    run(['cargo', 'build', '-q', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
         env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
-    run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
+    run([str(lab.cargo_target() / 'fast/horizon-client'), '--resources', str(resources)], cwd=work,
         env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}'))
     # Loot table names (D) are vanilla's bookkeeping; the drops themselves are compared.
     ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
diff --git a/tools/test_enchanting_parity.py b/tools/test_enchanting_parity.py
index 35f0777c8..9e070c3cb 100644
--- a/tools/test_enchanting_parity.py
+++ b/tools/test_enchanting_parity.py
@@ -56,9 +56,9 @@ def main():
         with (build / (name + '.log')).open('w', encoding='utf-8') as log:
             base.run(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT)
     run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none','-sourcepath',str(lab.ROOT/'mods/horizon/src/test/java'), '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
+    binary = Path(metadata['target_directory']) / 'fast/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
     run([binary, 'enchanting_fixture',resources, inputs, build / 'rust.txt'], 'rust')
     references = []
     for side in ['server']:
diff --git a/tools/test_entity_death_loot_parity.py b/tools/test_entity_death_loot_parity.py
index 07c77b0b8..2bb53ebbb 100644
--- a/tools/test_entity_death_loot_parity.py
+++ b/tools/test_entity_death_loot_parity.py
@@ -139,9 +139,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx2G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaEntityDeathLootOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'entity_death_loot_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     errors = [l for l in (build / 'server.txt').read_text().splitlines() if l.startswith('error ')]
     if errors:
diff --git a/tools/test_finalize_spawn_parity.py b/tools/test_finalize_spawn_parity.py
index 7d581fefc..0e889598c 100644
--- a/tools/test_finalize_spawn_parity.py
+++ b/tools/test_finalize_spawn_parity.py
@@ -148,9 +148,9 @@ def main():
         print(f'{len(vanilla)} oracle lines')
         return
     halloween = vanilla[0].split()[1]
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'finalize_spawn_fixture', resources, inputs, build / 'rust.txt', halloween], 'rust')
     rust = (build / 'rust.txt').read_text().splitlines()
     bad = [(a, b) for a, b in zip(vanilla, rust) if a != b]
diff --git a/tools/test_locator_bar_parity.py b/tools/test_locator_bar_parity.py
index 6574af76e..05f479461 100644
--- a/tools/test_locator_bar_parity.py
+++ b/tools/test_locator_bar_parity.py
@@ -258,12 +258,12 @@ def sides(name):
     subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath',
                     lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                    cwd=lab.ROOT, check=True, capture_output=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.LocatorBarClient']
diff --git a/tools/test_mace_parity.py b/tools/test_mace_parity.py
index 578e9e6ee..2ff560b8d 100644
--- a/tools/test_mace_parity.py
+++ b/tools/test_mace_parity.py
@@ -167,9 +167,9 @@ def main():
            '-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
     d.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
            str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
-    d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    d.run(['cargo', 'build', '-q', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
           env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
-    d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
+    d.run([str(lab.cargo_target() / 'fast/horizon-client'), '--resources', str(resources)], cwd=work,
           env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}'))
     ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
     native = h.split_cases((work / 'native.txt').read_text(), ignore)
diff --git a/tools/test_mob_ai_parity.py b/tools/test_mob_ai_parity.py
index 133deca2d..9d88ca18d 100644
--- a/tools/test_mob_ai_parity.py
+++ b/tools/test_mob_ai_parity.py
@@ -525,7 +525,7 @@ def main():
                                    'dev.horizonlab.parity.VanillaMobAiOracle', inputs, build / 'vanilla.txt', world],
                                   build, 'vanilla', timeout=3600)
     if not args.java_only:
-        command = ['cargo', 'build', '--locked', '--release', '-p', 'horizon-client', '--example', 'client_probe']
+        command = ['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe']
         target, env = lab.cargo_target(), None
         if args.trace:
             target = lab.LOCAL / 'mob-ai-trace-target'
@@ -533,7 +533,7 @@ def main():
             env = dict(os.environ, CARGO_TARGET_DIR=str(target), CARGO_PROFILE_RELEASE_DEBUG='line-tables-only',
                        CARGO_PROFILE_RELEASE_LTO='false', CARGO_PROFILE_RELEASE_CODEGEN_UNITS='16')
         oracle_harness.run_logged(command, build, 'compile-rust', env=env)
-        binary = target / 'release/examples/client_probe'
+        binary = target / 'fast/examples/client_probe'
         oracle_harness.run_logged([binary, 'mob_ai_probe', lab.RESOURCES, inputs, build / 'horizon.txt'], build, 'horizon')
     if args.java_only:
         return
diff --git a/tools/test_mob_attributes_parity.py b/tools/test_mob_attributes_parity.py
index 7fa1df5e6..27f2b238b 100755
--- a/tools/test_mob_attributes_parity.py
+++ b/tools/test_mob_attributes_parity.py
@@ -62,8 +62,8 @@ def main():
             subprocess.run(list(map(str, cmd)), cwd=lab.ROOT, check=True, timeout=3600, stdout=log, stderr=subprocess.STDOUT)
     run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx1G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]), 'dev.horizonlab.parity.VanillaMobAttributesOracle', build / 'vanilla.txt'], 'java')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
-    binary = lab.cargo_target() / 'release/examples/client_probe'
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    binary = lab.cargo_target() / 'fast/examples/client_probe'
     resources = lab.RESOURCES
     run([binary, 'mob_attributes_fixture', resources, build / 'rust.txt'], 'rust')
     vanilla, rust = parse(build / 'vanilla.txt'), parse(build / 'rust.txt')
diff --git a/tools/test_natural_spawn_parity.py b/tools/test_natural_spawn_parity.py
index 50781eca7..bd3eb2540 100644
--- a/tools/test_natural_spawn_parity.py
+++ b/tools/test_natural_spawn_parity.py
@@ -568,9 +568,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx3G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaNaturalSpawnOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'natural_spawn_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     vanilla = (build / 'server.txt').read_text().splitlines()
     errors = [l for l in vanilla if ' error ' in l]
diff --git a/tools/test_online_mode_parity.py b/tools/test_online_mode_parity.py
index 8096efd80..002516896 100644
--- a/tools/test_online_mode_parity.py
+++ b/tools/test_online_mode_parity.py
@@ -351,11 +351,11 @@ def main():
     build.mkdir(parents=True, exist_ok=True)
     report = build / 'report.json'
     report.unlink(missing_ok=True)
-    oh.run_logged(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
+    oh.run_logged(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
                   'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
 
     services = Services()
diff --git a/tools/test_raid_parity.py b/tools/test_raid_parity.py
index 4928c9715..6beadf52b 100644
--- a/tools/test_raid_parity.py
+++ b/tools/test_raid_parity.py
@@ -335,9 +335,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx3G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaRaidOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'raid_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     vanilla = (build / 'server.txt').read_text().splitlines()
     errors = [l for l in vanilla if ' error ' in l]
diff --git a/tools/test_scoreboard_parity.py b/tools/test_scoreboard_parity.py
index b38dfb301..8098ae681 100644
--- a/tools/test_scoreboard_parity.py
+++ b/tools/test_scoreboard_parity.py
@@ -250,9 +250,9 @@ def main():
     inputs = build / 'inputs.jsonl'
     inputs.write_text(''.join(json.dumps(c, ensure_ascii=False) + '\n' for c in chosen), encoding='utf-8')
     run([*oracle, 'run', inputs, build / 'vanilla.jsonl'], 'vanilla')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
+    binary = Path(metadata['target_directory']) / 'fast/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
     run([binary, 'scoreboard_fixture',build / 'registries.json', inputs, build / 'rust.jsonl', build / 'vanilla.jsonl'], 'rust')
     read = lambda p: [json.loads(l) for l in p.read_text(encoding='utf-8').splitlines()]
     vanilla, rust = read(build / 'vanilla.jsonl'), read(build / 'rust.jsonl')
diff --git a/tools/test_sculk_parity.py b/tools/test_sculk_parity.py
index bff5ad5ba..b4195e5c3 100644
--- a/tools/test_sculk_parity.py
+++ b/tools/test_sculk_parity.py
@@ -336,9 +336,9 @@ def main():
                                    'dev.horizonlab.parity.VanillaSculkOracle', inputs, build / 'vanilla.txt'],
                                   build, 'vanilla', timeout=3600)
     if not args.java_only:
-        oracle_harness.run_logged(['cargo', 'build', '--locked', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'],
+        oracle_harness.run_logged(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'],
                                   build, 'compile-rust')
-        oracle_harness.run_logged([lab.cargo_target() / 'release/horizon-client', '--resources', resources], build, 'horizon',
+        oracle_harness.run_logged([lab.cargo_target() / 'fast/horizon-client', '--resources', resources], build, 'horizon',
                                   env=lab.game_env(HORIZON_SCULK_FIXTURE=f'{inputs},{build / "horizon.txt"}'))
     if args.java_only:
         return
diff --git a/tools/test_secure_chat_parity.py b/tools/test_secure_chat_parity.py
index b9062568a..a4f77470f 100644
--- a/tools/test_secure_chat_parity.py
+++ b/tools/test_secure_chat_parity.py
@@ -254,11 +254,11 @@ def main():
     oh.run_logged(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-sourcepath',
                    lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                   build, 'compile-java')
-    oh.run_logged(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
+    oh.run_logged(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
                   'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     java = ['java', '-Xmx1g', '-Duser.timezone=UTC', '-cp', str(classes) + os.pathsep + dependencies,
             'dev.horizonlab.parity.SecureChatClient']
     oh.run_logged([*java, 'keys', build], build, 'keys')
diff --git a/tools/test_server_dimension_players_parity.py b/tools/test_server_dimension_players_parity.py
index ea026a509..887ebb2d7 100644
--- a/tools/test_server_dimension_players_parity.py
+++ b/tools/test_server_dimension_players_parity.py
@@ -118,12 +118,12 @@ def main():
     subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath',
                     lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                    cwd=lab.ROOT, check=True, capture_output=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.LocatorBarClient']
diff --git a/tools/test_server_dragon_parity.py b/tools/test_server_dragon_parity.py
index dc58e851d..563ac788a 100644
--- a/tools/test_server_dragon_parity.py
+++ b/tools/test_server_dragon_parity.py
@@ -101,12 +101,12 @@ def main():
     # SERVER_DRAGON_SIDES=vanilla (or horizon) runs one side and reads the other's last transcript.
     sides = [s for s in os.environ.get('SERVER_DRAGON_SIDES', 'vanilla,horizon').split(',') if s]
     if 'horizon' in sides:
-        subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+        subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                        check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-Duser.timezone=UTC', '-cp', str(classes) + os.pathsep + dependencies,
diff --git a/tools/test_server_entities_parity.py b/tools/test_server_entities_parity.py
index fba196c72..b8c5a7def 100644
--- a/tools/test_server_entities_parity.py
+++ b/tools/test_server_entities_parity.py
@@ -157,12 +157,12 @@ def main():
     # SERVER_ENTITIES_SIDES=vanilla (or horizon) runs one side and reads the other's last transcript.
     sides = [s for s in os.environ.get('SERVER_ENTITIES_SIDES', 'vanilla,horizon').split(',') if s]
     if 'horizon' in sides:
-        subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+        subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                        check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-Duser.timezone=UTC', '-cp', str(classes) + os.pathsep + dependencies,
diff --git a/tools/test_server_knockback_parity.py b/tools/test_server_knockback_parity.py
index 66b75946e..b3c4355ea 100644
--- a/tools/test_server_knockback_parity.py
+++ b/tools/test_server_knockback_parity.py
@@ -334,12 +334,12 @@ def main():
     subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath',
                     lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                    cwd=lab.ROOT, check=True, capture_output=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.KnockbackClient']
diff --git a/tools/test_server_ops_feedback_parity.py b/tools/test_server_ops_feedback_parity.py
index 91854fac6..eb7788545 100644
--- a/tools/test_server_ops_feedback_parity.py
+++ b/tools/test_server_ops_feedback_parity.py
@@ -118,12 +118,12 @@ def main():
     subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath',
                     lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                    cwd=lab.ROOT, check=True, capture_output=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.LocatorBarClient']
diff --git a/tools/test_server_player_targets_parity.py b/tools/test_server_player_targets_parity.py
index 263aa4a59..321a39f06 100644
--- a/tools/test_server_player_targets_parity.py
+++ b/tools/test_server_player_targets_parity.py
@@ -169,12 +169,12 @@ def main():
     subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath',
                     lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                    cwd=lab.ROOT, check=True, capture_output=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.LocatorBarClient']
diff --git a/tools/test_server_resource_pack_parity.py b/tools/test_server_resource_pack_parity.py
index 0f5d258c6..10965d273 100644
--- a/tools/test_server_resource_pack_parity.py
+++ b/tools/test_server_resource_pack_parity.py
@@ -134,9 +134,9 @@ def main():
     subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath',
                     lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                    cwd=lab.ROOT, check=True, capture_output=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
-    binary = lab.cargo_target() / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = lab.cargo_target() / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.ServerPackClient']
diff --git a/tools/test_server_world_gen_parity.py b/tools/test_server_world_gen_parity.py
index f55e55809..14da72a6d 100644
--- a/tools/test_server_world_gen_parity.py
+++ b/tools/test_server_world_gen_parity.py
@@ -130,11 +130,11 @@ def main():
     build.mkdir(parents=True, exist_ok=True)
     report = build / 'report.json'
     report.unlink(missing_ok=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main',
                       'nogui']
diff --git a/tools/test_spawn_rules_parity.py b/tools/test_spawn_rules_parity.py
index 7f9ac07ce..01196b355 100644
--- a/tools/test_spawn_rules_parity.py
+++ b/tools/test_spawn_rules_parity.py
@@ -155,9 +155,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx2G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaSpawnRulesOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'spawn_rules_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     vanilla = (build / 'server.txt').read_text().splitlines()
     errors = [l for l in vanilla if ' error ' in l]
diff --git a/tools/test_spawner_parity.py b/tools/test_spawner_parity.py
index 187e211b7..34f6ec726 100644
--- a/tools/test_spawner_parity.py
+++ b/tools/test_spawner_parity.py
@@ -249,9 +249,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx3G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaNaturalSpawnOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'natural_spawn_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     vanilla = (build / 'server.txt').read_text().splitlines()
     errors = [l for l in vanilla if ' error ' in l]
diff --git a/tools/test_subtitle_parity.py b/tools/test_subtitle_parity.py
index 6baf25570..17c856550 100644
--- a/tools/test_subtitle_parity.py
+++ b/tools/test_subtitle_parity.py
@@ -133,9 +133,9 @@ def main():
          *(PARITY / f'{n}.java' for n in ('ParityFont', 'VanillaSubtitleOracle'))], 'compile-java')
     run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaSubtitleOracle',
          inputs, build / 'vanilla.jsonl'], 'vanilla')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
+    binary = Path(metadata['target_directory']) / 'fast/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
     run([binary, 'subtitle_fixture',resources, inputs, build / 'rust.jsonl'], 'rust')
     vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text(encoding='utf-8').splitlines()]
     rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text(encoding='utf-8').splitlines()]
diff --git a/tools/test_team_rules_parity.py b/tools/test_team_rules_parity.py
index ac66a412b..9d12075ec 100644
--- a/tools/test_team_rules_parity.py
+++ b/tools/test_team_rules_parity.py
@@ -84,9 +84,9 @@ def main():
          PARITY / 'VanillaTeamRulesOracle.java'], 'compile-java')
     run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaTeamRulesOracle',
          inputs, build / 'vanilla.jsonl'], 'vanilla')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
+    binary = Path(metadata['target_directory']) / 'fast/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
     run([binary, 'team_rules_fixture',inputs, build / 'rust.jsonl'], 'rust')
     vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text().splitlines()]
     rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()]
diff --git a/tools/test_trading_parity.py b/tools/test_trading_parity.py
index 46e81f928..9b5581f3b 100644
--- a/tools/test_trading_parity.py
+++ b/tools/test_trading_parity.py
@@ -219,8 +219,8 @@ def main():
     if args.java_only:
         print(f'{len(vanilla)} oracle lines')
         return
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
-    binary = lab.cargo_target() / 'release/examples/client_probe'
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    binary = lab.cargo_target() / 'fast/examples/client_probe'
     run([binary, 'trading_fixture', resources, inputs, build / 'server.txt', build / 'rust.txt'], 'rust')
     rust = (build / 'rust.txt').read_text().splitlines()
     bad = [(a, b) for a, b in zip(vanilla, rust) if a != b]
diff --git a/tools/test_trial_spawner_parity.py b/tools/test_trial_spawner_parity.py
index 7b2412eaa..43d26338a 100644
--- a/tools/test_trial_spawner_parity.py
+++ b/tools/test_trial_spawner_parity.py
@@ -214,9 +214,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx3G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaNaturalSpawnOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'natural_spawn_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     vanilla = (build / 'server.txt').read_text().splitlines()
     errors = [l for l in vanilla if ' error ' in l]
diff --git a/tools/test_use_item_on_parity.py b/tools/test_use_item_on_parity.py
index eabdd04eb..35e1c5515 100644
--- a/tools/test_use_item_on_parity.py
+++ b/tools/test_use_item_on_parity.py
@@ -405,9 +405,9 @@ def main():
            '-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
     d.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
            str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
-    d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    d.run(['cargo', 'build', '-q', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
           env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
-    d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
+    d.run([str(lab.cargo_target() / 'fast/horizon-client'), '--resources', str(resources)], cwd=work,
           env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}'))
     ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
     native = h.split_cases((work / 'native.txt').read_text(), ignore)
diff --git a/tools/test_user_cache_parity.py b/tools/test_user_cache_parity.py
index 621514cc8..34a7af1f3 100644
--- a/tools/test_user_cache_parity.py
+++ b/tools/test_user_cache_parity.py
@@ -205,11 +205,11 @@ def main():
     build.mkdir(parents=True, exist_ok=True)
     report = build / 'report.json'
     report.unlink(missing_ok=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     services = Services()
     discovery = services.url + '/minecraft/client'
     dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
diff --git a/tools/test_vault_parity.py b/tools/test_vault_parity.py
index 5741320d3..00e6422f5 100644
--- a/tools/test_vault_parity.py
+++ b/tools/test_vault_parity.py
@@ -190,9 +190,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx3G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaNaturalSpawnOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'natural_spawn_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     vanilla = (build / 'server.txt').read_text().splitlines()
     errors = [l for l in vanilla if ' error ' in l]
diff --git a/tools/test_world_spawn_parity.py b/tools/test_world_spawn_parity.py
index 00c390005..33bdd4c65 100644
--- a/tools/test_world_spawn_parity.py
+++ b/tools/test_world_spawn_parity.py
@@ -69,10 +69,10 @@ def seeds(count):
     return SEEDS + [rng.randrange(-2**63, 2**63) for _ in range(count)]
 
 
-def target_dir():
+def target_dir(profile='release'):
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    return Path(metadata['target_directory']) / 'release'
+    return Path(metadata['target_directory']) / profile
 
 
 def origins(build, classes, dependencies, all_seeds):
@@ -134,9 +134,9 @@ def main():
     if args.origins_only:
         sys.exit(1 if origin_diffs else 0)
 
-    oh.run_logged(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
+    oh.run_logged(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
                   'compile-rust', timeout=3600)
-    binary = target_dir() / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = target_dir('fast') / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     # One worker thread: the chunks decorated in a fixed order (see above).
     vanilla_server = ['java', '-Xmx2g', '-Dmax.bg.threads=1', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', RESOURCES, '--dedicated', '--nogui']

From 1b1571ed6a731d574a30e0bfef224b8e6c5d1fc3 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 23:30:59 +0100
Subject: [PATCH 358/475] parity: a crate split's manifest changes don't select
 every harness

Cargo.lock is a shared input and every harness depends on its crates'
Cargo.toml, so a crate split (#2160) selected all 352 harnesses although
its moved code reaches 123. With --changed, Cargo.lock and Cargo.toml
changes that only add, remove or move workspace crates (no registry or git
package, version, feature, dependency or build setting changed across them,
compared with the merge base) are left out; the moved code counts through
its own sources. Any other manifest change still counts, as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/parity-workflow.md     |  2 +-
 tests/test_parity_runner.py | 41 ++++++++++++++++++++++++++
 tools/parity.py             | 58 ++++++++++++++++++++++++++++++++++++-
 3 files changed, 99 insertions(+), 2 deletions(-)

diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md
index 50b67c571..4d20d32be 100644
--- a/docs/parity-workflow.md
+++ b/docs/parity-workflow.md
@@ -64,7 +64,7 @@ A harness can declare, at the top level of its script:
 
 ### Which harnesses a change affects
 
-`--changed` and `--changed-files` narrow each harness's Rust sources to those its probes can reach (`tools/parity_reach.py`), so a change to one module of `horizon-client` no longer reruns every harness whose probe links the crate. The narrowing works on items, not files: from the probe modules a harness ran (or the binary it built), a free item (fn, type, const, static) is reached when a reached item names it in its own module, through a path or an import of a module that is named, or through a glob import; an inherent impl's methods count one by one once their type is reached and their name is mentioned; a trait impl counts once its trait and its type are reached (std's traits and types always are); a macro counts once invoked. Names match by spelling, so the result only over-approximates. A reached file's parent modules count through their `mod` declarations of it, compared with the merge base; Rust files a change adds take part, a dependency that was deleted counts as changed, code under `#[cfg(test)]` never counts, and a harness whose probe can't be found keeps every source. Parses are cached by content in `reach-cache.json` of the shared parity folder (beside `passes/`), so a new worktree starts warm; a harness's search stops as soon as it reaches a changed file, and after `PARITY_REACH_BUDGET` seconds (default 180) the remaining harnesses count every source their probes link, so choosing never holds a slow machine for long. `--by-crate` turns the narrowing off. On the last 20 pull requests merged on 2026-10-25, the harnesses picked went from 2255 to 1061 (2384 to 1592 harness-minutes; game-binary harnesses, which link all of `game/`, set the floor), and every harness a CI parity run failed in the week before was still picked; every source file a sample of probes executed (LLVM `-C instrument-coverage`) is among those kept. Building the graph takes 15 s cold, under a second warm, and up to a minute and a half on a change that reaches many harnesses.
+`--changed` and `--changed-files` narrow each harness's Rust sources to those its probes can reach (`tools/parity_reach.py`), so a change to one module of `horizon-client` no longer reruns every harness whose probe links the crate. The narrowing works on items, not files: from the probe modules a harness ran (or the binary it built), a free item (fn, type, const, static) is reached when a reached item names it in its own module, through a path or an import of a module that is named, or through a glob import; an inherent impl's methods count one by one once their type is reached and their name is mentioned; a trait impl counts once its trait and its type are reached (std's traits and types always are); a macro counts once invoked. Names match by spelling, so the result only over-approximates. A reached file's parent modules count through their `mod` declarations of it, compared with the merge base; Rust files a change adds take part, a dependency that was deleted counts as changed, code under `#[cfg(test)]` never counts, and a harness whose probe can't be found keeps every source. Parses are cached by content in `reach-cache.json` of the shared parity folder (beside `passes/`), so a new worktree starts warm; a harness's search stops as soon as it reaches a changed file, and after `PARITY_REACH_BUDGET` seconds (default 180) the remaining harnesses count every source their probes link, so choosing never holds a slow machine for long. `--by-crate` turns the narrowing off. With `--changed`, `Cargo.lock` and `Cargo.toml` changes that only add, remove or move workspace crates (a crate split: no registry or git package, version, feature, dependency or build setting changed across them, compared with the merge base) don't count: the moved code counts through its sources. #2160's split went from 352 harnesses to 123 this way (its own changes to the runner still select them all). On the last 20 pull requests merged on 2026-10-25, the harnesses picked went from 2255 to 1061 (2384 to 1592 harness-minutes; game-binary harnesses, which link all of `game/`, set the floor), and every harness a CI parity run failed in the week before was still picked; every source file a sample of probes executed (LLVM `-C instrument-coverage`) is among those kept. Building the graph takes 15 s cold, under a second warm, and up to a minute and a half on a change that reaches many harnesses.
 
 ## The gate
 
diff --git a/tests/test_parity_runner.py b/tests/test_parity_runner.py
index 49a88f0b1..20b3b1efb 100644
--- a/tests/test_parity_runner.py
+++ b/tests/test_parity_runner.py
@@ -401,3 +401,44 @@ class KnownFlakyTests(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+class WorkspaceManifestTests(unittest.TestCase):
+    """A crate split's Cargo.toml and Cargo.lock changes don't select every harness; a dependency change still does."""
+    CLIENT = '[package]\nname = "horizon-client"\n\n[dependencies]\nserde = "1"\nwgpu = { version = "27", features = ["x"] }\n'
+    LOCK = ('version = 4\n\n[[package]]\nname = "horizon-client"\nversion = "0.1.0"\ndependencies = [\n "serde",\n]\n\n'
+            '[[package]]\nname = "serde"\nversion = "1.0.1"\nsource = "registry+https://github.com/rust-lang/crates.io-index"\n')
+
+    def verdict(self, base, head):
+        """base, head: {path: text or None}; the manifests workspace_only_manifests leaves out."""
+        with tempfile.TemporaryDirectory() as temp, \
+                mock.patch.object(parity, "ROOT", Path(temp)), \
+                mock.patch.object(parity, "git_show", lambda _base, path: base.get(path)):
+            for path, text in head.items():
+                if text is not None:
+                    Path(temp, path).parent.mkdir(parents=True, exist_ok=True)
+                    Path(temp, path).write_text(text)
+            return parity.workspace_only_manifests(set(head) | set(base), "base")
+
+    def test_a_crate_split_is_left_out(self):
+        command = '[package]\nname = "horizon-command"\n\n[dependencies]\nserde = "1"\nhorizon-core = { path = "../horizon-core" }\n'
+        client = self.CLIENT + 'horizon-command = { path = "../horizon-command" }\n'
+        lock = self.LOCK.replace('[[package]]\nname = "serde"', '[[package]]\nname = "horizon-command"\nversion = "0.1.0"\n\n'
+                                 '[[package]]\nname = "serde"')
+        base = {"Cargo.toml": '[workspace]\nmembers = ["crates/horizon-client"]\nresolver = "2"\n',
+                "crates/horizon-client/Cargo.toml": self.CLIENT, "Cargo.lock": self.LOCK}
+        head = {"Cargo.toml": '[workspace]\nmembers = ["crates/horizon-client", "crates/horizon-command"]\nresolver = "2"\n',
+                "crates/horizon-client/Cargo.toml": client, "crates/horizon-command/Cargo.toml": command, "Cargo.lock": lock}
+        self.assertEqual(self.verdict(base, head), set(head))
+
+    def test_a_dependency_change_still_counts(self):
+        base = {"crates/horizon-client/Cargo.toml": self.CLIENT, "Cargo.lock": self.LOCK}
+        bumped = {"crates/horizon-client/Cargo.toml": self.CLIENT, "Cargo.lock": self.LOCK.replace("1.0.1", "1.0.2")}
+        self.assertEqual(self.verdict(base, bumped), set())
+        feature = {"crates/horizon-client/Cargo.toml": self.CLIENT.replace('["x"]', '["x", "y"]')}
+        self.assertEqual(self.verdict({"crates/horizon-client/Cargo.toml": self.CLIENT}, feature), set())
+        resolver = {"Cargo.toml": '[workspace]\nmembers = ["a"]\nresolver = "3"\n'}
+        self.assertEqual(self.verdict({"Cargo.toml": '[workspace]\nmembers = ["a"]\nresolver = "2"\n'}, resolver), set())
+
+    def test_without_a_base_everything_counts(self):
+        self.assertEqual(parity.workspace_only_manifests({"Cargo.lock"}, None), set())
diff --git a/tools/parity.py b/tools/parity.py
index a5f7f2db1..76da59b4c 100644
--- a/tools/parity.py
+++ b/tools/parity.py
@@ -1246,6 +1246,58 @@ def trace_main(output, script, arguments):
 
 # Files every harness's result depends on (part of environment_key): a change to one affects them all.
 SHARED_INPUTS = {"research-lock.json", "Cargo.lock"}
+# Manifest sections that say what a crate is and where its targets are, not what it builds with.
+MANIFEST_SECTION_KEPT = re.compile(r"\[\[?(?:package|lib|bin|example|test|bench|lints|badges)\b[^\]]*\]\]?$")
+# A workspace crate named as a dependency (by path, or from the workspace's own table), or listed as a member.
+WORKSPACE_LINE = re.compile(r'(?:horizon[\w-]*|cargo-horizon-mod|xtask)\s*=\s*(?:\{[^}]*\b(?:path|workspace)\s*=[^}]*\}|true)'
+                            r'|(?:horizon[\w-]*|cargo-horizon-mod|xtask)\.workspace\s*=\s*true|"crates/[^"]+",?')
+
+
+def git_show(base, path):
+    """path's content at commit base, or None where it didn't exist."""
+    result = subprocess.run(["git", "show", f"{base}:{path}"], cwd=ROOT, capture_output=True, text=True)
+    return result.stdout if result.returncode == 0 else None
+
+
+def manifest_lines(text):
+    """A Cargo.toml's lines that decide what is built: (section, line) pairs, without its package's identity and
+    targets, comments, or workspace crates (whose code counts through its own sources)."""
+    lines, section = set(), ""
+    for raw in (text or "").splitlines():
+        line = re.sub(r"\s+", " ", raw.split("#", 1)[0]).strip()
+        if not line:
+            continue
+        if line.startswith("["):
+            section = line
+            continue
+        if MANIFEST_SECTION_KEPT.match(section) or WORKSPACE_LINE.fullmatch(line) or \
+                section == "[workspace]" and (line.startswith("members =") or line.startswith('"') or line == "]"):
+            continue
+        lines.add((section, line))
+    return lines
+
+
+def lock_packages(text):
+    """Cargo.lock's packages from a registry or git (with their versions and checksums); workspace crates' entries
+    only list what their manifests say."""
+    return {block.strip() for block in (text or "").split("[[package]]") if "\nsource = " in block}
+
+
+def workspace_only_manifests(changed, base):
+    """The changed Cargo.lock and Cargo.toml files whose changes only add, remove or move workspace crates (a crate
+    split): no external package, version, feature, or build setting changed across them. Their crates' code counts
+    through its own sources, so these files don't make every harness linking the crates rerun."""
+    manifests = sorted(path for path in changed if path == "Cargo.lock" or path.endswith("Cargo.toml"))
+    if not manifests or base is None:
+        return set()
+    if "Cargo.lock" in manifests and \
+            lock_packages(git_show(base, "Cargo.lock")) != lock_packages((ROOT / "Cargo.lock").read_text(encoding="utf-8")):
+        return set()
+    tomls = [path for path in manifests if path != "Cargo.lock"]
+    before = set().union(*(manifest_lines(git_show(base, path)) for path in tomls)) if tomls else set()
+    after = set().union(*(manifest_lines((ROOT / path).read_text(encoding="utf-8") if (ROOT / path).exists() else None)
+                          for path in tomls)) if tomls else set()
+    return set(manifests) if before == after else set()
 
 
 def changed_files(ref):
@@ -1449,7 +1501,11 @@ def main():
         if args.changed:
             merge_base = subprocess.run(["git", "merge-base", "HEAD", args.changed], cwd=ROOT, capture_output=True, text=True)
             base = merge_base.stdout.strip() or None
-        affected = affected_harnesses(found, records, changed, reach=not args.by_crate, base=base)
+        moved = workspace_only_manifests(changed, base) if not args.by_crate else set()
+        if moved:
+            print(f"{', '.join(sorted(moved))}: only workspace crates added, removed or moved; their sources count "
+                  "instead", flush=True)
+        affected = affected_harnesses(found, records, changed - moved, reach=not args.by_crate, base=base)
         chosen = [name for name in found if name in affected and stale(name, state, hasher, environment)]
         print(f"{len(changed)} files changed{since}: {len(affected)} harnesses "
               f"depend on them, {len(chosen)} without a pass for their current inputs.", flush=True)

From 9555f375d459e7da0fb4d5ce497985e4f8df310b Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 23:31:29 +0100
Subject: [PATCH 359/475] parity: remote_fireball is no longer known flaky
 (#2499)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tools/parity_hosts.json | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tools/parity_hosts.json b/tools/parity_hosts.json
index 29027f87f..60e6205e8 100644
--- a/tools/parity_hosts.json
+++ b/tools/parity_hosts.json
@@ -44,7 +44,6 @@
   "lan_integration": "the whole lan_e2e suite: ~40 min a run on a loaded runner, and single checks flake under load; run it by name, or tools/lan_e2e.py"
  },
  "known_flaky": {
-  "remote_fireball": "samples the fireball on the wall clock, so a slow host sees it in too few samples (desktop runner, 3 times on 10-26)",
   "world_reopen": "counted 4 minecarts instead of 3 once on a loaded Mac mini runner, then passed at the same head (10-26)"
  }
 }

From a68ee8009f43ef692ecaac095218a1650db60585 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 23:33:46 +0100
Subject: [PATCH 360/475] Save and load a mob's active effects, keep a player's
 hidden particles

A mob's effects were never written to its NBT and never read back, so
they were gone after a reload. LivingEntity.addAdditionalSaveData and
readAdditionalSaveData store them as active_effects.

A player's effect saved show_particles as always on and read it back
from show_icon, so an effect given with hideParticles came back with
particles.
---
 crates/horizon-client/src/brewing.rs          | 25 +++++++++++++-
 crates/horizon-client/src/effects.rs          |  5 +--
 crates/horizon-client/src/entity_nbt.rs       | 34 +++++++++++++++++++
 .../src/game/commands/effects.rs              | 21 +-----------
 crates/horizon-client/src/save.rs             | 10 +++---
 5 files changed, 67 insertions(+), 28 deletions(-)

diff --git a/crates/horizon-client/src/brewing.rs b/crates/horizon-client/src/brewing.rs
index f29bfc08b..cdd988a7a 100644
--- a/crates/horizon-client/src/brewing.rs
+++ b/crates/horizon-client/src/brewing.rs
@@ -7,7 +7,12 @@ use crate::{
     items::{ItemStack, Items},
 };
 use serde_json::Value;
-use std::{collections::HashSet, fs, path::Path, sync::Arc};
+use std::{
+    collections::{HashMap, HashSet},
+    fs,
+    path::Path,
+    sync::{Arc, OnceLock},
+};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Category {
@@ -94,6 +99,24 @@ pub fn effect(id: &str) -> Option<&'static EffectDef> {
     let id = id.trim_start_matches("minecraft:");
     EFFECTS.iter().find(|e| e.id == id)
 }
+/// Namespaced effect ids for mob effect storage.
+pub fn namespaced(id: &'static str) -> &'static str {
+    static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
+    IDS.get_or_init(|| {
+        EFFECTS
+            .iter()
+            .map(|e| {
+                (
+                    e.id,
+                    &*Box::leak(format!("minecraft:{}", e.id).into_boxed_str()),
+                )
+            })
+            .collect()
+    })
+    .get(id)
+    .copied()
+    .unwrap_or(id)
+}
 /// A `Potion`: id, name suffix (`item.minecraft.potion.effect.<name>`) and
 /// effects as (effect, duration ticks, amplifier).
 #[derive(Clone, Copy, Debug)]
diff --git a/crates/horizon-client/src/effects.rs b/crates/horizon-client/src/effects.rs
index 17dce93ab..16a7a273a 100644
--- a/crates/horizon-client/src/effects.rs
+++ b/crates/horizon-client/src/effects.rs
@@ -179,13 +179,14 @@ impl PlayerEffects {
         self.list.clear();
     }
     /// The effects of a saved player (`Player.active_effects`: id,
-    /// duration, amplifier, ambient, visible).
+    /// duration, amplifier, ambient, particles visible).
     pub fn from_saved(saved: &[(String, i32, i32, bool, bool)]) -> Self {
         let mut effects = Self::default();
-        for (id, duration, amplifier, ambient, _) in saved {
+        for (id, duration, amplifier, ambient, particles) in saved {
             if let Some(def) = brewing::effect(id) {
                 let mut e = EffectInstance::new(def.id, *duration, *amplifier);
                 e.ambient = *ambient;
+                e.visible = *particles;
                 effects.add(e);
             }
         }
diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 161ca12e9..22824805a 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -188,6 +188,26 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             map.remove(&horizon_world::nbt::JavaString::from(key));
         }
     }
+    // LivingEntity.addAdditionalSaveData: `active_effects` only when there are
+    // any (MobEffectInstance.CODEC; ambient and show_particles are at their
+    // defaults for a mob's effects).
+    if m.extra.effects.is_empty() {
+        map.remove(&horizon_world::nbt::JavaString::from("active_effects"));
+    } else {
+        let effects = m
+            .extra
+            .effects
+            .iter()
+            .map(|&(effect, duration, amplifier)| {
+                Tag::compound([
+                    ("id", string(crate::brewing::namespaced(effect))),
+                    ("amplifier", Tag::Byte(amplifier.clamp(0, 255) as u8 as i8)),
+                    ("duration", Tag::Int(duration)),
+                    ("show_icon", Tag::Byte(1)),
+                ])
+            });
+        map.insert("active_effects".into(), Tag::List(effects.collect()));
+    }
     if m.ticks_frozen > 0 {
         map.insert("TicksFrozen".into(), Tag::Int(m.ticks_frozen));
     } else {
@@ -712,6 +732,20 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     m.no_gravity = flag(tag, "NoGravity");
     m.glowing = flag(tag, "Glowing");
     m.ticks_frozen = number(tag.get("TicksFrozen")).unwrap_or(0) as i32;
+    // LivingEntity.readAdditionalSaveData: the saved `active_effects`, the last
+    // entry of an effect winning.
+    if let Some(Tag::List(effects)) = tag.get("active_effects") {
+        for e in effects {
+            let Some(def) = text(e.get("id")).and_then(|id| crate::brewing::effect(&id)) else {
+                continue;
+            };
+            let effect = crate::brewing::namespaced(def.id);
+            let duration = number(e.get("duration")).unwrap_or(0) as i32;
+            let amplifier = number(e.get("amplifier")).unwrap_or(0) as i32;
+            m.extra.effects.retain(|x| x.0 != effect);
+            m.extra.effects.push((effect, duration, amplifier));
+        }
+    }
     m.silent = flag(tag, "Silent");
     m.invulnerable_flag = flag(tag, "Invulnerable");
     if m.species() == crate::mobs::Species::Bat {
diff --git a/crates/horizon-client/src/game/commands/effects.rs b/crates/horizon-client/src/game/commands/effects.rs
index 65d6592f7..85ccc398f 100644
--- a/crates/horizon-client/src/game/commands/effects.rs
+++ b/crates/horizon-client/src/game/commands/effects.rs
@@ -1,11 +1,10 @@
 //! `/effect` (EffectCommands) and `/enchant` (EnchantCommand).
 use super::{Arg, Context, Game, R, Target, err, texts};
 use horizon_client::{
-    brewing,
+    brewing::{self, namespaced},
     effects::EffectInstance,
     text::{self, Style, Text},
 };
-use std::{collections::HashMap, sync::OnceLock};
 
 /// `CommandResponseTracker` over targets: elements with a non-zero result.
 #[derive(Default)]
@@ -21,24 +20,6 @@ impl Tracker {
         }
     }
 }
-/// Namespaced effect ids for mob effect storage.
-fn namespaced(id: &'static str) -> &'static str {
-    static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
-    IDS.get_or_init(|| {
-        brewing::EFFECTS
-            .iter()
-            .map(|e| {
-                (
-                    e.id,
-                    &*Box::leak(format!("minecraft:{}", e.id).into_boxed_str()),
-                )
-            })
-            .collect()
-    })
-    .get(id)
-    .copied()
-    .unwrap_or(id)
-}
 fn effect_name(id: &str) -> Text {
     Text::translate(&format!("effect.minecraft.{id}"), &[])
 }
diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs
index 5431adcd6..f965cf406 100644
--- a/crates/horizon-client/src/save.rs
+++ b/crates/horizon-client/src/save.rs
@@ -2763,7 +2763,7 @@ pub struct Level {
     pub xp_seed: i32,
     /// ServerPlayer.seenCredits: the end poem has been shown.
     pub seen_credits: bool,
-    /// Player.active_effects: (id, duration, amplifier, ambient, show_icon).
+    /// Player.active_effects: (id, duration, amplifier, ambient, show_particles).
     pub active_effects: Vec<(String, i32, i32, bool, bool)>,
     /// Player.EnderItems: the ender chest inventory (27 slots).
     pub ender_items: Vec<Option<crate::items::ItemStack>>,
@@ -3043,7 +3043,7 @@ impl Level {
                         get("duration").unwrap_or(0) as i32,
                         get("amplifier").unwrap_or(0) as i32,
                         get("ambient").unwrap_or(0) != 0,
-                        get("show_icon").is_none_or(|v| v != 0),
+                        get("show_particles").is_none_or(|v| v != 0),
                     ))
                 })
                 .collect(),
@@ -3145,14 +3145,14 @@ impl Level {
                 Tag::List(
                     self.active_effects
                         .iter()
-                        .map(|(id, duration, amplifier, ambient, icon)| {
+                        .map(|(id, duration, amplifier, ambient, particles)| {
                             Tag::compound([
                                 ("id", string(id)),
                                 ("duration", Tag::Int(*duration)),
                                 ("amplifier", Tag::Byte(*amplifier as i8)),
                                 ("ambient", Tag::Byte(i8::from(*ambient))),
-                                ("show_particles", Tag::Byte(1)),
-                                ("show_icon", Tag::Byte(i8::from(*icon))),
+                                ("show_particles", Tag::Byte(i8::from(*particles))),
+                                ("show_icon", Tag::Byte(1)),
                             ])
                         })
                         .collect(),

From 9266e0c7c9b3e633971555657aafe033b9ba3c1f Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 23:34:03 +0100
Subject: [PATCH 361/475] Mobs are pushed by flowing water and lava

---
 .../examples/probe/mob_ai_probe.rs            |   1 +
 crates/horizon-client/src/game/creatures.rs   |   1 +
 crates/horizon-client/src/mobs.rs             |   2 +
 crates/horizon-client/src/mobs/living.rs      | 122 ++++++++++++++++++
 4 files changed, 126 insertions(+)

diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs
index 5b6c26d2f..9c7eed643 100644
--- a/crates/horizon-client/examples/probe/mob_ai_probe.rs
+++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs
@@ -1081,6 +1081,7 @@ pub fn main() -> horizon_client::Result<()> {
                     world: &world,
                     registry,
                     facts: &facts,
+                    fluid_tables: &motion.fluids,
                     movement: &motion.blocks,
                     collision: &collision,
                     data: &data,
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index f6961ab13..951db09ac 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -401,6 +401,7 @@ impl Game<'_> {
             world: &self.world,
             registry: self.pack.assets.registry,
             facts: self.res.facts(),
+            fluid_tables: &self.motion.fluids,
             movement: &self.motion.blocks,
             collision: self.collision,
             data: self.res.mob_data(),
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index f4086216d..81f81f330 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -1560,6 +1560,8 @@ pub struct MobWorld<'a> {
     pub world: &'a World,
     pub registry: &'a horizon_world::registry::BlockRegistry,
     pub facts: &'a BlockFacts,
+    /// Fluid states and flow facts, for the currents that push mobs.
+    pub fluid_tables: &'a crate::motion::FluidResources,
     pub movement: &'a horizon_world::movement_properties::BoundMovementProperties,
     pub collision: &'a BlockCollisionRegistry<'a>,
     pub data: &'a MobData,
diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs
index 394821ace..ce3183721 100644
--- a/crates/horizon-client/src/mobs/living.rs
+++ b/crates/horizon-client/src/mobs/living.rs
@@ -9,8 +9,15 @@ use crate::{
 };
 use horizon_core::{
     geometry::{Aabb, Vec3, trig},
+    position::BlockPos,
     random::RandomSource,
 };
+use horizon_world::{
+    entity_fluid::{CurrentAccumulator, CurrentTarget},
+    fluid::{FluidKind, FluidState},
+    fluid_flow::{FluidFlowWorld, flow_at},
+    registry::BlockStateId,
+};
 
 /// `Entity.moveDist`, `flyDist` and `nextStep`.
 #[derive(Clone, Copy, Debug)]
@@ -36,6 +43,50 @@ pub struct Fluids {
     pub in_lava: bool,
     pub eye_in_water: bool,
 }
+/// `FluidFlowWorld` over the mob's scene: the neighbours a flow vector reads.
+struct FlowScene<'a, 'w>(&'a MobWorld<'w>);
+impl FluidFlowWorld for FlowScene<'_, '_> {
+    type Error = std::convert::Infallible;
+    type Block = BlockStateId;
+    fn fluid(&mut self, p: BlockPos) -> Result<FluidState, Self::Error> {
+        Ok(self.0.fluid_tables.fluid(self.0.world.block(p.x, p.y, p.z)))
+    }
+    fn block(&mut self, p: BlockPos) -> Result<BlockStateId, Self::Error> {
+        Ok(self.0.world.block(p.x, p.y, p.z))
+    }
+    fn blocks_fluid_flow(&self, s: BlockStateId) -> bool {
+        self.0.fluid_tables.blocks_flow(s)
+    }
+    fn is_ice_class(&self, s: BlockStateId) -> bool {
+        self.0.fluid_tables.ice(s)
+    }
+    fn is_face_sturdy(
+        &mut self,
+        s: BlockStateId,
+        _: BlockPos,
+        d: horizon_core::geometry::Direction,
+    ) -> Result<bool, Self::Error> {
+        Ok(self.0.fluid_tables.sturdy(s, d))
+    }
+}
+/// The mob's velocity, for `CurrentAccumulator::apply_to`.
+struct Pushed<'a>(&'a mut Vec3);
+impl CurrentTarget for Pushed<'_> {
+    type Error = std::convert::Infallible;
+    fn is_player_class(&self) -> bool {
+        false
+    }
+    fn velocity(&mut self) -> Result<Vec3, Self::Error> {
+        Ok(*self.0)
+    }
+    fn add_delta_movement(&mut self, delta: Vec3) -> Result<(), Self::Error> {
+        let sum = Vec3::new(self.0.x + delta.x, self.0.y + delta.y, self.0.z + delta.z);
+        if delta.is_finite() && sum.is_finite() {
+            *self.0 = sum;
+        }
+        Ok(())
+    }
+}
 pub fn wrap(a: f32) -> f32 {
     let mut a = a % 360.0;
     if a >= 180.0 {
@@ -140,6 +191,40 @@ impl MobWorld<'_> {
         }
         out
     }
+    /// Entity.updateFluidHeightAndDoFluidPushing's currents over the deflated
+    /// box: the flow of every water and lava block it touches, summed (a thin
+    /// fluid layer scales its flow down), as (water, lava).
+    fn fluid_currents(&self, bounds: Aabb) -> (CurrentAccumulator, CurrentAccumulator) {
+        let base_y = bounds.min_position().y;
+        let b = bounds.deflate(Vec3::new(0.001, 0.001, 0.001));
+        let (lo, hi) = (b.min_position(), b.max_position());
+        let mut scene = FlowScene(self);
+        let (mut water, mut lava) = (CurrentAccumulator::default(), CurrentAccumulator::default());
+        for x in lo.x.floor() as i32..=(hi.x.ceil() as i32 - 1) {
+            for y in lo.y.floor() as i32..=(hi.y.ceil() as i32 - 1) {
+                for z in lo.z.floor() as i32..=(hi.z.ceil() as i32 - 1) {
+                    let p = BlockPos::new(x, y, z);
+                    let state = self.fluid_tables.fluid(self.world.block(x, y, z));
+                    let current = match state.kind() {
+                        FluidKind::Empty => continue,
+                        FluidKind::Water | FluidKind::FlowingWater => &mut water,
+                        FluidKind::Lava | FluidKind::FlowingLava => &mut lava,
+                    };
+                    let surface = f64::from(y) + self.fluid_height(x, y, z).1;
+                    if surface < lo.y {
+                        continue;
+                    }
+                    current.height = current.height.max(surface - base_y);
+                    let mut flow = flow_at(&mut scene, state, p).unwrap_or(Vec3::ZERO);
+                    if current.height < 0.4 {
+                        flow = flow.scale(current.height);
+                    }
+                    current.accumulate(flow);
+                }
+            }
+        }
+        (water, lava)
+    }
     /// `BlockState.getCollisionShape(level, pos)` (the empty collision
     /// context) as boxes in the world.
     pub fn block_collision_boxes(&self, x: i32, y: i32, z: i32) -> Vec<Aabb> {
@@ -334,6 +419,27 @@ impl Mob {
     pub fn is_in_liquid(&self) -> bool {
         self.fluids.in_water || self.fluids.in_lava
     }
+    /// `Entity.isPushedByFluid`: water animals, turtles, axolotls, frogs and
+    /// nautiluses keep their own course.
+    fn pushed_by_fluid(&self) -> bool {
+        use super::Species as S;
+        !matches!(
+            self.species(),
+            S::Tadpole
+                | S::Cod
+                | S::Salmon
+                | S::TropicalFish
+                | S::Pufferfish
+                | S::Squid
+                | S::GlowSquid
+                | S::Dolphin
+                | S::Turtle
+                | S::Axolotl
+                | S::Frog
+                | S::Nautilus
+                | S::ZombieNautilus
+        )
+    }
     fn affected_by_fluids(&self) -> bool {
         true
     }
@@ -450,6 +556,22 @@ impl Mob {
     pub(super) fn update_fluids(&mut self, w: &MobWorld, events: &mut Vec<MobEvent>) {
         let was_touching_water = self.fluids.in_water;
         self.fluids = w.fluids(self.bounds(), self.eye_y());
+        // EntityFluidInteraction.applyCurrentTo: the flow pushes the mob.
+        if (self.fluids.in_water || self.fluids.in_lava) && self.pushed_by_fluid() {
+            let (water, lava) = w.fluid_currents(self.bounds());
+            let lava_scale = if w.nether {
+                0.007
+            } else {
+                0.0023333333333333335
+            };
+            let mut pushed = Pushed(&mut self.velocity);
+            if water.height > 0.0 {
+                let _ = water.apply_to(&mut pushed, 0.014);
+            }
+            if lava.height > 0.0 {
+                let _ = lava.apply_to(&mut pushed, lava_scale);
+            }
+        }
         if self.fluids.in_water {
             self.fall_distance = 0.0;
             if !was_touching_water && !self.first_tick {

From 2c894783aa34187aa421280d092827e9f3485373 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 23:37:14 +0100
Subject: [PATCH 362/475] Bubble columns lift and drag mobs, items and ender
 pearls

---
 crates/horizon-client/src/game.rs           |  9 +++
 crates/horizon-client/src/game/creatures.rs | 15 +++++
 crates/horizon-client/src/mobs/living.rs    | 11 ++++
 crates/horizon-client/src/motion.rs         |  2 +-
 crates/horizon-client/src/motion/fluids.rs  | 61 +++++++++++++++++++++
 5 files changed, 97 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index db49087b2..387ec592f 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2366,6 +2366,15 @@ impl Game<'_> {
                 no_physics,
                 &self.res.motion().fluids,
             );
+            // Entity.applyEffectsFromBlocks: bubble columns lift or drag the item.
+            horizon_client::motion::bubble_column_push(
+                &self.world,
+                self.pack.assets.registry,
+                self.res.facts(),
+                self.collision,
+                item.bounds(),
+                &mut item.velocity,
+            );
             cells.moved(i, item.previous, item.position);
             // ItemEntity.tick: merge every 2 ticks while moving between
             // blocks, every 40 otherwise, before the lifetime check.
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index f6961ab13..cfac5f8e4 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -1941,6 +1941,21 @@ impl Game<'_> {
                 if shooter.is_some() {
                     p.owner = Some(Who::Player);
                 }
+                // ThrownEnderpearl.onAboveBubbleColumn / onInsideBubbleColumn.
+                if keep && hit == Hit::None && matches!(p.kind, ProjectileKind::EnderPearl) {
+                    let (at, h) = (p.position, 0.125);
+                    horizon_client::motion::bubble_column_push(
+                        w.world,
+                        w.registry,
+                        w.facts,
+                        w.collision,
+                        Aabb::new(
+                            Vec3::new(at.x - h, at.y, at.z - h),
+                            Vec3::new(at.x + h, at.y + 2.0 * h, at.z + h),
+                        ),
+                        &mut p.velocity,
+                    );
+                }
                 if let Some(a) = p.arrow.as_mut() {
                     arrow_events.extend(a.events.drain(..).map(|e| (p.position, e)));
                 }
diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs
index 394821ace..6d30cf231 100644
--- a/crates/horizon-client/src/mobs/living.rs
+++ b/crates/horizon-client/src/mobs/living.rs
@@ -428,6 +428,17 @@ impl Mob {
         // Entity.checkSupportingBlock
         self.supporting = self.supporting_block(w, moved);
         self.movement_emission(w, moved, events);
+        // Entity.applyEffectsFromBlocks: bubble columns push the mob.
+        if crate::motion::bubble_column_push(
+            w.world,
+            w.registry,
+            w.facts,
+            w.collision,
+            self.bounds(),
+            &mut self.velocity,
+        ) {
+            self.fall_distance = 0.0;
+        }
     }
     /// LivingEntity.checkFallDamage: the fluid state refreshed out of water
     /// (touching water resets the fall), then Entity.checkFallDamage.
diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index dfdc3f168..7b88d9af8 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -44,7 +44,7 @@ use std::{
 
 pub(crate) mod environment;
 mod fluids;
-pub use fluids::{FluidResources, FluidTags, LAVA, PlayerFluids, WATER};
+pub use fluids::{FluidResources, FluidTags, LAVA, PlayerFluids, WATER, bubble_column_push};
 
 pub struct MotionResources {
     pub attributes: Arc<Catalog>,
diff --git a/crates/horizon-client/src/motion/fluids.rs b/crates/horizon-client/src/motion/fluids.rs
index 894e6d907..e3751f0c6 100644
--- a/crates/horizon-client/src/motion/fluids.rs
+++ b/crates/horizon-client/src/motion/fluids.rs
@@ -119,6 +119,67 @@ impl PlayerMotion {
         !self.fluids.first_tick && self.fluids.interaction.is_in_fluid(&FluidTags, LAVA)
     }
 }
+/// `BubbleColumnBlock.entityInside` for an entity that is not the player (a mob,
+/// a dropped item, an ender pearl): the bubble columns its box touches push it
+/// up or drag it down, harder at the surface (`Entity.handleOnAboveBubbleColumn`
+/// and `handleOnInsideBubbleColumn`). Returns whether it was inside a column
+/// below the surface, which resets its fall distance.
+pub fn bubble_column_push(
+    world: &World,
+    registry: &horizon_world::registry::BlockRegistry,
+    facts: &crate::blocks::BlockFacts,
+    collision: &horizon_world::block_collision::BlockCollisionRegistry<'_>,
+    bounds: Aabb,
+    velocity: &mut Vec3,
+) -> bool {
+    let b = bounds.deflate(Vec3::new(
+        f64::from(1.0e-5f32),
+        f64::from(1.0e-5f32),
+        f64::from(1.0e-5f32),
+    ));
+    let (lo, hi) = (b.min_position(), b.max_position());
+    let mut reset_fall = false;
+    for x in lo.x.floor() as i32..=(hi.x.ceil() as i32 - 1) {
+        for y in lo.y.floor() as i32..=(hi.y.ceil() as i32 - 1) {
+            for z in lo.z.floor() as i32..=(hi.z.ceil() as i32 - 1) {
+                let state = world.block(x, y, z);
+                if &*facts.get(state).name != "minecraft:bubble_column" {
+                    continue;
+                }
+                let drag = registry
+                    .state(state)
+                    .and_then(|s| s.properties.get("drag"))
+                    .is_some_and(|d| d == "true");
+                let above = world.block(x, y + 1, z);
+                // stateAbove.getCollisionShape(level, pos): the shape is asked
+                // at the column's own position.
+                let mut scene = SceneCollisions {
+                    world,
+                    binding: collision,
+                    subject: None,
+                };
+                let context = horizon_world::collision_context::CollisionContext::empty(false);
+                let nothing_above = collision
+                    .collision_shape_with_context(
+                        &mut scene,
+                        above,
+                        BlockPos::new(x, y, z),
+                        &context,
+                    )
+                    .is_ok_and(|shape| shape.is_empty())
+                    && facts.get(above).fluid == crate::blocks::Fluid::None;
+                velocity.y = match (nothing_above, drag) {
+                    (true, true) => (-0.9_f64).max(velocity.y - 0.03),
+                    (true, false) => 1.8_f64.min(velocity.y + 0.1),
+                    (false, true) => (-0.3_f64).max(velocity.y - 0.03),
+                    (false, false) => 0.7_f64.min(velocity.y + 0.06),
+                };
+                reset_fall |= !nothing_above;
+            }
+        }
+    }
+    reset_fall
+}
 /// Which fluids `FluidTags.WATER` and `FluidTags.LAVA` hold.
 pub struct FluidTags;
 impl FluidMembership for FluidTags {

From 9ada76e00a53c83f164a7996246fffa7ee419e62 Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Mon, 26 Oct 2026 23:41:13 +0100
Subject: [PATCH 363/475] Restore the lam-alef madda and hamza ligature rows in
 FORMS

---
 crates/horizon-client/src/bidi.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/bidi.rs b/crates/horizon-client/src/bidi.rs
index 98924027c..c9c6caac7 100644
--- a/crates/horizon-client/src/bidi.rs
+++ b/crates/horizon-client/src/bidi.rs
@@ -71,7 +71,7 @@ const FORMS: &[(u32, u32)] = &[
     (0x0636, 0xFEBD), (0x0637, 0xFEC1), (0x0638, 0xFEC5), (0x0639, 0xFEC9), (0x063A, 0xFECD),
     (0x0641, 0xFED1), (0x0642, 0xFED5), (0x0643, 0xFED9), (0x0644, 0xFEDD), (0x0645, 0xFEE1),
     (0x0646, 0xFEE5), (0x0647, 0xFEE9), (0x0648, 0xFEED), (0x0649, 0xFEEF), (0x064A, 0xFEF1),
-    (0xFEF9, 0xFEF9), (0xFEFB, 0xFEFB),
+    (0xFEF5, 0xFEF5), (0xFEF7, 0xFEF7), (0xFEF9, 0xFEF9), (0xFEFB, 0xFEFB),
 ];
 
 /// `Bidi_Mirroring_Glyph` (`UCharacter.getMirror`): each pair is two

From 111db2827b9b797baf1ce83548ffaa5e38c1ffbd Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Mon, 26 Oct 2026 23:46:29 +0100
Subject: [PATCH 364/475] ci: full-parity and PR parity jobs on playhorizon,
 not the desktop

The maintainer asked that CI stop using his desktop (2026-10-26). playhorizon's
runner now carries horizon-game and the desktop's runner none of the job labels;
full-parity jobs go to playhorizon only, with a 6 h timeout on its 4 CPUs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/parity-main.yml |  4 ++--
 .github/workflows/parity.yml      | 16 ++++++++--------
 docs/release-flow.md              | 25 +++++++++++++++----------
 3 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/parity-main.yml b/.github/workflows/parity-main.yml
index 70fb33796..4840b98be 100644
--- a/.github/workflows/parity-main.yml
+++ b/.github/workflows/parity-main.yml
@@ -25,8 +25,8 @@ jobs:
   parity-main:
     # A Mac mini runner of its own (ludovics-mac-mini-2 holds only this label since 2026-10-26): behind PR parity jobs
     # this run waited 2 h while every merge replaced the pending one, and on the release runner a release then waited
-    # behind the next run. PR parity jobs have ludovics-mac-mini and the desktop. Not the desktop: a job slowed down
-    # because the maintainer came back could time out, and a failure here bisects and comments on merges.
+    # behind the next run. PR parity jobs have ludovics-mac-mini and playhorizon. Not playhorizon: its 4 CPUs
+    # make a core-crate run several times longer, and a failure here bisects and comments on merges.
     runs-on: [self-hosted, macOS, horizon-parity-main]
     timeout-minutes: 240  # a core-crate batch reruns ~300 harnesses (~60-90 min), a bisect a few rounds of the failures
     steps:
diff --git a/.github/workflows/parity.yml b/.github/workflows/parity.yml
index b90ad9968..c850c17aa 100644
--- a/.github/workflows/parity.yml
+++ b/.github/workflows/parity.yml
@@ -1,6 +1,6 @@
 name: parity
-# The vanilla harnesses a pull request's changes can affect, on the Mac mini's runner, which holds the maintainer's
-# own Minecraft files (Horizon never downloads the game). Called by ci.yml for pull requests from this repository
+# The vanilla harnesses a pull request's changes can affect, on the Mac mini's runner or playhorizon's, which hold the
+# maintainer's own Minecraft files (Horizon never downloads the game). Called by ci.yml for pull requests from this repository
 # and by run-parity.yml when a maintainer labels a fork's pull request run-parity. See docs/release-flow.md.
 on:
   workflow_call:
@@ -16,8 +16,8 @@ on:
       full:
         description: >-
           The pull request carries the full-parity label (a change every harness reaches, such as a crate split): it
-          runs on the desktop's runner only, so the Mac mini's runners stay free for the others. While the desktop is
-          in use the job waits for it.
+          runs on playhorizon's runner only, so the Mac mini's runners stay free for the others. While that runner is
+          busy the job waits for it.
         type: boolean
         default: false
 permissions:
@@ -28,10 +28,10 @@ env:
 
 jobs:
   parity:
-    runs-on: ${{ inputs.full && fromJSON('["self-hosted", "horizon-game", "ludodesktop"]') || fromJSON('["self-hosted", "horizon-game"]') }}
-    # A change to core crates reruns ~350 harnesses: ~60-90 min on the Mac mini, ~35 min on the desktop, longer if
-    # someone comes back to the desktop meanwhile (the job then goes on with 2 threads).
-    timeout-minutes: ${{ inputs.full && 300 || 120 }}
+    runs-on: ${{ inputs.full && fromJSON('["self-hosted", "horizon-game", "playhorizon"]') || fromJSON('["self-hosted", "horizon-game"]') }}
+    # A change to core crates reruns ~350 harnesses: ~60-90 min on the Mac mini; on playhorizon (4 of its 8 vCPUs, 4
+    # harnesses at a time) up to a few hours, and any pull request's job may land there.
+    timeout-minutes: ${{ inputs.full && 360 || 180 }}
     steps:
       - uses: actions/checkout@v4
         with:
diff --git a/docs/release-flow.md b/docs/release-flow.md
index 8373f2bf6..ed7be2418 100644
--- a/docs/release-flow.md
+++ b/docs/release-flow.md
@@ -13,7 +13,7 @@ reopened; labels never start it):
 | Job | Runs on | What | Time |
 | --- | --- | --- | --- |
 | `verify` | GitHub `ubuntu-latest` | Public-tree check, Python tests, rustfmt, clippy with warnings denied, Rust tests. Dependencies and the workspace build come from a cache saved by main's runs | ~4 min cold, less warm |
-| `parity / parity` | A runner with the label `horizon-game`: the Mac mini's two, and the desktop's while nobody uses it (below) | Only for a change to a harness, an oracle, a probe or the runner (or the `run-parity` label): the vanilla harnesses the change can affect (`tools/parity.py --changed <base>`). Other pull requests skip it: [parity-main](#parity-on-main) checks them on main | seconds when nothing is affected; minutes per affected harness |
+| `parity / parity` | A runner with the label `horizon-game`: the Mac mini's and playhorizon's (below) | Only for a change to a harness, an oracle, a probe or the runner (or the `run-parity` label): the vanilla harnesses the change can affect (`tools/parity.py --changed <base>`). Other pull requests skip it: [parity-main](#parity-on-main) checks them on main | seconds when nothing is affected; minutes per affected harness |
 
 Pushes to main run `verify` only; the nightly audit covers main's harnesses.
 
@@ -29,12 +29,12 @@ repository, `run-parity.yml` for a fork's pull request a maintainer labels `run-
 
 A pull request every harness reaches (a crate split moves files every probe links: #2160 ran all 352 harnesses, 71
 minutes on a Mac mini runner, while five other pull requests' jobs queued behind it) carries the `full-parity` label:
-its job runs on the desktop's runner only (8 harnesses at a time), and waits for it while the desktop is in use
-instead of taking a Mac mini runner. Labels don't start `checks`: add it when opening the pull request
+its job runs on playhorizon's runner only (4 harnesses at a time), and waits for it while that runner is busy
+instead of taking the Mac mini's. Labels don't start `checks`: add it when opening the pull request
 (`gh pr create --label full-parity`), or before the next push.
 
 Horizon never downloads the game, so harnesses that compare with vanilla run only where the maintainer's own
-copy is: the Mac mini, his Linux desktop and playhorizon (below). Their runners run as the maintainer's account and keep their checkout
+copy is: the Mac mini and playhorizon (below). Their runners run as the maintainer's account and keep their checkout
 between runs (`clean: false`), so the probes build incrementally into `.local/parity-target` and earlier passes
 stand.
 
@@ -83,8 +83,9 @@ release's macOS build back. Each keeps its own checkout, `target/` and Rust inst
 `_work/horizon/shared-local` links to the first's, so they share the vanilla data, the preparations (one at a
 time, under a lock) and the parity passes and slots.
 
-**The desktop's runner.** `ludodesktop-horizon` (labels `self-hosted`, `Linux`, `X64`, `ludodesktop`, and
-`horizon-game` once a full trial has passed there) runs on the maintainer's Linux desktop while nobody uses it: its
+**The desktop's runner (retired).** On 2026-10-26 the maintainer asked that CI stop using his desktop: its services are
+stopped and `ludodesktop-horizon` has no label a job asks for (only `self-hosted`, `Linux`, `X64`), so nothing waits for
+it. What follows describes it as it ran. It ran on the maintainer's Linux desktop while nobody used it: its
 screen locked, or untouched for 15 minutes (his rule, 2026-10-26). `tools/ci/linux-runner.sh install`, run there as
 him, registers it and installs two systemd user services: `horizon-runner` (the runner, in
 `~/.actions-runners/horizon`, nice 19, in `horizon-ci.slice` with CPU and I/O weight 20, half the threads (on all of
@@ -105,12 +106,16 @@ and its failures bisect and comment on merges.
 
 **playhorizon's runner.** `playhorizon-horizon` runs on a server a hosting partner lends the project (Ubuntu, 8
 AMD EPYC threads, 30 GB, in Detroit; reachable only through the maintainer's tailnet). Nobody sits at it, so the
-watcher never pauses it except by hand, and it gets the machine: `RUNNER_CPUS=7 RUNNER_MEMORY=24 RUNNER_JOBS=6`.
+watcher never pauses it except by hand. It gets half the machine: `RUNNER_MEMORY=24`, `CARGO_BUILD_JOBS` and the
+harness slots at 4, and a drop-in (`~/.config/systemd/user/horizon-runner.service.d/cpus.conf`) that starts it under
+`taskset -c 4-7`, so CPUs 0-3 stay free for benchmarks pinned there (the user slice can't set `AllowedCPUs`: systemd
+doesn't delegate the cpuset controller to it).
 Without Nix, `linux-runner.sh` takes the build libraries, the JDK, sccache, Xvfb and Mesa's software Vulkan
 (lavapipe; there is no GPU) from apt, and Python 3.13 from uv. The partner can reach the machine, so gh is not
 logged in there: the registration token comes from another machine (`RUNNER_TOKEN`), and no job with secrets may
-run there (parity has none). It is also a parity host (`playhorizon` in `tools/parity_hosts.json`, 6 jobs). Like
-the desktop's, it gets the `horizon-game` label only once a full trial has passed there.
+run there (parity has none). It is also a parity host (`playhorizon` in `tools/parity_hosts.json`, 6 jobs). Since
+2026-10-26 it has the `horizon-game` label: pull requests' parity jobs run there or on the Mac mini, and `full-parity`
+ones only there.
 
 ## Merging
 
@@ -218,7 +223,7 @@ How releases are numbered, and how installs from before 0.2 reach it: [versionin
 | `release-now` | Releases as soon as main's checks pass, without waiting for merges to settle |
 | `skip-release` | Doesn't trigger a release and isn't listed in the notes |
 | `run-parity` | Runs the parity job once on a fork's pull request |
-| `full-parity` | Runs the pull request's parity job on the desktop's runner only (a change every harness reaches) |
+| `full-parity` | Runs the pull request's parity job on playhorizon's runner only (a change every harness reaches) |
 | `parity-regression` | Opened by the nightly audit for a harness that fails on main |
 | `release-blocker` | On an issue: no game release is published while it is open ([One channel](#one-channel)) |
 

From 5b5ebfcce3ecbcae6c9a5811c83ac039f867da32 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Louis=20Nordb=C3=B8?=
 <179310784+Louistuis@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:47:57 +0100
Subject: [PATCH 365/475] Walk turtles at their own pace so their feet stop
 flailing (#1776)

Turtles used the default MoveControl, which sets the speed straight to
speedModifier * movement speed (0.25 on a stroll). Vanilla gives them
TurtleMoveControl: updateSpeed halves the speed every tick on land (never
below 0.06), and in water lifts the turtle 0.005 and cuts the speed away
from home (0.08) or as a baby (0.06); tick then eases the speed an eighth
of the way to the wanted one, faces the wanted point with the body, lifts
towards it and never jumps. On land that settles at 0.08375, so a
strolling turtle covered about nine times the ground per tick that
vanilla's does (the input is speed squared). TurtleModel swings the legs
by 8 * walkSpeed at walkPos * 5, so the walk animation fed by that motion
spun the feet erratically.

This only fixes the move control. Swimming still differs from vanilla:
Turtle.travelInWater (moveRelative(0.1F), 0.9 drag, sinking 0.005 without
a target unless heading home within 20 blocks of it), TurtlePathNavigation
and the turtle goal set are not ported yet; turtles keep the generic
fluid travel and goals for now.

Vanilla: Turtle$TurtleMoveControl.tick / updateSpeed, Turtle.<init>,
TurtleModel.setupAnim, LivingEntity.updateWalkAnimation.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/mobs/control.rs |   5 +-
 crates/horizon-client/src/mobs/turtle.rs  | 194 +++++++++++++++++++++-
 2 files changed, 196 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/mobs/control.rs b/crates/horizon-client/src/mobs/control.rs
index 3df557362..bc4d8235e 100644
--- a/crates/horizon-client/src/mobs/control.rs
+++ b/crates/horizon-client/src/mobs/control.rs
@@ -6,7 +6,7 @@ use horizon_core::geometry::trig;
 /// `2.5000003E-7F` widened: the squared distance controls treat as arrived.
 const ARRIVED: f64 = 2.500_000_3e-7_f32 as f64;
 /// `1.0E-5F` widened.
-const EPSILON: f64 = 1.0e-5_f32 as f64;
+pub(super) const EPSILON: f64 = 1.0e-5_f32 as f64;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum Operation {
@@ -135,6 +135,9 @@ impl Mob {
         if self.species() == super::Species::Rabbit {
             return super::rabbit::move_control(self, w);
         }
+        if self.species() == super::Species::Turtle {
+            return super::turtle::move_control(self);
+        }
         let attr_speed = self.movement_speed();
         match self.ai.mov.kind {
             MoveKind::Custom => super::ai::custom_move_control(self, w, events),
diff --git a/crates/horizon-client/src/mobs/turtle.rs b/crates/horizon-client/src/mobs/turtle.rs
index 98dd5b558..e56973384 100644
--- a/crates/horizon-client/src/mobs/turtle.rs
+++ b/crates/horizon-client/src/mobs/turtle.rs
@@ -1,12 +1,17 @@
 //! Turtles (`Turtle`): the egg a bred mother carries (`TurtleBreedGoal`), her
 //! walk home (`TurtleGoHomeGoal`) and the egg she digs into the sand
 //! (`TurtleLayEggGoal`). `extra.flag` is `hasEgg`, `extra.flag2` `isLayingEgg`,
-//! `extra.counter` `layEggCounter` and `extra.home` `homePos`.
+//! `extra.counter` `layEggCounter` and `extra.home` `homePos`. Its own
+//! `TurtleMoveControl` sets the speed it walks and swims at. Not ported yet:
+//! `Turtle.travelInWater` (swimming still uses the generic fluid travel),
+//! `TurtlePathNavigation` and the rest of the turtle goal set, so movement in
+//! water still differs from vanilla.
 use super::{
     Mob, MobEvent, MobWorld,
+    control::{EPSILON, Operation, rotlerp},
     goals::{Breed, Cx, Goal, JUMP, MOVE, MoveToBlock, goal_clone, reduced},
 };
-use horizon_core::random::RandomSource;
+use horizon_core::{geometry::trig, random::RandomSource};
 
 pub fn register(m: &mut Mob) {
     let g = &mut m.ai.goals;
@@ -49,6 +54,45 @@ fn block_of(m: &Mob) -> [i32; 3] {
 fn is_sand(w: &MobWorld, p: [i32; 3]) -> bool {
     w.has_tag("minecraft:sand", w.block_name(p[0], p[1], p[2]))
 }
+/// `Turtle.TurtleMoveControl.updateSpeed`: slow in water away from home
+/// (slower still as a baby), and halved every tick on land, never under 0.06.
+fn update_speed(m: &mut Mob) {
+    if m.fluids.in_water {
+        m.velocity.y += 0.005;
+        if !close_to_home(m, 16.0) {
+            m.set_speed((m.ai.speed / 2.0).max(0.08));
+        }
+        if m.is_baby() {
+            m.set_speed((m.ai.speed / 3.0).max(0.06));
+        }
+    } else if m.on_ground {
+        m.set_speed((m.ai.speed / 2.0).max(0.06));
+    }
+}
+/// `Turtle.TurtleMoveControl.tick`: ease the speed an eighth of the way to
+/// the wanted one each tick (after `updateSpeed` cut it), face the wanted
+/// point and lift towards it; no jumping, and the operation is never reset.
+pub fn move_control(m: &mut Mob) {
+    update_speed(m);
+    if m.ai.mov.operation != Operation::MoveTo || m.ai.nav.is_done() {
+        m.set_speed(0.0);
+        return;
+    }
+    let [wx, wy, wz] = m.ai.mov.wanted;
+    let (xd, yd, zd) = (wx - m.position.x, wy - m.position.y, wz - m.position.z);
+    let dist = (xd * xd + yd * yd + zd * zd).sqrt();
+    if dist < EPSILON {
+        m.set_speed(0.0);
+        return;
+    }
+    let y_rot = trig::atan2_degrees(zd, xd) - 90.0;
+    m.yaw = rotlerp(m.yaw, y_rot, 90.0);
+    m.body_yaw = m.yaw;
+    let wanted = (m.ai.mov.speed_modifier * m.movement_speed()) as f32;
+    // Mth.lerp(0.125F, getSpeed(), wanted).
+    m.set_speed(m.ai.speed + 0.125 * (wanted - m.ai.speed));
+    m.velocity.y += f64::from(m.ai.speed) * (yd / dist) * 0.1;
+}
 /// `Turtle.aiStep`: while digging, sand crumbs fly every fifth tick.
 pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     if m.alive() && m.extra.flag2 && m.extra.counter >= 1 && m.extra.counter % 5 == 0 {
@@ -207,3 +251,149 @@ impl Goal for GoHome {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::mobs::{
+        Species,
+        path::{Path, PathNode, PathType},
+    };
+    use horizon_core::geometry::Vec3;
+    use std::sync::Arc;
+
+    /// A turtle (movement speed 0.25) strolling (`speedModifier` 1.0) to a
+    /// point ten blocks ahead along a path it has not finished.
+    fn strolling_turtle() -> Mob {
+        let mut kind = crate::mobs::sensor_scan_tests::kind();
+        let k = Arc::make_mut(&mut kind);
+        k.id = "minecraft:turtle".into();
+        k.species = Species::Turtle;
+        k.speed = 0.25;
+        k.step_height = 1.0;
+        let mut m = Mob::new(1, kind, Vec3::ZERO, 0.0);
+        m.on_ground = true;
+        let node = PathNode {
+            x: 0,
+            y: 0,
+            z: 10,
+            kind: PathType::Walkable,
+        };
+        m.ai.nav.path = Some(Path {
+            nodes: vec![node],
+            next: 0,
+            target: [0, 0, 10],
+            dist_to_target: 0.0,
+            reached: true,
+        });
+        m.ai.mov.set_wanted(0.0, 0.0, 10.0, 1.0);
+        m
+    }
+    fn speeds(m: &mut Mob, ticks: usize) -> Vec<f32> {
+        (0..ticks)
+            .map(|_| {
+                move_control(m);
+                assert_eq!(m.ai.zza, m.ai.speed, "setSpeed sets the forward input");
+                m.ai.speed
+            })
+            .collect()
+    }
+
+    #[test]
+    fn walks_on_land_at_a_third_of_its_movement_speed() {
+        // TurtleMoveControl.tick on the ground: updateSpeed makes it
+        // max(speed / 2, 0.06) = 0.06, then Mth.lerp(0.125F, 0.06, 0.25),
+        // every tick. The default MoveControl walked it at the full 0.25, so
+        // the walk animation (and TurtleModel's 8 * walkSpeed leg swing) ran
+        // about nine times too fast (#1776).
+        let mut m = strolling_turtle();
+        let land = 0.06_f32 + 0.125 * (0.25 - 0.06_f32);
+        assert_eq!(speeds(&mut m, 40), vec![land; 40]);
+        // Facing the wanted point, the body with it; it never jumps.
+        assert_eq!(m.body_yaw, m.yaw);
+        assert!(crate::mobs::living::wrap(m.yaw).abs() < 1.0e-3);
+        assert!(!m.ai.jump);
+        assert_eq!(m.ai.mov.operation, Operation::MoveTo);
+        assert_eq!(m.velocity.y, 0.0);
+    }
+
+    #[test]
+    fn water_speed_is_cut_away_from_home_and_for_babies() {
+        // updateSpeed in water near home: no cut, the lerp climbs towards
+        // 0.25, and it lifts the turtle 0.005 a tick. (Only the control's
+        // speed: Turtle.travelInWater is not ported.)
+        let mut m = strolling_turtle();
+        m.on_ground = false;
+        m.fluids.in_water = true;
+        let s = speeds(&mut m, 60);
+        assert_eq!(s[0], 0.125 * 0.25);
+        assert!(s.windows(2).all(|w| w[1] > w[0]) && s[59] > 0.24 && s[59] < 0.25);
+        assert!((m.velocity.y - 60.0 * 0.005).abs() < 1.0e-9);
+        // More than 16 blocks from home: max(speed / 2, 0.08) first.
+        let mut m = strolling_turtle();
+        m.on_ground = false;
+        m.fluids.in_water = true;
+        m.extra.home = Some([0, 0, 40]);
+        let far = 0.08_f32 + 0.125 * (0.25 - 0.08_f32);
+        assert_eq!(speeds(&mut m, 20), vec![far; 20]);
+        // A baby: max(speed / 3, 0.06).
+        let mut m = strolling_turtle();
+        m.on_ground = false;
+        m.fluids.in_water = true;
+        m.extra.age = -24000;
+        let young = 0.06_f32 + 0.125 * (0.25 - 0.06_f32);
+        assert_eq!(speeds(&mut m, 20), vec![young; 20]);
+    }
+
+    #[test]
+    fn stops_when_the_path_is_done_or_the_point_reached() {
+        let mut m = strolling_turtle();
+        m.ai.nav.stop();
+        assert_eq!(speeds(&mut m, 1), vec![0.0]);
+        let mut m = strolling_turtle();
+        m.ai.mov.set_wanted(0.0, 0.0, 0.0, 1.0);
+        assert_eq!(speeds(&mut m, 1), vec![0.0]);
+        // updateSpeed runs before the early return: a stopped turtle in
+        // water is still lifted 0.005, path done or not moving at all.
+        let mut m = strolling_turtle();
+        m.fluids.in_water = true;
+        m.ai.nav.stop();
+        assert_eq!(speeds(&mut m, 1), vec![0.0]);
+        assert_eq!(m.velocity.y, 0.005);
+        let mut m = strolling_turtle();
+        m.fluids.in_water = true;
+        m.ai.mov.operation = Operation::Wait;
+        assert_eq!(speeds(&mut m, 1), vec![0.0]);
+        assert_eq!(m.velocity.y, 0.005);
+    }
+
+    #[test]
+    fn lifts_towards_a_point_above_by_the_slope_of_the_way_there() {
+        // setDeltaMovement(... + getSpeed() * (dy / dist) * 0.1): two up,
+        // three across and ten ahead.
+        let mut m = strolling_turtle();
+        m.ai.mov.set_wanted(3.0, 2.0, 10.0, 1.0);
+        let speed = speeds(&mut m, 1)[0];
+        let dist = (3.0_f64 * 3.0 + 2.0 * 2.0 + 10.0 * 10.0).sqrt();
+        assert_eq!(m.velocity.y, f64::from(speed) * (2.0 / dist) * 0.1);
+        assert!(m.velocity.y > 0.0);
+    }
+
+    #[test]
+    fn turns_at_most_ninety_degrees_a_tick_and_wraps_into_a_turn() {
+        // rotlerp(yRot, target, 90): from 150 towards about -16.7 it turns
+        // the full 90 to 60, then reaches the target, kept in [0, 360] as
+        // about 343.3; the body follows the yaw each tick.
+        let mut m = strolling_turtle();
+        m.ai.mov.set_wanted(3.0, 0.0, 10.0, 1.0);
+        m.yaw = 150.0;
+        m.body_yaw = 150.0;
+        let target = trig::atan2_degrees(10.0, 3.0) - 90.0;
+        assert!((-17.0..-16.0).contains(&target));
+        move_control(&mut m);
+        assert_eq!((m.yaw, m.body_yaw), (60.0, 60.0));
+        move_control(&mut m);
+        assert_eq!(m.yaw, 60.0 + (target - 60.0) + 360.0);
+        assert_eq!(m.body_yaw, m.yaw);
+    }
+}

From 8909e0510c4700295514c83c5f61cbd5695d9db7 Mon Sep 17 00:00:00 2001
From: levzzz <86072227+levzzz5154@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:55:39 +0500
Subject: [PATCH 366/475] commands: selectors find the End crystals and the
 Ender Dragon

Horizon's command targets enumerated the ordinary entity collections
only, so `@e[type=end_crystal]` and `@e[type=ender_dragon]` matched
nothing: the End crystals and the dragon live in their own lists, and
neither carried an entity id a command could name.

The crystals and the dragon now take an id from the entity counter when
they are created, as EndCrystal's and EnderDragon's constructors do; the
selector offers them as candidates; `/data get entity` reads them and
`/kill` removes them the way `Entity.kill` does. `/summon
minecraft:end_crystal` creates one, as vanilla does.

Fixes #1531

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 crates/horizon-client/src/game/commands.rs    | 49 +++++++++++++++++++
 .../horizon-client/src/game/commands/data.rs  | 10 ++++
 crates/horizon-client/src/game/dragon.rs      | 24 ++++++++-
 crates/horizon-client/src/game/persist.rs     | 20 +++++++-
 crates/horizon-client/src/game/scoreboard.rs  |  6 ++-
 tools/command_exec_corpus.py                  | 11 +++++
 6 files changed, 115 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs
index 22041c3b2..bb8ae68d6 100644
--- a/crates/horizon-client/src/game/commands.rs
+++ b/crates/horizon-client/src/game/commands.rs
@@ -53,6 +53,10 @@ pub(super) enum Target {
     /// An entity of a type Horizon does not simulate (markers, displays,
     /// interactions...): kept as its saved data at a position.
     Other(u32),
+    /// An End crystal, by its entity id (`minecraft:end_crystal`).
+    Crystal(u32),
+    /// The Ender Dragon, by its entity id (`minecraft:ender_dragon`).
+    Dragon(u32),
 }
 /// An entity of a type Horizon does not simulate: its compound lives in the
 /// entity memory (`persist.raw`), its position and rotation here.
@@ -385,6 +389,16 @@ impl Game<'_> {
                 .iter()
                 .find(|o| o.id == id)
                 .map(|o| [o.position.x, o.position.y, o.position.z]),
+            Target::Crystal(id) => self
+                .crystals
+                .iter()
+                .find(|c| c.id == id)
+                .map(|c| [c.position.x, c.position.y, c.position.z]),
+            Target::Dragon(id) => self
+                .dragon
+                .as_ref()
+                .filter(|d| d.id == id)
+                .map(|d| [d.position.x, d.position.y, d.position.z]),
         }
     }
     pub(super) fn target_type(&self, t: Target) -> String {
@@ -428,6 +442,8 @@ impl Game<'_> {
                 .iter()
                 .find(|o| o.id == id)
                 .map_or_else(String::new, |o| o.kind.clone()),
+            Target::Crystal(_) => "minecraft:end_crystal".into(),
+            Target::Dragon(_) => "minecraft:ender_dragon".into(),
         }
     }
     /// The name of the player the game acts for: a guest's own while their
@@ -552,6 +568,12 @@ impl Game<'_> {
             candidates.extend(self.boats.iter().map(|b| Target::Boat(b.id)));
             candidates.extend(self.carts.iter().map(|c| Target::Cart(c.id)));
             candidates.extend(self.others.iter().map(|o| Target::Other(o.id)));
+            // The End crystals and the dragon (EndCrystal and EnderDragon
+            // are entities of their own).
+            candidates.extend(self.crystals.iter().map(|c| Target::Crystal(c.id)));
+            if let Some(d) = &self.dragon {
+                candidates.push(Target::Dragon(d.id));
+            }
         }
         let level = self.experience.level;
         let creative = self.creative;
@@ -1199,6 +1221,17 @@ impl Game<'_> {
                     }
                 }
             }
+            Target::Crystal(id) => {
+                if let Some(c) = self.crystals.iter_mut().find(|c| c.id == id) {
+                    c.position = v;
+                }
+            }
+            Target::Dragon(id) => {
+                if let Some(d) = self.dragon.as_mut().filter(|d| d.id == id) {
+                    d.position = v;
+                    d.previous = v;
+                }
+            }
             // Wall-mounted entities do not move.
             Target::Frame(_) | Target::Painting(_) => {}
         }
@@ -1594,6 +1627,8 @@ impl Game<'_> {
             Target::Boat(id) => self.boats.retain(|b| b.id != id),
             Target::Cart(id) => self.carts.retain(|c| c.id != id),
             Target::Other(id) => self.others.retain(|o| o.id != id),
+            Target::Crystal(id) => self.kill_crystal(id),
+            Target::Dragon(id) => self.kill_dragon(id),
         }
     }
     fn cmd_kill(&mut self, ctx: &Context) -> R<i32> {
@@ -1706,6 +1741,20 @@ impl Game<'_> {
                     self.spawn_bolt(pos, false);
                     name = Text::translate("entity.minecraft.lightning_bolt", &[]);
                 }
+                "end_crystal" => {
+                    // EndCrystal's constructor takes an id from the entity
+                    // counter, and the crystal is shown with its base.
+                    self.next_entity += 1;
+                    self.crystals.push(super::dragon::Crystal {
+                        id: self.next_entity,
+                        position: Vec3::new(pos[0], pos[1], pos[2]),
+                        show_bottom: true,
+                        time: self.world.random.next_int_bound(100_000).unwrap_or(0),
+                        beam: None,
+                        invulnerable: false,
+                    });
+                    name = Text::translate("entity.minecraft.end_crystal", &[]);
+                }
                 k if super::minecarts::CartKind::from_id(&kind).is_some() => {
                     let cart_kind = super::minecarts::CartKind::from_id(&kind)
                         .unwrap_or(super::minecarts::CartKind::Rideable);
diff --git a/crates/horizon-client/src/game/commands/data.rs b/crates/horizon-client/src/game/commands/data.rs
index ac16c5e7c..3964f73a1 100644
--- a/crates/horizon-client/src/game/commands/data.rs
+++ b/crates/horizon-client/src/game/commands/data.rs
@@ -129,6 +129,16 @@ impl Game<'_> {
                 entity_nbt::arrow_to_nbt(p, random_uuid(), owner, in_block, None)
                     .or_else(|| entity_nbt::fireball_to_nbt(p, random_uuid(), owner, None))?
             }
+            Target::Crystal(id) => {
+                let c = self.crystals.iter().find(|c| c.id == id)?;
+                let (uuid, raw) = self.persist_anon("minecraft:end_crystal", c.position);
+                c.to_nbt(uuid.unwrap_or_else(random_uuid), raw)
+            }
+            Target::Dragon(id) => {
+                let d = self.dragon.as_ref().filter(|d| d.id == id)?;
+                let (uuid, raw) = self.persist_anon("minecraft:ender_dragon", d.position);
+                d.to_nbt(uuid.unwrap_or_else(random_uuid), raw)
+            }
         })
     }
     /// `Entity.load` of new data (`EntityDataAccessor.setData`): the entity is
diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index fff03ef1c..7e1c90ac7 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -828,8 +828,10 @@ impl Game<'_> {
                 continue;
             }
             let time = self.world.random.next_int_bound(100_000).unwrap_or(0);
+            // EndCrystal's constructor takes an id from the entity counter.
+            self.next_entity += 1;
             self.crystals.push(Crystal {
-                id: 0,
+                id: self.next_entity,
                 position: at,
                 show_bottom: true,
                 time,
@@ -2830,8 +2832,11 @@ impl Game<'_> {
             return false;
         }
         let time = self.world.random.next_int_bound(100_000).unwrap_or(0);
+        // EndCrystal's constructor takes an id from the entity counter, so
+        // the crystal is an entity a command can name (`@e[type=end_crystal]`).
+        self.next_entity += 1;
         self.crystals.push(Crystal {
-            id: 0,
+            id: self.next_entity,
             position: Vec3::new(x + 0.5, y, z + 0.5),
             show_bottom: false,
             time,
@@ -2848,6 +2853,21 @@ impl Game<'_> {
         self.swing_arm();
         true
     }
+    /// `EndCrystal.kill` (`/kill`): the crystal is removed, without a blast
+    /// (`Entity.kill` does not hurt it).
+    pub(super) fn kill_crystal(&mut self, id: u32) {
+        if let Some(i) = self.crystals.iter().position(|c| c.id == id) {
+            self.destroy_crystal(i, None, CrystalDamage::Explosion);
+        }
+    }
+    /// `EnderDragon.kill` (`/kill`): `Entity.kill` removes the entity, it
+    /// does not hurt it (the dragon flies its death flight when its health
+    /// runs out).
+    pub(super) fn kill_dragon(&mut self, id: u32) {
+        if self.dragon.as_ref().is_some_and(|d| d.id == id) {
+            self.dragon = None;
+        }
+    }
     /// Any entity touching `room` (`Level.getEntities(null, box)`).
     fn entity_in(&self, room: Aabb) -> bool {
         let touches = |lo: Vec3, hi: Vec3| {
diff --git a/crates/horizon-client/src/game/persist.rs b/crates/horizon-client/src/game/persist.rs
index b5e650e70..7b5a741b9 100644
--- a/crates/horizon-client/src/game/persist.rs
+++ b/crates/horizon-client/src/game/persist.rs
@@ -290,14 +290,22 @@ impl Game<'_> {
                     "minecraft:ender_dragon" => {
                         let seed = self.world.random.next_long();
                         if self.dragon.is_none()
-                            && let Some(d) = super::dragon::Dragon::from_nbt(&tag, seed)
+                            && let Some(mut d) = super::dragon::Dragon::from_nbt(&tag, seed)
                         {
+                            // EnderDragon's constructor takes its id and its
+                            // parts' from the entity counter.
+                            d.id = self.next_entity + 1;
+                            self.next_entity += 9;
                             self.dragon = Some(d);
                         }
                     }
                     "minecraft:end_crystal" => {
                         let time = self.world.random.next_int_bound(100_000).unwrap_or(0);
-                        if let Some(c) = super::dragon::Crystal::from_nbt(&tag, time) {
+                        if let Some(mut c) = super::dragon::Crystal::from_nbt(&tag, time) {
+                            // EndCrystal's constructor takes an id from the
+                            // entity counter.
+                            self.next_entity += 1;
+                            c.id = self.next_entity;
                             self.crystals.push(c);
                         }
                     }
@@ -531,6 +539,14 @@ impl Game<'_> {
         self.persist.uuids.remove(&id);
         self.persist.raw.remove(&id);
     }
+    /// The compound an entity without a Horizon entity ID was loaded with
+    /// (the crystals and the dragon), found again by type and position.
+    pub(super) fn persist_anon(&self, kind: &str, p: Vec3) -> (Option<[i32; 4]>, Option<&Tag>) {
+        self.persist
+            .anon
+            .get(&anon_key(kind, p))
+            .map_or((None, None), |(_, uuid, raw)| (*uuid, Some(raw)))
+    }
     /// The compound an entity was loaded with (and commands have edited).
     pub(super) fn persist_raw(&self, id: u32) -> Option<&Tag> {
         self.persist.raw.get(&id)
diff --git a/crates/horizon-client/src/game/scoreboard.rs b/crates/horizon-client/src/game/scoreboard.rs
index 81c03e288..005446ed1 100644
--- a/crates/horizon-client/src/game/scoreboard.rs
+++ b/crates/horizon-client/src/game/scoreboard.rs
@@ -180,7 +180,11 @@ impl Game<'_> {
             | Target::Cart(id)
             | Target::Other(id) => self.persist.raw.get(&id),
             Target::Player => self.level.player_extra.as_ref(),
-            Target::Guest(_) | Target::Orb(_) | Target::Projectile(_) => None,
+            Target::Guest(_)
+            | Target::Orb(_)
+            | Target::Projectile(_)
+            | Target::Crystal(_)
+            | Target::Dragon(_) => None,
         };
         match raw.and_then(|r| r.get("Tags")) {
             Some(Tag::List(l)) => l
diff --git a/tools/command_exec_corpus.py b/tools/command_exec_corpus.py
index d8f925ef0..1d346e002 100644
--- a/tools/command_exec_corpus.py
+++ b/tools/command_exec_corpus.py
@@ -327,6 +327,17 @@ def entities():
         cmd('/data get entity @e[tag=attr,limit=1] Health'),
         cmd('/attribute @e[tag=attr,limit=1] minecraft:attack_damage base get'),
         cmd('/kill @e[tag=attr]'),
+        # An End crystal is an entity of its own: a type selector finds it,
+        # reads it and kills it (#1531).
+        cmd('/summon minecraft:end_crystal 4.5 210 8.5'),
+        cmd('/execute if entity @e[type=minecraft:end_crystal]'),
+        cmd('/data get entity @e[type=minecraft:end_crystal,limit=1] Pos'),
+        cmd('/kill @e[type=minecraft:end_crystal]'),
+        cmd('/execute if entity @e[type=minecraft:end_crystal]'),
+        cmd('/summon minecraft:ender_dragon 4.5 210 8.5'),
+        cmd('/execute if entity @e[type=minecraft:ender_dragon]'),
+        cmd('/data get entity @e[type=minecraft:ender_dragon,limit=1] Pos'),
+        cmd('/kill @e[type=minecraft:ender_dragon]'),
         *setup('/kill @e[type=minecraft:armor_stand]'),
         {'op': 'tick', 'n': 25},
         cmd('/execute if entity @e[tag=h]'),

From 64cd55cf74d7ae27b67bc69b737a98f53274a59d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Louis=20Nordb=C3=B8?=
 <179310784+Louistuis@users.noreply.github.com>
Date: Mon, 26 Oct 2026 21:14:00 +0100
Subject: [PATCH 367/475] Finish a use on the server's USE_ITEM_COMPLETE, and
 eat on the client too

On a server client (single player's server thread, LAN guests, dedicated
servers) the window ended a consumable's use on its own timer and never ate
the food: its FoodData waited for the server's next ClientboundSetHealth.
With the button still held, the next startUseItem found the food bar below
20 and began another bite, so the eating animation went on after the bar
was full (#2471).

Vanilla's client never completes a use by itself: LivingEntity.updateUsingItem
completes it only on the server, and ServerPlayer.completeUsingItem first
sends the player entity event 9 (USE_ITEM_COMPLETE). Player.handleEntityEvent(9)
then runs completeUsingItem on the client, where Consumable.onConsume calls
the FoodProperties listener on both sides: the client's FoodData eats at once.

- The server sends event 9 to the acting guest when a consumable, a potion or
  a spyglass use completes. Like the guest's packets, the events are queued
  during their turn (kept across nested turns) and sent with their entity id.
- The client keeps using until that event, then shows the last crumbs, eats
  the food (the next ClientboundSetHealth replaces it) and starts the item's
  use_cooldown, which ItemStack.use only starts at once for an item with no
  use time.
- What vanilla's client checks so that a use can't outlive the server's:
  MultiPlayerGameMode.useItem passes on an item cooling down (chorus fruit
  held through its cooldown), LivingEntity.updatingUsingItem stops when the
  hand no longer holds the item the use began with (ItemStack.isSameItem),
  a respawn is a new player with no use, and Consumable.startConsuming
  starts none for a consumable with no use time.
- ItemCooldowns tick where Player.tick ticks them: after LivingEntity.tick's
  use on the server and after Minecraft.handleKeybinds on the client. Both
  sides ticked them first, so a guest's entry ended a tick later on the
  server than on their client, whose held retry was refused and never ended.

lan_e2e's new eat_full check eats melon slices up to a full bar with the
button still held: before, a new bite had started (use ticks 26, 2, 9, 15);
now nothing is in use. Held on two chorus fruits, both are eaten across the
cooldown. consume-release holds its completed use a little longer, as the
use now ends with the server's event.

Fixes #2471

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game.rs             |   6 +
 crates/horizon-client/src/game/consume.rs     |  10 ++
 crates/horizon-client/src/game/lan_actions.rs |  49 +++++---
 crates/horizon-client/src/game/potions.rs     |   1 +
 crates/horizon-client/src/game/remote.rs      | 113 ++++++++++++++----
 tools/lan_e2e.py                              |  66 +++++++++-
 6 files changed, 205 insertions(+), 40 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index db49087b2..43f68f228 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -1681,6 +1681,9 @@ struct Game<'a> {
     /// The acting guest's cooldowns, as (item, ticks): their packet needs the
     /// hub's item registry, which the guest's turn does not hold.
     guest_cooldowns: Vec<(Arc<str>, i32)>,
+    /// The acting guest's own entity events (`ServerPlayer.connection.send`),
+    /// sent with their entity id, which the guest's turn does not hold.
+    guest_entity_events: Vec<i8>,
     /// `broadcastToAdmins` lines a guest's command queued, sent once it
     /// returns: the line, whether operators get it and whether the console
     /// logs it.
@@ -4078,6 +4081,7 @@ impl Game<'_> {
         if &*stack.item == "minecraft:spyglass" {
             // SpyglassItem.USE_DURATION, then finishUsingItem.
             if ticks + 1 >= 1200 {
+                self.send_use_item_complete();
                 self.stop_spyglass();
                 self.using = None;
             } else {
@@ -4099,6 +4103,7 @@ impl Game<'_> {
         }
         if ticks >= duration {
             self.using = None;
+            self.send_use_item_complete();
             // ItemStack.finishUsingItem's applyAfterUseComponentSideEffects.
             self.apply_use_cooldown(&stack);
             self.finish_consuming(&info, consumable, &stack);
@@ -12893,6 +12898,7 @@ impl<'a> Game<'a> {
             lan_acting: None,
             guest_packets: Vec::new(),
             guest_cooldowns: Vec::new(),
+            guest_entity_events: Vec::new(),
             lan_acting_name: None,
             lan_acting_uuid: None,
             chat_capture: None,
diff --git a/crates/horizon-client/src/game/consume.rs b/crates/horizon-client/src/game/consume.rs
index 93d919911..dc187d207 100644
--- a/crates/horizon-client/src/game/consume.rs
+++ b/crates/horizon-client/src/game/consume.rs
@@ -19,7 +19,17 @@ use std::convert::Infallible;
 
 type ItemConsumable = Consumable<String, ConsumeEffect>;
 
+/// `EntityEvent.USE_ITEM_COMPLETE`: the server finished the player's use.
+pub(super) const USE_ITEM_COMPLETE_EVENT: i8 = 9;
+
 impl Game<'_> {
+    /// `ServerPlayer.completeUsingItem`: the player's own client is told
+    /// first, and completes the use itself (eating the food there too).
+    pub(super) fn send_use_item_complete(&mut self) {
+        if self.lan_acting.is_some() {
+            self.guest_entity_events.push(USE_ITEM_COMPLETE_EVENT);
+        }
+    }
     /// `Consumable.emitParticlesAndSounds(user.getRandom(), user, stack, count)`.
     pub(super) fn emit_consume(
         &mut self,
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index dc1e74f0b..ba5ed75cd 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -165,6 +165,8 @@ pub(super) struct GuestSwap {
     acting: (Option<u32>, Option<String>, Option<u128>),
     /// The packets queued for that guest.
     packets: Vec<play::Clientbound>,
+    /// The entity events queued for that guest.
+    entity_events: Vec<i8>,
     /// The host's count of swings started, kept while the guest acts.
     swings: u32,
     /// How many projectiles there were: those added since are the guest's.
@@ -389,6 +391,7 @@ impl Game<'_> {
             self.lan_acting_uuid.replace(g.uuid),
         );
         let packets = std::mem::take(&mut self.guest_packets);
+        let entity_events = std::mem::take(&mut self.guest_entity_events);
         let swings = self.swings_started;
         let projectiles = self.creatures.projectiles.len();
         let modifiers = std::mem::replace(
@@ -449,6 +452,7 @@ impl Game<'_> {
             death_cause,
             acting,
             packets,
+            entity_events,
             swings,
             projectiles,
             modifiers,
@@ -508,6 +512,7 @@ impl Game<'_> {
             combat,
             acting,
             packets,
+            entity_events,
             swings,
             projectiles,
             modifiers,
@@ -529,6 +534,17 @@ impl Game<'_> {
         for packet in std::mem::replace(&mut self.guest_packets, packets) {
             host.hub.send_to(conn, &packet);
         }
+        // ServerPlayer.connection.send: the guest's own entity events.
+        let entity_id = host.hub.guests[i].entity_id;
+        for event in std::mem::replace(&mut self.guest_entity_events, entity_events) {
+            host.hub.send_to(
+                conn,
+                &C::EntityEvent(play::EntityEvent {
+                    id: entity_id,
+                    event,
+                }),
+            );
+        }
         // ServerItemCooldowns.onCooldownStarted: the guest's own cooldown.
         for (group, duration) in std::mem::take(&mut self.guest_cooldowns) {
             host.hub.send_to(
@@ -1910,21 +1926,8 @@ impl Game<'_> {
                 continue;
             }
             let play = host.play.entry(conn).or_default();
-            // Player.tick's ItemCooldowns.tick, once a tick for each player
-            // (the shield an axe disabled, a thrown pearl).
-            play.shield_cooldown = play.shield_cooldown.saturating_sub(1);
+            // ServerGamePacketListenerImpl.tick's dropSpamThrottler.
             play.creative_drops = play.creative_drops.saturating_sub(1);
-            // ServerItemCooldowns.onCooldownEnded: a finished entry is told to
-            // the guest (a duration of 0 removes it).
-            for group in play.cooldowns.tick() {
-                host.hub.send_to(
-                    conn,
-                    &C::Cooldown(play::Cooldown {
-                        group: group.to_string(),
-                        duration: 0,
-                    }),
-                );
-            }
             let digging = play.digging;
             let using = play.using.is_some();
             let delayed = play.destroy_delay > 0 || play.use_delay > 0 || play.attack_ticks < 100;
@@ -1961,6 +1964,24 @@ impl Game<'_> {
                     play.digging = None;
                 }
             }
+            // Player.tick's ItemCooldowns.tick, once a tick for each player
+            // (the shield an axe disabled, a thrown pearl), after
+            // LivingEntity.tick's use: an entry a finished use starts has 20
+            // ticks left when the next tick's packets are handled, as the
+            // guest's own client counts.
+            let play = host.play.entry(conn).or_default();
+            play.shield_cooldown = play.shield_cooldown.saturating_sub(1);
+            // ServerItemCooldowns.onCooldownEnded: a finished entry is told to
+            // the guest (a duration of 0 removes it).
+            for group in play.cooldowns.tick() {
+                host.hub.send_to(
+                    conn,
+                    &C::Cooldown(play::Cooldown {
+                        group: group.to_string(),
+                        duration: 0,
+                    }),
+                );
+            }
             // Player.tick: a different main-hand item resets the attack
             // strength, and detectEquipmentUpdates gives the guest its modifiers.
             let g = &host.hub.guests[gi];
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index 2ccfd4116..7f30e21c2 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -300,6 +300,7 @@ impl Game<'_> {
             return true;
         }
         self.using = None;
+        self.send_use_item_complete();
         self.post_entity_event("minecraft:drink", horizon_client::mobs::Who::Player);
         if ominous {
             self.drink_ominous_bottle(slot, stack);
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..50bf6d4f3 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -117,6 +117,8 @@ pub(super) struct Remote {
     joined: bool,
     status: String,
     pub(super) entity_id: i32,
+    /// The item the player's use began with (`LivingEntity.useItem`).
+    pub(super) use_item: Option<Arc<str>>,
     dimension: DimensionType,
     /// What chunk packets decode with (the dimension's height and sky, the
     /// biome registry); replaced whenever one of them changes.
@@ -428,6 +430,7 @@ impl Game<'_> {
             joined: false,
             status: "Connecting to the server...".into(),
             entity_id: 0,
+            use_item: None,
             dimension: DimensionType::vanilla("minecraft:overworld"),
             chunk_format: Arc::new(ChunkFormat::new(
                 &DimensionType::vanilla("minecraft:overworld"),
@@ -1639,8 +1642,10 @@ impl Game<'_> {
                 self.send(S::ClientInformation(info));
             }
             C::Respawn(p) => {
-                // A new player, without effects: the server sends them again.
+                // A new player, without effects (the server sends them
+                // again) and with no item in use.
                 self.potions.effects.clear();
+                self.using = None;
                 self.enter_remote_dimension(&p.spawn, true);
                 self.screen = Screen::Playing;
                 if let Some(r) = self.remote.as_mut() {
@@ -2138,6 +2143,11 @@ impl Game<'_> {
                 if p.event == super::totem::TOTEM_EVENT {
                     self.remote_totem(p.id);
                 }
+                if p.event == super::consume::USE_ITEM_COMPLETE_EVENT
+                    && self.remote.as_ref().is_some_and(|r| r.entity_id == p.id)
+                {
+                    self.remote_complete_using();
+                }
             }
             C::Animate(p) => self.remote_animate(p.id, p.action),
             // ClientPacketListener.handleSwingAnimation: the entity swings
@@ -3135,12 +3145,6 @@ impl Game<'_> {
     fn tick_remote_level(&mut self) -> Result<()> {
         self.ticks += 1;
         self.track_experience_display();
-        // Player.tick's ItemCooldowns.tick: this path replaces `tick_world`'s
-        // for a server's client (multiplayer and the default single player),
-        // so the entries advance here or the slot stays shaded until the
-        // server says the entry ended. `onCooldownEnded` is the plain
-        // ItemCooldowns' no-op on a client.
-        self.cooldowns.tick();
         // Options.broadcastOptions: a changed render distance or Chat option
         // is sent again.
         let view = client_view_distance(self.settings.render_distance);
@@ -3174,6 +3178,14 @@ impl Game<'_> {
         // Window callbacks only queue clicks, so an interaction cannot leak
         // between CLIENT_TICK_END and a later pong.
         self.remote_handle_input();
+        // Player.tick's ItemCooldowns.tick, in ClientLevel.tickEntities after
+        // handleKeybinds: this path replaces `tick_world`'s for a server's
+        // client (multiplayer and the default single player), so the entries
+        // advance here or the slot stays shaded until the server says the
+        // entry ended. `onCooldownEnded` is the plain ItemCooldowns' no-op on
+        // a client. Ticking it after the keybinds keeps a held use from
+        // trying again a tick before the server's entry ends.
+        self.cooldowns.tick();
         // ClientLevel.tick: the border's size change.
         self.border.tick();
         self.player_border();
@@ -4295,10 +4307,19 @@ impl Game<'_> {
         let Some(info) = self.res.items().get(&held.item).cloned() else {
             return false;
         };
-        // MultiPlayerGameMode.useItem runs the use here too (inside
-        // startPrediction): the `use_cooldown` component starts its entry, and
-        // the server's ClientboundCooldownPacket confirms it.
-        self.apply_use_cooldown(&held);
+        // MultiPlayerGameMode.useItem's prediction: an item cooling down
+        // passes (its packet still goes).
+        let group = horizon_client::cooldowns::group(&held, info.use_cooldown.as_ref());
+        if self.cooldowns.is_on_cooldown(&group) {
+            return false;
+        }
+        // It runs the use here too: ItemStack.use starts the `use_cooldown`
+        // of an item with no use time, and the server's
+        // ClientboundCooldownPacket confirms it; one held in use starts it at
+        // finishUsingItem (remote_complete_using).
+        if !info.consumable.as_ref().is_some_and(|c| c.ticks() > 0) {
+            self.apply_use_cooldown(&held);
+        }
         // Food starts being eaten (Consumable.startConsuming), a book and
         // quill opens.
         self.with_hand(hand, |g| g.start_eating(&info));
@@ -4373,14 +4394,25 @@ impl Game<'_> {
         self.remote_use_item(Hand::Off);
     }
     /// `LivingEntity.updatingUsingItem` on a server client: an item held in
-    /// use (`held_until_released`), and a
-    /// consumable's eating animation and its crumbs. The server eats it and
-    /// sends the stack, the hunger and the sounds.
+    /// use (`held_until_released`), and a consumable's eating animation and
+    /// its crumbs until the server's USE_ITEM_COMPLETE. The server sends the
+    /// stack, its hunger and the sounds.
     fn remote_tick_using(&mut self) {
         let Some((slot, ticks)) = self.using else {
             return;
         };
         let stack = self.stack_in(slot).cloned();
+        // The use stops when the hand no longer holds the item it began with
+        // (ItemStack.isSameItem).
+        let item = stack.as_ref().map(|s| Arc::clone(&s.item));
+        if let Some(r) = self.remote.as_mut() {
+            if ticks == 0 {
+                r.use_item = item;
+            } else if r.use_item != item {
+                self.using = None;
+                return;
+            }
+        }
         // Another hotbar slot picked: LivingEntity.updatingUsingItem sees a
         // different stack in the hand. The off hand keeps its item.
         let in_hand = slot == self.selected || slot == super::shield::OFFHAND_SLOT;
@@ -4405,20 +4437,51 @@ impl Game<'_> {
             self.using = None;
             return;
         }
-        // Consumable.shouldEmitParticlesAndSounds, as in tick_used_item.
-        let duration = consumable.ticks().max(0) as u32;
-        let remaining = duration - ticks.min(duration);
-        if consumable.particles && consumable.should_emit(remaining as i32) {
+        // Consumable.startConsuming eats one with no use time at once, without
+        // a use (nor a USE_ITEM_COMPLETE).
+        if consumable.ticks() <= 0 {
+            self.using = None;
+            return;
+        }
+        // Consumable.shouldEmitParticlesAndSounds, as in tick_used_item. The
+        // countdown goes on past zero (LivingEntity.updateUsingItem completes
+        // only on the server) until the server's USE_ITEM_COMPLETE.
+        let remaining = consumable.ticks() - ticks as i32;
+        if consumable.particles && consumable.should_emit(remaining) {
             self.eat_particles(&stack, 5);
         }
-        if ticks + 1 >= duration {
-            self.using = None;
-            if consumable.particles {
-                self.eat_particles(&stack, 16);
-            }
-        } else {
-            self.using = Some((slot, ticks + 1));
+        self.using = Some((slot, ticks + 1));
+    }
+    /// `Player.handleEntityEvent(9)`: `completeUsingItem` on the client. A consumable's last crumbs, and FoodProperties.onConsume,
+    /// which runs on the client too (Consumable.onConsume calls its
+    /// ConsumableListeners on both sides): the client's FoodData eats at once,
+    /// so a held right click finds `Player.canEat` false instead of starting
+    /// another bite before the server's ClientboundSetHealth arrives.
+    fn remote_complete_using(&mut self) {
+        let Some((slot, _)) = self.using.take() else {
+            return;
+        };
+        let Some(stack) = self.stack_in(slot).cloned() else {
+            return;
+        };
+        let Some(info) = self.res.items().get(&stack.item).cloned() else {
+            return;
+        };
+        if info.consumable.as_ref().is_some_and(|c| c.particles) {
+            self.eat_particles(&stack, 16);
         }
+        if let Some((nutrition, saturation)) = info.food
+            && let Some(r) = self.remote.as_mut()
+        {
+            // FoodData.eat(nutrition, saturation), as finish_consuming does;
+            // the next ClientboundSetHealth replaces it.
+            let (_, food, sat) = &mut r.health;
+            *food = (*food + nutrition as i32).clamp(0, 20);
+            *sat = (*sat + saturation).clamp(0.0, *food as f32);
+            self.apply_remote_health();
+        }
+        // ItemStack.finishUsingItem's applyAfterUseComponentSideEffects.
+        self.apply_use_cooldown(&stack);
     }
     /// MouseHandler updates KeyMapping; handleKeybinds sends packets on a tick.
     pub(super) fn remote_mouse(&mut self, button: MouseButton, pressed: bool) -> Result<()> {
diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index 03e0e888f..329a11707 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -114,6 +114,10 @@ address. The script then checks, from both sides, what a guest's game used to ge
               use to completion still consumes the item (#1293).
 - eating:    each side sees the other player eat: the item in use (LivingEntity's flags) on the
              player it draws, and no longer once the bread is eaten (#803);
+- eat_full:  holding right click with melon slices until the food bar is full: the guest's own
+             client eats each slice when the server says it is done (entity event 9,
+             USE_ITEM_COMPLETE), so no other bite starts; held on chorus fruit, both fruits are
+             eaten across its cooldown (#2471).
 - xp:        experience orbs 4 blocks away fly to the guest, show on the guest's screen and give the
              guest their points (not the host).
 - objects:   boats, minecarts, armor stands, item frames and paintings the host summons reach the
@@ -5214,6 +5218,64 @@ CHECKS += ['helduse']
 CHECK_FNS.update(helduse=check_held_use)
 
 
+def check_eat_full(host, guest, out):
+    """Holding right click past a full food bar starts no other bite; chorus fruit's cooldown
+    doesn't leave the use stuck (#2471)."""
+    guest('command', command='gamemode survival')
+    guest('command', command='clear @s')
+    # Full health: natural regeneration at 18 food or more would eat into the bar.
+    guest('command', command='effect give @s minecraft:instant_health 1 10')
+    guest('command', command='effect give @s minecraft:hunger 60 127')
+    for _ in range(400):
+        if remote(guest)['food'] <= 17:
+            break
+        guest.wait(1)
+    guest('command', command='effect clear @s')
+    guest('command', command='give @s minecraft:melon_slice 16')
+    guest.wait(5)
+    guest.raw('select', 'minecraft:melon_slice')
+    hungry = remote(guest)['food']
+    # A slice (2 food) takes 32 ticks (1.6 s): the button stays down well past the slices that fill
+    # the bar, with room for a slow server.
+    slices = -(-(20 - hungry) // 2)
+    hold = threading.Thread(target=guest.raw, args=('use-item', '--hold', slices * 4.0 + 6.0))
+    hold.start()
+    deadline = time.monotonic() + slices * 4.0 + 2.0
+    while remote(guest)['food'] < 20 and time.monotonic() < deadline:
+        time.sleep(0.1)
+    # The bar is full and the button is still down: nothing is in use over the next 20 ticks
+    # (sleeps, as `wait` is refused while the held use-item runs).
+    using = []
+    for _ in range(4):
+        time.sleep(0.25)
+        using.append(guest('state').get('using'))
+    guest.shot(out, 'eat-full')
+    hold.join()
+    guest.wait(10)
+    full = {'hungry': hungry, 'fed': remote(guest)['food'], 'using': using,
+            'eaten': 16 - guest('inventory')['counts'].get('minecraft:melon_slice', 0), 'needed': slices}
+    assert hungry < 20, f'the guest is not hungry: {full}'
+    assert full['fed'] == 20 and full['eaten'] == slices, f'the bar did not fill: {full}'
+    assert using == [None] * 4, f'another bite started with a full food bar: {full}'
+
+    # Chorus fruit can always be eaten, then its group cools down for 20 ticks: the client waits
+    # it out (MultiPlayerGameMode.useItem) and eats the second fruit with the button still held.
+    guest('command', command='clear @s')
+    guest('command', command='give @s minecraft:chorus_fruit 2')
+    guest.wait(5)
+    guest.raw('select', 'minecraft:chorus_fruit')
+    guest.raw('use-item', '--hold', 7.0)
+    guest.wait(10)
+    chorus = {'left': guest('inventory')['counts'].get('minecraft:chorus_fruit', 0),
+              'using': guest('state').get('using')}
+    assert chorus == {'left': 0, 'using': None}, f'the held use did not eat both chorus fruits: {chorus}'
+    return {'full': full, 'chorus': chorus}
+
+
+CHECKS += ['eat_full']
+CHECK_FNS.update(eat_full=check_eat_full)
+
+
 def check_consume_release(host, guest, out):
     """#1293: releasing a consumable in either hand cancels it on client and server, while
     holding it to completion applies its effects and remainder (Consumable.onConsume)."""
@@ -5258,8 +5320,10 @@ def check_consume_release(host, guest, out):
                     assert effects == before, f'{case} applied consumption effects after release: {cancelled}'
                     game.shot(out, f'consume-release-{hand}-{item}')
                     # A sustained press must still consume normally, including the milk's empty bucket.
+                    # The use ends with the server's USE_ITEM_COMPLETE, 32 server ticks after its
+                    # UseItem: room for a busy server before letting go.
                     game.raw('mouse', 'right', 'down')
-                    game.wait(40)
+                    game.wait(50)
                     game.raw('mouse', 'right', 'up')
                     game.wait(10)
                     inventory = game('inventory')

From 67b6e75c0b4361c9aa2fb04ea020410cf0fe5167 Mon Sep 17 00:00:00 2001
From: levzzz <86072227+levzzz5154@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:01:42 +0500
Subject: [PATCH 368/475] The container screen's press state does not survive
 the screen

AbstractContainerScreen keeps `isQuickCrafting` and the drag it belongs to
on the screen, so every screen starts with its own state. Horizon keeps
both on `Game`, and #2052 only dropped them when the pointer was grabbed
again, so a press whose release never arrived (the pointer left the
window) kept the drag running on the next screen: `Clicks::press` answers
`None` for every later press, so the Shift quick move and the clicks on
the inventory went dead.

The press state now goes with the pointer: `Game::capture` drops it
whichever way the pointer changes hands (a screen opens or closes, the
window loses focus), and `Clicks::cancel_drag` names the drop.

Fixes #1737

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 crates/horizon-client/src/container_screen.rs | 43 +++++++++++++++++++
 crates/horizon-client/src/game.rs             | 21 +++++----
 crates/horizon-client/src/menu.rs             | 27 ++++++++++++
 3 files changed, 83 insertions(+), 8 deletions(-)

diff --git a/crates/horizon-client/src/container_screen.rs b/crates/horizon-client/src/container_screen.rs
index 77c7ad8aa..a7b1794c5 100644
--- a/crates/horizon-client/src/container_screen.rs
+++ b/crates/horizon-client/src/container_screen.rs
@@ -124,6 +124,18 @@ impl Clicks {
         self.skip_next_release = true;
     }
 
+    /// The screen that takes the pointer over starts with its own state:
+    /// `AbstractContainerScreen` holds `isQuickCrafting` and the drag it
+    /// belongs to on the screen, so a screen that opens (or closes) drops
+    /// them. A press whose release never arrived -- the pointer left the
+    /// window -- would otherwise keep the drag running, and `press` answers
+    /// `None` for every later press, so the quick move and the clicks go
+    /// dead on every screen after it.
+    pub fn cancel_drag(&mut self) {
+        self.quick_crafting = None;
+        self.skip_next_release = false;
+    }
+
     /// `mouseClicked` (no double click): the `slotClicked` input it sends on
     /// `target`, if any. A press holding a stack starts a quick craft drag
     /// instead. `cloning` is `keyPickItem` with infinite materials.
@@ -301,4 +313,35 @@ mod tests {
             Some(Input::Pickup)
         );
     }
+
+    /// #1737: a press whose release never arrives (the pointer left the
+    /// window) leaves `isQuickCrafting` set, and `press` answers `None` for
+    /// every later press, so the Shift quick move and the clicks on the
+    /// inventory go dead. The drag belongs to the screen that has it
+    /// (`AbstractContainerScreen` holds `isQuickCrafting`), so the screen
+    /// that takes the pointer over drops it and the quick move works again.
+    #[test]
+    fn a_lost_release_does_not_wedge_the_quick_move() {
+        let mut clicks = Clicks::default();
+        let slot = Target::<usize>::Slot(3);
+        // Pressed with a stack carried: a quick craft drag starts, and its
+        // release never arrives.
+        assert_eq!(clicks.press(&slot, Button::Left, false, false, false), None);
+        assert!(clicks.quick_crafting().is_some());
+        // The stuck drag swallows the next press: the Shift quick move stops
+        // working and the inventory stops answering.
+        assert_eq!(clicks.press(&slot, Button::Right, true, true, false), None);
+        // The screen that takes the pointer over starts with its own state.
+        clicks.cancel_drag();
+        assert!(clicks.quick_crafting().is_none());
+        // The quick move works again.
+        assert_eq!(
+            clicks.press(&slot, Button::Right, true, true, false),
+            Some(Input::QuickMove)
+        );
+        assert_eq!(
+            clicks.press(&slot, Button::Left, true, false, false),
+            Some(Input::Pickup)
+        );
+    }
 }
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 807a1d2cf..60c857785 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4941,10 +4941,13 @@ impl Game<'_> {
         if capture && !self.focused {
             return;
         }
-        if capture {
-            // The inventory's screens are behind us: no drag survives them.
-            self.reset_inventory_clicks();
-        } else {
+        // The container screen's press state belongs to the screen: a screen
+        // that takes the pointer over starts with its own state, as
+        // `AbstractContainerScreen` does, so a press whose release never
+        // arrived (the pointer left the window) cannot wedge the next
+        // screen's quick move and clicks.
+        self.reset_inventory_clicks();
+        if !capture {
             self.stop_mining();
         }
         // The real pointer takes over from an agent's.
@@ -5788,12 +5791,14 @@ impl Game<'_> {
         }
     }
     /// `AbstractContainerScreen` keeps `isQuickCrafting` and the drag it
-    /// belongs to on the screen; Horizon keeps them on the game, so they are
-    /// dropped when a screen closes. A press whose release never reaches the
-    /// screen (the pointer left the window, or the screen closed first) would
+    /// 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 = Default::default();
+        self.inv_clicks.cancel_drag();
         self.inv_drag = None;
         self.last_inv_click = None;
     }
diff --git a/crates/horizon-client/src/menu.rs b/crates/horizon-client/src/menu.rs
index 3b2b8fd31..56c8a3b55 100644
--- a/crates/horizon-client/src/menu.rs
+++ b/crates/horizon-client/src/menu.rs
@@ -3211,4 +3211,31 @@ pub(crate) mod tests {
             assert_eq!(menu.slot(0), stack("dirt", 1).as_ref());
         });
     }
+
+    /// #1737: a Shift+Right-Click quick move in a chest (a double chest's
+    /// 54 slots) moves the stack and leaves the menu's state clean, so the
+    /// next quick move still moves its stack and the inventory still
+    /// answers.
+    #[test]
+    fn a_chest_quick_move_keeps_the_next_one_working() {
+        with_menu(Kind::Chest(6), |env, menu| {
+            menu.creative = false;
+            // The hotbar holds two stacks; the chest is empty.
+            menu.set_slot(env, 81, stack("cobblestone", 64));
+            menu.set_slot(env, 82, stack("dirt", 32));
+            // Shift+Right-Click on the hotbar: the stack goes into the chest.
+            menu.click(env, 81, 1, Input::QuickMove).unwrap();
+            assert_eq!(menu.slot(81), None);
+            assert_eq!(menu.slot(0).map(|s| s.count), Some(64));
+            // Nothing is left on the cursor and no quick craft is running.
+            assert_eq!(menu.carried, None);
+            assert_eq!(menu.quick_status, 0);
+            // The next quick move still works.
+            menu.click(env, 82, 1, Input::QuickMove).unwrap();
+            assert_eq!(menu.slot(82), None);
+            assert_eq!(menu.slot(1).map(|s| s.count), Some(32));
+            assert_eq!(menu.carried, None);
+            assert_eq!(menu.quick_status, 0);
+        });
+    }
 }

From 4e82a62489205c0ba7182c37baa47b142c916c8c Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Tue, 27 Oct 2026 00:01:54 +0100
Subject: [PATCH 369/475] Vexes hold their sword at the small size Java uses

---
 crates/horizon-client/src/mobs/render.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs
index 077fd38a6..8b316d8ba 100644
--- a/crates/horizon-client/src/mobs/render.rs
+++ b/crates/horizon-client/src/mobs/render.rs
@@ -1235,6 +1235,15 @@ fn hand_base(
         0.0
     };
     let mut t = part_matrix(model, base, poses, arm, offset)?;
+    if m.species() == Species::Vex {
+        // `VexModel.translateToHand`: the held item is drawn at 0.55 scale.
+        t *= glam::Mat4::from_scale(glam::Vec3::splat(0.55));
+        t *= glam::Mat4::from_translation(glam::Vec3::new(
+            if left { -0.046_875 } else { 0.046_875 },
+            -0.156_25,
+            0.078_125,
+        ));
+    }
     let (ox, oy, oz) = if m.is_baby() {
         (0.0, 1.0, -4.5)
     } else {

From 7ae20a5b294ebc8891ae8faabc42496c187356d3 Mon Sep 17 00:00:00 2001
From: levzzz <86072227+levzzz5154@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:07:36 +0500
Subject: [PATCH 370/475] A potion from the creative inventory keeps its
 contents in the hotbar

#1832 reported that a potion taken from the creative inventory and put in
the hotbar turned into the uncraftable potion. The hand-over keeps the
stack as it is on `main` (#1796 and #1874), so this adds the test that
keeps it that way: the item tab's stack is the real one, the creative
screen hands it over unchanged, and the hotbar slot holds the brew.

Fixes #1832

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 crates/horizon-client/src/menu.rs | 33 +++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/crates/horizon-client/src/menu.rs b/crates/horizon-client/src/menu.rs
index 3b2b8fd31..38186d170 100644
--- a/crates/horizon-client/src/menu.rs
+++ b/crates/horizon-client/src/menu.rs
@@ -3211,4 +3211,37 @@ pub(crate) mod tests {
             assert_eq!(menu.slot(0), stack("dirt", 1).as_ref());
         });
     }
+
+    /// #1832: a potion taken from the creative inventory and put in the
+    /// hotbar keeps its `PotionContents` (the brew), as vanilla's
+    /// `PotionContents.createItemStack` builds it: the item tab's stack is
+    /// the real one, and the hotbar slot holds it as it is.
+    #[test]
+    fn a_creative_potion_keeps_its_contents_in_the_hotbar() {
+        let snbt = r#"{components:{"minecraft:potion_contents":{potion:"minecraft:swiftness"}},count:1,id:"minecraft:potion"}"#;
+        let potion = crate::item_data::parse_stack(snbt).unwrap().unwrap();
+        assert_eq!(potion.potion(), Some("minecraft:swiftness"));
+        // The creative screen hands the stack over...
+        let mut carried = None;
+        crate::creative::click_display(
+            &mut carried,
+            Some(&potion),
+            |_: &ItemStack| 1,
+            0,
+            Input::Pickup,
+        );
+        assert_eq!(
+            carried.as_ref().and_then(|s| s.potion()),
+            Some("minecraft:swiftness")
+        );
+        // ... and the hotbar slot keeps it: it is not the uncraftable
+        // potion, which is a `minecraft:potion` with no contents at all.
+        with_menu(Kind::ItemPicker, |env, menu| {
+            menu.carried = carried;
+            menu.click(env, 45, 0, Input::Pickup).unwrap();
+            let in_hand = menu.slot(45).expect("the hotbar slot");
+            assert_eq!(in_hand.potion(), Some("minecraft:swiftness"));
+            assert_eq!(&*in_hand.item, "minecraft:potion");
+        });
+    }
 }

From 4c9075a0729f4c3f5ec47428a87ac252c5566284 Mon Sep 17 00:00:00 2001
From: levzzz <86072227+levzzz5154@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:08:31 +0500
Subject: [PATCH 371/475] Keep the thrown-item reproduction for #1762

A server's client ticks a projectile itself between the entity tracker's
updates, as vanilla's Entity no-op interpolation handler does; before #2086 it
only eased towards the server's position, so a thrown egg, ender pearl or wind
charge hung in the air for half a second. The client tick is now a named
function with unit tests for that flight, and the parity harness keeps the
reproduction the issue asked for: a connected client throws each of them and
samples their position twice as often as the tracker's interval. The LAN
harness can also run headless now (HORIZON_E2E_HEADLESS), so the games render
offscreen and never pause on the focus loss on a machine with no focused
window.

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 .../src/game/remote_projectiles.rs            | 79 +++++++++++++++++--
 tools/lan_e2e.py                              | 12 ++-
 tools/test_remote_fireball_parity.py          | 50 ++++++++++--
 3 files changed, 129 insertions(+), 12 deletions(-)

diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs
index 897999c6b..d896d12eb 100644
--- a/crates/horizon-client/src/game/remote_projectiles.rs
+++ b/crates/horizon-client/src/game/remote_projectiles.rs
@@ -77,6 +77,14 @@ fn remote_arrow_tick(p: &mut Projectile, w: &impl ProjectileWorld) {
     }
     p.velocity.y -= 0.05;
 }
+/// A server's client ticks a projectile itself: it flies on between the
+/// tracker's updates (10 to 20 ticks apart) with its own gravity and drag,
+/// and a block stops it there; only the server decides what it hits.
+pub(super) fn remote_projectile_tick(p: &mut Projectile, w: &impl ProjectileWorld) {
+    if !matches!(p.tick(w).1, Hit::None) {
+        p.velocity = Vec3::ZERO;
+    }
+}
 
 impl Game<'_> {
     /// `handleAddEntity` for these types; false when `kind` isn't one.
@@ -341,11 +349,7 @@ impl Game<'_> {
                         p.age += 1;
                         p.position = p.position.add_vector(p.velocity);
                     }
-                    _ => {
-                        if !matches!(p.tick(&world).1, Hit::None) {
-                            p.velocity = Vec3::ZERO;
-                        }
-                    }
+                    _ => remote_projectile_tick(p, &world),
                 }
             }
         }
@@ -519,3 +523,68 @@ impl Game<'_> {
         out
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_client::mobs::Who;
+    use horizon_core::geometry::Aabb;
+
+    /// A world with nothing in it: the client tick of a projectile only
+    /// needs the blocks around it.
+    struct Empty;
+    impl ProjectileWorld for Empty {
+        fn clip(&self, _: Vec3, _: Vec3) -> Option<(Vec3, [i32; 3], [i32; 3])> {
+            None
+        }
+        fn in_water(&self, _: Vec3) -> bool {
+            false
+        }
+        fn targets(&self) -> &[(Who, Aabb)] {
+            &[]
+        }
+    }
+
+    /// A thrown item, as a server's client tracks it: the spawn position and
+    /// the motion the server gave it.
+    fn thrown(kind: ProjectileKind) -> Projectile {
+        let mut p = Projectile::new(kind, Vec3::new(0.0, 100.0, 0.0), None);
+        p.velocity = Vec3::new(1.5, 0.0, 0.0);
+        p
+    }
+
+    #[test]
+    fn a_thrown_item_flies_on_between_the_server_updates() {
+        // A thrown egg, an ender pearl and a wind charge (#1762): the server
+        // sends their position every 10 ticks, and the client ticks them
+        // itself in between, as vanilla's no-op interpolation handler does.
+        for kind in [
+            ProjectileKind::Egg,
+            ProjectileKind::EnderPearl,
+            ProjectileKind::WindCharge,
+        ] {
+            let mut p = thrown(kind);
+            remote_projectile_tick(&mut p, &Empty);
+            assert!(p.position.x > 1.0, "the projectile did not fly on: {p:?}");
+            // A second tick moves it further: it keeps flying, not a hop.
+            let first = p.position.x;
+            remote_projectile_tick(&mut p, &Empty);
+            assert!(p.position.x > first, "the projectile stopped: {p:?}");
+        }
+    }
+
+    #[test]
+    fn a_thrown_item_falls_and_drags_like_a_throwable_projectile() {
+        // ThrowableProjectile.tick: gravity 0.03, then the air drag 0.99.
+        let mut p = thrown(ProjectileKind::Egg);
+        remote_projectile_tick(&mut p, &Empty);
+        assert!((p.velocity.x - 1.5 * 0.99).abs() < 1e-9, "{p:?}");
+        assert!((p.velocity.y - (-0.03 * 0.99)).abs() < 1e-9, "{p:?}");
+        // A wind charge keeps its speed: no gravity and no drag
+        // (AbstractWindCharge: acceleration 0, inertia 1).
+        let mut p = thrown(ProjectileKind::WindCharge);
+        remote_projectile_tick(&mut p, &Empty);
+        assert!((p.velocity.x - 1.5).abs() < 1e-9, "{p:?}");
+        assert!((p.velocity.y - 0.0).abs() < 1e-9, "{p:?}");
+    }
+}
diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index 012e8f021..0086cecc9 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -4743,9 +4743,17 @@ def run(ctl, out, resources, checks):
     host, guest = Game('host', ctl, resources), Game('guest', ctl, resources)
     # Either way explicitly: the game's default is the server thread.
     host.d.env['HORIZON_SERVER_THREAD'] = '1' if SERVER_THREAD else '0'
+    # A headless run (HORIZON_E2E_HEADLESS) has no focused window to draw in: the games render
+    # offscreen and never pause on the focus loss, or the world would stand still.
+    headless = bool(os.environ.get('HORIZON_E2E_HEADLESS'))
+    launch = ['launch']
+    if headless or sys.platform == 'darwin':
+        launch.append('--offscreen')
+    if headless:
+        launch.append('--no-pause')
     results = {}
     try:
-        host.pid = host('launch', wait=False, offscreen=sys.platform == 'darwin')['pid']
+        host.pid = host.raw(*launch)['pid']
         # Guests' commands need the world's Allow Commands as well as the LAN's (#372): a creative
         # world has them; everyone plays in survival.
         host.raw('open', 'Lan', 5, 'creative')
@@ -4759,7 +4767,7 @@ def run(ctl, out, resources, checks):
         host('command', command='gamerule spawn_mobs false')
         port = host.raw('lan', 'open', 0, 'commands')['port']
         host.player = host.raw('lan', 'status').get('host', 'Player')  # the host's profile name
-        guest.pid = guest('launch', wait=False, offscreen=sys.platform == 'darwin')['pid']
+        guest.pid = guest.raw(*launch)['pid']
         guest.raw('connect', f'127.0.0.1:{port}', GUEST_NAME)
         guest.raw('wait-for', 'loaded', '--timeout', 300)
         guest.wait(40)
diff --git a/tools/test_remote_fireball_parity.py b/tools/test_remote_fireball_parity.py
index 7e60ff30a..3969322f4 100644
--- a/tools/test_remote_fireball_parity.py
+++ b/tools/test_remote_fireball_parity.py
@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
-"""A connected client advances ghast fireballs between tracker packets.
+"""A connected client advances ghast fireballs and thrown items between tracker packets.
 
-AbstractHurtingProjectile.tick/applyInertia run on clients as well as servers.
-Like lan_e2e's falling-entity check, sample motion more often than the tracker
-interval; an interpolation-only client stalls for most of that interval.
+AbstractHurtingProjectile.tick/applyInertia run on clients as well as servers, and
+a thrown item ticks itself on the client too. Like lan_e2e's falling-entity check,
+sample motion more often than the tracker interval; an interpolation-only client
+stalls for most of that interval (#1762).
 """
 import json
 import math
@@ -36,6 +37,44 @@ def check_motion(host, guest, out):
     return {'positions': samples}
 
 
+def check_thrown(host, guest, out):
+    """A thrown egg, an ender pearl and a wind charge fly on between tracker packets.
+
+    The server sends a thrown item's position every 10 ticks; a client that only
+    eased towards it hung in the air for half a second (#1762). Vanilla's client
+    ticks the projectile itself, as Entity's no-op interpolation handler does.
+    """
+    x, y, z = (math.floor(v) for v in lan.pos_of(guest))
+    for game in (host, guest):
+        game('command', command='gamemode survival')
+    results = {}
+    for item, kind in (('minecraft:egg', 'Egg'), ('minecraft:ender_pearl', 'EnderPearl'),
+                        ('minecraft:wind_charge', 'WindCharge')):
+        # A clear lane along +X at the guest's eye height, with room to fall.
+        host('command', command=f'fill {x + 2} {y - 7} {z - 2} {x + 60} {y - 7} {z + 2} minecraft:stone')
+        host('command', command=f'fill {x + 2} {y - 6} {z - 2} {x + 60} {y + 3} {z + 2} minecraft:air')
+        guest('command', command=f'tp @s {x + 0.5:.2f} {y:.2f} {z + 0.5:.2f}')
+        guest.wait(20)
+        guest('command', command='clear @s')
+        guest('command', command=f'item replace entity @s weapon.mainhand with {item}')
+        guest.wait(10)
+        # The server throws along the rotation it has: let it arrive first.
+        guest.raw('look-at', f'{x + 40:.2f}', f'{y + 1.62:.2f}', f'{z + 0.5:.2f}')
+        guest.wait(5)
+        guest.raw('use-item')
+        samples = []
+        for _ in range(6):
+            shots = [p for p in guest('status')['projectiles'] if p['kind'] == kind]
+            samples.append(shots[0]['position'][0] if shots else None)
+            guest.wait(2)
+        seen = [p for p in samples if p is not None]
+        moves = sum(b != a for a, b in zip(seen, seen[1:]))
+        results[item] = {'positions': samples, 'moves': moves}
+        assert len(seen) >= 4, f'{item} visible in only {len(seen)} samples: {samples}'
+        assert moves >= len(seen) - 2, f'{item} stalled between tracker updates: {samples}'
+    return results
+
+
 def main():
     subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client',
                     '--bin', 'horizon-client', '--bin', 'horizon-ctl'], cwd=lab.ROOT, check=True)
@@ -43,6 +82,7 @@ def main():
         ['cargo', 'metadata', '--format-version', '1', '--no-deps'], cwd=lab.ROOT, text=True))
     ctl = lab.ROOT / metadata['target_directory'] / 'fast' / 'horizon-ctl'
     lan.CHECK_FNS['remote-fireball'] = check_motion
+    lan.CHECK_FNS['remote-thrown'] = check_thrown
     # Use the runner's current display (xvfb on Linux), with fresh isolated homes.
     lan.game_env = lambda _screen, home: lab.game_env(
         HORIZON_HOME=home, HORIZON_TELEMETRY_URL='off')
@@ -53,7 +93,7 @@ def main():
         out = lab.LOCAL / 'remote-fireball-parity' / mode
         out.mkdir(parents=True, exist_ok=True)
         # lan.Game launches each client with lab.game_env and private scratch homes.
-        reports[mode] = lan.run(ctl, out, lab.RESOURCES.resolve(), ['remote-fireball'])
+        reports[mode] = lan.run(ctl, out, lab.RESOURCES.resolve(), ['remote-fireball', 'remote-thrown'])
     lab.write_json(lab.LOCAL / 'remote-fireball-parity' / 'report.json', reports)
     assert all(r['pass'] for mode in reports.values() for r in mode.values()), reports
 

From b5794fa5b38775b620fc8222b7ab3f2b1dd9f6cb Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Tue, 27 Oct 2026 00:17:04 +0100
Subject: [PATCH 372/475] Check rain at the mob's position, not the global
 weather

Water sensitive mobs, endermen, dolphins, wolves, sun burn and the happy
ghast's healing now ask the rain at their own spot (Entity.isInRain,
Level.precipitationAt) instead of the world raining flag. Rain also puts
out a burning mob, and striders are hurt by water and rain.
---
 crates/horizon-client/src/mobs/ai.rs          | 31 ++++++++++---------
 crates/horizon-client/src/mobs/aquatic.rs     |  2 +-
 crates/horizon-client/src/mobs/enderman.rs    | 10 +-----
 crates/horizon-client/src/mobs/happy_ghast.rs |  5 +--
 crates/horizon-client/src/mobs/species.rs     |  2 +-
 crates/horizon-client/src/mobs/tame.rs        |  7 +----
 crates/horizon-client/src/mobs/world.rs       | 26 ++++++++++------
 7 files changed, 39 insertions(+), 44 deletions(-)

diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 3406c09d7..ea7b14768 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -444,6 +444,16 @@ pub fn tick_swing(m: &mut Mob) {
     }
     m.anim.attack_anim = m.ai.swing_time as f32 / 6.0;
 }
+/// `Entity.isInRain`: rain at the block position, or at the top of the box.
+pub(super) fn in_rain(m: &Mob, w: &MobWorld) -> bool {
+    let (x, y, z) = (
+        m.position.x.floor() as i32,
+        m.position.y.floor() as i32,
+        m.position.z.floor() as i32,
+    );
+    let top = (m.position.y + f64::from(m.height())).floor() as i32;
+    w.raining_at(x, y, z) || w.raining_at(x, top, z)
+}
 /// `LivingEntity.baseTick` refills a breather's air by 4, then
 /// `Axolotl.handleAirSupply` (unless the mob has no AI): water or rain fills
 /// it, anywhere else it runs down from the pre-tick value, and at -20 the
@@ -454,15 +464,7 @@ fn axolotl_air_supply(m: &mut Mob, w: &MobWorld) {
     if m.no_ai {
         return;
     }
-    // Entity.isInRain: rain at the block, or at the top of the box.
-    let (x, y, z) = (
-        m.position.x.floor() as i32,
-        m.position.y.floor() as i32,
-        m.position.z.floor() as i32,
-    );
-    let top = (m.position.y + f64::from(m.height())).floor() as i32;
-    let in_rain = w.raining_at(x, y, z) || w.raining_at(x, top, z);
-    if m.fluids.in_water || in_rain {
+    if m.fluids.in_water || in_rain(m, w) {
         m.air = super::axolotl::MAX_AIR;
     } else {
         m.air = before - 1;
@@ -490,8 +492,9 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         );
         m.damage(fire, Damage::of(DamageKind::InFire));
     }
-    // Fire: water extinguishes, lava ignites, burning hurts every second.
-    if m.fluids.in_water && m.fire_ticks > 0 {
+    // Fire: water or rain (Entity.isInRain) extinguishes, lava ignites,
+    // burning hurts every second.
+    if m.fire_ticks > 0 && (m.fluids.in_water || in_rain(m, w)) {
         m.fire_ticks = 0;
         events.push(MobEvent::Sound(
             "entity.generic.extinguish_fire",
@@ -553,9 +556,7 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
             m.air = (m.air + 4).min(300);
         }
 
-        if m.kind.flags.water_sensitive
-            && (m.fluids.in_water || w.raining && w.can_see_sky(ex, ey, ez))
-        {
+        if m.kind.flags.water_sensitive && (m.fluids.in_water || in_rain(m, w)) {
             m.damage(1.0, Damage::of(DamageKind::Drown));
         }
     }
@@ -888,7 +889,7 @@ fn sun_burn_tick(m: &mut Mob, w: &MobWorld) -> bool {
         m.position.z.floor() as i32,
     );
     let br = w.brightness(x, y, z);
-    let wet = m.fluids.in_water || w.raining && w.can_see_sky(x, y, z);
+    let wet = m.fluids.in_water || in_rain(m, w);
     br > 0.5 && m.random.next_float() * 30.0 < (br - 0.4) * 2.0 && !wet && w.can_see_sky(x, y, z)
 }
 /// Mob.serverAiStep
diff --git a/crates/horizon-client/src/mobs/aquatic.rs b/crates/horizon-client/src/mobs/aquatic.rs
index f63a42239..59a73c605 100644
--- a/crates/horizon-client/src/mobs/aquatic.rs
+++ b/crates/horizon-client/src/mobs/aquatic.rs
@@ -259,7 +259,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         }
         S::Dolphin => {
             // Dolphin.tick: moisture out of water, hop on land.
-            if m.fluids.in_water || w.raining {
+            if m.fluids.in_water || super::ai::in_rain(m, w) {
                 m.extra.counter = 2400;
             } else {
                 m.extra.counter -= 1;
diff --git a/crates/horizon-client/src/mobs/enderman.rs b/crates/horizon-client/src/mobs/enderman.rs
index 3ccd963a2..17566fb65 100644
--- a/crates/horizon-client/src/mobs/enderman.rs
+++ b/crates/horizon-client/src/mobs/enderman.rs
@@ -184,15 +184,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
             }
         }
     }
-    if (m.fluids.in_water
-        || w.raining
-            && w.can_see_sky(
-                m.position.x.floor() as i32,
-                m.eye_y().floor() as i32,
-                m.position.z.floor() as i32,
-            ))
-        && m.alive()
-    {
+    if (m.fluids.in_water || super::ai::in_rain(m, w)) && m.alive() {
         // Hurt by water: teleport away.
         m.extra.counter2 = m.extra.counter2.max(1);
     }
diff --git a/crates/horizon-client/src/mobs/happy_ghast.rs b/crates/horizon-client/src/mobs/happy_ghast.rs
index bd4c5b1f3..296644acc 100644
--- a/crates/horizon-client/src/mobs/happy_ghast.rs
+++ b/crates/horizon-client/src/mobs/happy_ghast.rs
@@ -544,14 +544,15 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld) {
             m.ai.home = Some((here, radius));
         }
     }
-    // continuousHeal: a point every 30 seconds, every second in rain.
+    // continuousHeal: a point every 30 seconds, every second in rain or snow
+    // (Level.precipitationAt).
     if m.alive() && m.death_time == 0 && m.health < m.attrs.max_health {
         let (x, y, z) = (
             m.position.x.floor() as i32,
             m.position.y.floor() as i32,
             m.position.z.floor() as i32,
         );
-        let wet = w.raining && w.can_see_sky(x, y, z);
+        let wet = w.precipitation_at(x, y, z).is_some();
         let interval = if wet { 20 } else { 600 };
         if m.age.is_multiple_of(interval) {
             m.health = (m.health + 1.0).min(m.attrs.max_health);
diff --git a/crates/horizon-client/src/mobs/species.rs b/crates/horizon-client/src/mobs/species.rs
index f48a21fe9..14b462b72 100644
--- a/crates/horizon-client/src/mobs/species.rs
+++ b/crates/horizon-client/src/mobs/species.rs
@@ -1500,7 +1500,7 @@ impl Def {
                 ),
             // Nautilus.handleAirSupply: it dries out on land.
             needs_water: aquatic || s == S::Nautilus,
-            water_sensitive: matches!(s, S::Enderman | S::Blaze | S::SnowGolem),
+            water_sensitive: matches!(s, S::Enderman | S::Blaze | S::SnowGolem | S::Strider),
             animal: !matches!(s, S::Bat | S::SulfurCube | S::Mannequin)
                 && !self.hostile_class()
                 && !aquatic
diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs
index 1e725df80..c9bd26457 100644
--- a/crates/horizon-client/src/mobs/tame.rs
+++ b/crates/horizon-client/src/mobs/tame.rs
@@ -529,12 +529,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     let v = &mut m.anim.v;
     v[INTEREST] += (goal - v[INTEREST]) * 0.4;
     // isWet (extra.flag2), isShaking (counter2 > 0).
-    let rain = w.raining
-        && w.can_see_sky(
-            m.position.x.floor() as i32,
-            (m.position.y + f64::from(m.height())).floor() as i32,
-            m.position.z.floor() as i32,
-        );
+    let rain = super::ai::in_rain(m, w);
     let shaking = m.extra.counter2 > 0;
     if m.fluids.in_water || rain {
         m.extra.flag2 = true;
diff --git a/crates/horizon-client/src/mobs/world.rs b/crates/horizon-client/src/mobs/world.rs
index bce324228..dc201a3f3 100644
--- a/crates/horizon-client/src/mobs/world.rs
+++ b/crates/horizon-client/src/mobs/world.rs
@@ -206,18 +206,24 @@ impl MobWorld<'_> {
         }
         self.world.light(x, y, z) >> 4 == 15
     }
-    /// Level.isRainingAt: raining, open to the sky, nothing motion blocking
-    /// above, and the biome's precipitation at the position is rain, not snow
+    /// Level.precipitationAt: raining, open to the sky, nothing motion
+    /// blocking above, then the biome's precipitation at the position:
+    /// `Some(true)` rain, `Some(false)` snow, `None` nothing.
+    pub fn precipitation_at(&self, x: i32, y: i32, z: i32) -> Option<bool> {
+        if !self.raining || !self.can_see_sky(x, y, z) || self.motion_blocking_height(x, z) > y {
+            return None;
+        }
+        let chunk = self.world.chunks.get(&(x >> 4, z >> 4))?;
+        let biome = self.biomes.get(chunk.biome(x, y, z));
+        if !biome.precipitation {
+            return None;
+        }
+        Some(biome.temperature_at(BlockPos::new(x, y, z), self.sea_level) >= 0.15)
+    }
+    /// Level.isRainingAt: the precipitation at the position is rain, not snow
     /// or none.
     pub fn raining_at(&self, x: i32, y: i32, z: i32) -> bool {
-        if !self.raining || !self.can_see_sky(x, y, z) || self.motion_blocking_height(x, z) > y {
-            return false;
-        }
-        let Some(chunk) = self.world.chunks.get(&(x >> 4, z >> 4)) else {
-            return false;
-        };
-        let biome = self.biomes.get(chunk.biome(x, y, z));
-        biome.precipitation && biome.temperature_at(BlockPos::new(x, y, z), self.sea_level) >= 0.15
+        self.precipitation_at(x, y, z) == Some(true)
     }
     /// Level.getLightLevelDependentMagicValue: the dimension's brightness curve
     /// at the raw (sky darkened) light level.

From 87d577e5665b72ae2c54d9044ad0dfa37f45b1fa Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Tue, 27 Oct 2026 00:20:08 +0100
Subject: [PATCH 373/475] Check rain at the player's and arrow's position

Arrows now ask whether it rains at their spot (biome precipitation and
blocks above, Level.isRainingAt) instead of just the sky light, and a
Riptide trident needs rain at the player's position. Rain also puts out
a burning player (Entity.baseTick), in the window and for guests on the
server thread.
---
 crates/horizon-client/src/game.rs             |  9 +++++
 .../src/game/block_entity_anims.rs            |  2 +-
 crates/horizon-client/src/game/creatures.rs   |  6 +--
 crates/horizon-client/src/game/lan_actions.rs |  2 +
 crates/horizon-client/src/game/powder_snow.rs | 38 ++++++++++++++++++-
 crates/horizon-client/src/game/trident.rs     |  6 +--
 6 files changed, 53 insertions(+), 10 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index db49087b2..87d87f8a3 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -4669,6 +4669,7 @@ impl Game<'_> {
             }
         }
         self.powder_snow_fire()?;
+        self.rain_extinguish_in_frame();
         self.tick_totem();
         let Some(player) = self.player.as_mut() else {
             return Ok(());
@@ -9903,6 +9904,14 @@ impl Game<'_> {
         };
         Some(t < 0.15)
     }
+    /// `Level.isRainingAt`: it rains, the sky light is 15, nothing that stops
+    /// motion is above, and the biome's precipitation there is rain.
+    fn raining_at(&self, p: BlockPos) -> bool {
+        self.world.weather.levels(1.0).0 > 0.2
+            && self.world.light(p.x, p.y, p.z) >> 4 == 15
+            && self.rain_height(p.x, p.z) <= p.y
+            && self.precipitation(p.x, p.y, p.z) == Some(false)
+    }
     /// `getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)`: one above the
     /// highest block in `blocks_motion_in_heightmap` or holding a fluid.
     fn rain_height(&self, x: i32, z: i32) -> i32 {
diff --git a/crates/horizon-client/src/game/block_entity_anims.rs b/crates/horizon-client/src/game/block_entity_anims.rs
index 6f92d7f55..7790a48f3 100644
--- a/crates/horizon-client/src/game/block_entity_anims.rs
+++ b/crates/horizon-client/src/game/block_entity_anims.rs
@@ -547,7 +547,7 @@ impl Game<'_> {
         });
     }
     /// `Entity.isInRain`: rain at the block position or at the top of the box.
-    fn in_rain(&mut self, at: Vec3, top: f64) -> bool {
+    pub(super) fn in_rain(&mut self, at: Vec3, top: f64) -> bool {
         let p = BlockPos::new(
             at.x.floor() as i32,
             at.y.floor() as i32,
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index e895cb7f7..632fae3e7 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2118,11 +2118,9 @@ impl Game<'_> {
             ArrowEvent::ShootEvent | ArrowEvent::Drop => {}
         }
     }
-    /// `Level.isRainingAt` for arrows: raining, open to the sky (the biome's
-    /// precipitation is not checked here).
+    /// `Level.isRainingAt` for arrows.
     fn arrow_rain(&self) -> impl Fn(BlockPos) -> bool + '_ {
-        let raining = self.world.weather.levels(1.0).0 > 0.2;
-        move |p: BlockPos| raining && self.world.light(p.x, p.y, p.z) >> 4 == 15
+        move |p: BlockPos| self.raining_at(p)
     }
     /// The level as arrows see it.
     fn arrow_scene<'s>(
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index dc1e74f0b..8928f634a 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -2267,6 +2267,8 @@ impl Game<'_> {
                     game.cauldron_extinguish(*pos);
                 }
             }
+            // Entity.baseTick: rain puts out a burning player.
+            game.rain_extinguish_player();
             // WitherRoseBlock.entityInside along those moves.
             for event in &events {
                 if matches!(event, MotionEvent::InsideWitherRose) {
diff --git a/crates/horizon-client/src/game/powder_snow.rs b/crates/horizon-client/src/game/powder_snow.rs
index 6a904706f..5b3692df3 100644
--- a/crates/horizon-client/src/game/powder_snow.rs
+++ b/crates/horizon-client/src/game/powder_snow.rs
@@ -53,7 +53,11 @@ impl Game<'_> {
         if let Some(player) = self.player.as_mut() {
             player.fire_ticks = 0;
         }
-        // Entity.playEntityOnFireExtinguishedSound
+        self.extinguish_sound(at);
+        Ok(())
+    }
+    /// Entity.playEntityOnFireExtinguishedSound
+    fn extinguish_sound(&mut self, at: [f64; 3]) {
         let r = self.particles.random();
         let pitch = 1.6 + (r.next_float() - r.next_float()) * 0.4;
         self.audio.play(
@@ -62,7 +66,37 @@ impl Game<'_> {
             0.7,
             pitch,
         );
-        Ok(())
+    }
+    /// `Entity.baseTick`: a burning player in the rain (`isInRain`) has the
+    /// fire put out (`clearFire`). Returns whether it did.
+    pub(super) fn rain_extinguish_player(&mut self) -> bool {
+        let Some(player) = self.player.as_ref() else {
+            return false;
+        };
+        let (at, top) = (player.position, player.bounds().max_position().y);
+        if player.fire_ticks <= 0 || !self.in_rain(at, top) {
+            return false;
+        }
+        if let Some(player) = self.player.as_mut() {
+            player.fire_ticks = 0;
+        }
+        true
+    }
+    /// The in-window player's rain extinguish, with its sound (a server's
+    /// fire is the server's).
+    pub(super) fn rain_extinguish_in_frame(&mut self) {
+        if self.remote.is_some() {
+            return;
+        }
+        let at = self
+            .player
+            .as_ref()
+            .map(|p| [p.position.x, p.position.y, p.position.z]);
+        if self.rain_extinguish_player()
+            && let Some(at) = at
+        {
+            self.extinguish_sound(at);
+        }
     }
     /// Whether the block at `pos` is powder snow.
     pub(super) fn is_powder_snow(&self, pos: [i32; 3]) -> bool {
diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs
index d934e85aa..01bc6af5f 100644
--- a/crates/horizon-client/src/game/trident.rs
+++ b/crates/horizon-client/src/game/trident.rs
@@ -112,7 +112,7 @@ impl Game<'_> {
         }
         true
     }
-    fn in_water_or_rain(&self) -> bool {
+    fn in_water_or_rain(&mut self) -> bool {
         let Some(p) = &self.player else { return false };
         let (x, y, z) = (
             p.position.x.floor() as i32,
@@ -121,8 +121,8 @@ impl Game<'_> {
         );
         let water = self.res.facts().get(self.world.block(x, y, z)).fluid
             == horizon_client::blocks::Fluid::Water;
-        let sky = self.world.light(x, y + 1, z) >> 4 == 15;
-        water || (self.world.weather.raining && sky)
+        let (at, top) = (p.position, p.bounds().max_position().y);
+        water || self.in_rain(at, top)
     }
     /// The living entities a spinning player can touch this tick, for
     /// `LivingEntity.checkAutoSpinAttack` (none when not spinning).

From 6384234e37fdd6b6bb3911e502c96c37a5e39b85 Mon Sep 17 00:00:00 2001
From: levzzz <86072227+levzzz5154@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:32:16 +0500
Subject: [PATCH 374/475] Stop a piston push at the world border

`move_pushed` resolved the pushed movement with `SceneCollisions`, which
supplies no world-border collision, so a piston next to the border could push
a player through it even though ordinary movement stops at the border.
`Entity.move` collects the border's walls in
`collectCollidersIgnoringWorldBorder` whenever
`WorldBorder.isInsideCloseToBorder` holds, and `CollisionGetter.borderCollision`
adds `WorldBorder.getCollisionShape` to them. The push now resolves through
`EntityCollisions::with_border`, which applies that same rule to the pushed
body's own x and z, so a body pushed into the border's wall stops there.

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 crates/horizon-client/src/collisions.rs       |  99 ++++++++++++++-
 crates/horizon-client/src/game/piston_push.rs | 114 ++++++++++++++++--
 tools/lan_e2e.py                              |  50 ++++++++
 3 files changed, 249 insertions(+), 14 deletions(-)

diff --git a/crates/horizon-client/src/collisions.rs b/crates/horizon-client/src/collisions.rs
index 9ec271b27..d35a1adfa 100644
--- a/crates/horizon-client/src/collisions.rs
+++ b/crates/horizon-client/src/collisions.rs
@@ -161,8 +161,21 @@ impl<W: EntityMovementWorld<Error = io::Error>> EntityMovementWorld for EntityCo
         border.collision_shape().map(Some).map_err(io::Error::other)
     }
 }
-impl EntityCollisions<'_, SceneCollisions<'_, '_>> {
-    /// `SceneCollisions::resolve` that also stops at the entity boxes.
+impl<'a, W> EntityCollisions<'a, W>
+where
+    W: BlockCollisionWorld<Error = io::Error> + EntityMovementWorld<Error = io::Error>,
+{
+    /// `EntityCollisions` for a body the world border also stops: the border
+    /// and the body's own x and z (`WorldBorder.isInsideCloseToBorder`).
+    pub fn with_border(blocks: W, border: &'a BorderGeometry, at: [f64; 2]) -> Self {
+        Self {
+            blocks,
+            entities: &[],
+            border: Some((border, at)),
+        }
+    }
+    /// `SceneCollisions::resolve` that also stops at the entity boxes and,
+    /// with a border, at the world border's walls.
     pub fn resolve(
         &mut self,
         bounds: Aabb,
@@ -170,12 +183,11 @@ impl EntityCollisions<'_, SceneCollisions<'_, '_>> {
         max_step: f32,
         on_ground: bool,
     ) -> Result<Vec3> {
-        let context = self.blocks.context(bounds);
         Ok(resolve_world_movement(
             self,
             MovementRequest {
                 entity: EntityIdentity(0),
-                context,
+                context: CollisionContext::position(bounds.min_position().y),
                 bounds,
                 movement,
                 max_step,
@@ -409,6 +421,42 @@ impl PowderSnowWorld for SceneCollisions<'_, '_> {
     }
 }
 
+/// A collision world without blocks: no chunk is resident, so only the
+/// world border stops a body.
+pub struct EmptyCollisions;
+
+impl BlockCollisionWorld for EmptyCollisions {
+    type Error = io::Error;
+    type Chunk = ChunkPos;
+    fn collision_chunk(&mut self, _: ChunkPos) -> io::Result<Option<ChunkPos>> {
+        Ok(None)
+    }
+    fn collision_block(&mut self, _: ChunkPos, _: BlockPos) -> io::Result<CollisionBlock> {
+        Err(io::Error::other("no chunk is resident"))
+    }
+    fn is_suffocating(&mut self, _: ChunkPos, _: CollisionBlock, _: BlockPos) -> io::Result<bool> {
+        Ok(false)
+    }
+    fn context_shape(
+        &mut self,
+        _: CollisionBlock,
+        _: BlockPos,
+        _: &CollisionContext<'_>,
+    ) -> io::Result<VoxelShape> {
+        Ok(VoxelShape::empty())
+    }
+}
+
+impl EntityMovementWorld for EmptyCollisions {
+    type Error = io::Error;
+    fn entity_collisions(&mut self, _: EntityIdentity, _: Aabb) -> io::Result<Vec<VoxelShape>> {
+        Ok(Vec::new())
+    }
+    fn movement_border(&mut self, _: EntityIdentity, _: Aabb) -> io::Result<Option<VoxelShape>> {
+        Ok(None)
+    }
+}
+
 /// Collision queries over any block lookup (test worlds without chunks):
 /// every chunk is present, nothing is suffocating, no entities collide.
 pub struct LookupCollisions<'w, 'r> {
@@ -520,3 +568,46 @@ mod piston_noclip_tests {
         assert_eq!(PISTON_NOCLIP.with(|value| value.get()), None);
     }
 }
+
+#[cfg(test)]
+mod border_movement_tests {
+    use super::*;
+
+    /// A border 10 wide around the origin: its wall's inner face is at x = 5.
+    fn border() -> BorderGeometry {
+        BorderGeometry::new([0.0, 0.0], 10.0, 29_999_984).expect("a border")
+    }
+
+    /// `WorldBorder.isInsideCloseToBorder` and `WorldBorder.getCollisionShape`:
+    /// a body inside close to the border collides with the border's walls.
+    #[test]
+    fn a_body_next_to_the_border_stops_at_its_wall() {
+        // A body 0.6 wide, 0.4 blocks short of the wall, moved east into it.
+        let bounds = Aabb::new(Vec3::new(4.0, 0.0, 0.0), Vec3::new(4.6, 1.8, 0.6));
+        let border = border();
+        let mut collisions = EntityCollisions::with_border(EmptyCollisions, &border, [4.3, 0.3]);
+        let moved = collisions
+            .resolve(bounds, Vec3::new(0.51, 0.0, 0.0), 0.0, false)
+            .expect("the movement resolves");
+        // The wall stops the body 0.4 blocks short of the whole move.
+        assert!(
+            (moved.x - 0.4).abs() < 1.0e-9,
+            "the body was not stopped by the border: {moved:?}"
+        );
+    }
+
+    /// Away from the border, the same body moves the whole way.
+    #[test]
+    fn a_body_away_from_the_border_moves_whole() {
+        let bounds = Aabb::new(Vec3::new(0.0, 0.0, 0.0), Vec3::new(0.6, 1.8, 0.6));
+        let border = border();
+        let mut collisions = EntityCollisions::with_border(EmptyCollisions, &border, [0.3, 0.3]);
+        let moved = collisions
+            .resolve(bounds, Vec3::new(0.51, 0.0, 0.0), 0.0, false)
+            .expect("the movement resolves");
+        assert!(
+            (moved.x - 0.51).abs() < 1.0e-9,
+            "the body did not move the whole way: {moved:?}"
+        );
+    }
+}
diff --git a/crates/horizon-client/src/game/piston_push.rs b/crates/horizon-client/src/game/piston_push.rs
index 9c3eebb50..6bbf1cb39 100644
--- a/crates/horizon-client/src/game/piston_push.rs
+++ b/crates/horizon-client/src/game/piston_push.rs
@@ -8,10 +8,13 @@
 //! wall instead of passing through it.
 //!
 use super::Game;
-use horizon_client::collisions::{SceneCollisions, with_piston_noclip};
-use horizon_core::geometry::{Aabb, Direction, Vec3};
+use horizon_client::collisions::{EntityCollisions, SceneCollisions, with_piston_noclip};
+use horizon_core::geometry::{Aabb, Direction, Vec3, border::BorderGeometry};
 use horizon_core::position::BlockPos;
-use horizon_world::{level::pistons::MovingPiston, piston_movement::PistonMovement, piston_push};
+use horizon_world::{
+    block_collision_scan::BlockCollisionWorld, level::pistons::MovingPiston,
+    piston_movement::PistonMovement, piston_push, world_movement::EntityMovementWorld,
+};
 
 /// What one piston asks for this tick: where it is, its state, and the progress
 /// `moveCollidedEntities` runs at (before the tick stores it).
@@ -137,6 +140,7 @@ impl Game<'_> {
                 self.move_pushed(
                     target,
                     before,
+                    [body.position.x, body.position.z],
                     body.step_height,
                     body.on_ground,
                     step.scale(amount),
@@ -159,6 +163,7 @@ impl Game<'_> {
                     self.move_pushed(
                         target,
                         after.bounds,
+                        [after.position.x, after.position.z],
                         after.step_height,
                         after.on_ground,
                         back.scale(fix),
@@ -186,6 +191,7 @@ impl Game<'_> {
                     self.move_pushed(
                         target,
                         body.bounds,
+                        [body.position.x, body.position.z],
                         body.step_height,
                         body.on_ground,
                         piston_push::step_vector(movement).scale(delta_progress),
@@ -342,11 +348,12 @@ impl Game<'_> {
     }
 
     /// `Entity.move(MoverType.PISTON, movement)` for one pushed entity: the
-    /// per-tick piston limit, then the block collision scan.
+    /// per-tick piston limit, then the block and world border collision scan.
     fn move_pushed(
         &mut self,
         target: Target,
         before: Aabb,
+        at: [f64; 2],
         step_height: f32,
         on_ground: bool,
         movement: Vec3,
@@ -361,12 +368,19 @@ impl Game<'_> {
             return;
         }
         let resolved = with_piston_noclip(piston_direction, || {
-            SceneCollisions {
-                world: &self.world,
-                binding: self.collision,
-                subject: None,
-            }
-            .resolve(before, limited, step_height, on_ground)
+            pushed_movement(
+                SceneCollisions {
+                    world: &self.world,
+                    binding: self.collision,
+                    subject: None,
+                },
+                self.border.geometry(),
+                at,
+                before,
+                limited,
+                step_height,
+                on_ground,
+            )
             .unwrap_or(Vec3::ZERO)
         });
         if resolved.length_squared() <= 1.0e-7
@@ -477,3 +491,83 @@ impl Game<'_> {
         }
     }
 }
+
+/// `Entity.move(MoverType.PISTON, movement)` for a pushed body: the movement
+/// it makes. The world's blocks stop it, and so does the world border:
+/// `Entity.collectCollidersIgnoringWorldBorder` adds the border's walls when
+/// the body is inside close to the border, as ordinary movement does.
+fn pushed_movement<W>(
+    blocks: W,
+    border: &BorderGeometry,
+    at: [f64; 2],
+    before: Aabb,
+    movement: Vec3,
+    step_height: f32,
+    on_ground: bool,
+) -> horizon_client::Result<Vec3>
+where
+    W: BlockCollisionWorld<Error = std::io::Error> + EntityMovementWorld<Error = std::io::Error>,
+{
+    EntityCollisions::with_border(blocks, border, at).resolve(
+        before,
+        movement,
+        step_height,
+        on_ground,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_client::collisions::EmptyCollisions;
+
+    /// A border 10 wide around the origin: its wall's inner face is at x = 5.
+    fn border() -> BorderGeometry {
+        BorderGeometry::new([0.0, 0.0], 10.0, 29_999_984).expect("a border")
+    }
+
+    /// `Entity.collectCollidersIgnoringWorldBorder`: the border's walls stop a
+    /// pushed body that is inside close to the border.
+    #[test]
+    fn a_pushed_body_stops_at_the_world_border() {
+        // A body 0.6 wide, 0.4 blocks short of the wall, pushed east into it.
+        let before = Aabb::new(Vec3::new(4.0, 0.0, 0.0), Vec3::new(4.6, 1.8, 0.6));
+        let border = border();
+        let moved = pushed_movement(
+            EmptyCollisions,
+            &border,
+            [4.3, 0.3],
+            before,
+            Vec3::new(0.51, 0.0, 0.0),
+            0.0,
+            false,
+        )
+        .expect("the push resolves");
+        // The wall stops the body 0.4 blocks short of the whole push.
+        assert!(
+            (moved.x - 0.4).abs() < 1.0e-9,
+            "the body was not stopped by the border: {moved:?}"
+        );
+    }
+
+    /// Away from the border, the same push moves the whole way.
+    #[test]
+    fn a_pushed_body_moves_whole_away_from_the_border() {
+        let before = Aabb::new(Vec3::new(0.0, 0.0, 0.0), Vec3::new(0.6, 1.8, 0.6));
+        let border = border();
+        let moved = pushed_movement(
+            EmptyCollisions,
+            &border,
+            [0.3, 0.3],
+            before,
+            Vec3::new(0.51, 0.0, 0.0),
+            0.0,
+            false,
+        )
+        .expect("the push resolves");
+        assert!(
+            (moved.x - 0.51).abs() < 1.0e-9,
+            "the body did not move the whole push: {moved:?}"
+        );
+    }
+}
diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index 4bb9a478b..585b3000b 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -2453,6 +2453,56 @@ def check_piston_push(host, guest, out):
     after = next(p['pos'][0] for p in pigs if p['id'] == pig['id'])
     results['pig'] = after - before
     assert results['pig'] > 0.3, f'piston did not push pig: {before} -> {after}'
+    results.update(piston_push_at_border(host, guest))
+    return results
+
+
+def piston_push_at_border(host, guest):
+    """A piston next to the world border: the border's wall stops the pushed
+    body, as it stops ordinary movement (`Entity.collectCollidersIgnoringWorldBorder`)."""
+    hx, _, hz = pos_of(host)
+    x, y, z = (int(hx // 16) * 16 + 8, 100, int(hz // 16) * 16 + 8)
+    host('command', command=f'fill {x-4} {y-1} {z-4} {x+7} {y-1} {z+4} minecraft:stone')
+    host('command', command=f'fill {x-4} {y} {z-4} {x+7} {y+5} {z+4} minecraft:air')
+    host('command', command=f'setblock {x} {y} {z} minecraft:piston[facing=east]')
+    # The border's east wall stands at `x + 2`, the east face of the block the
+    # head extends into: a body pushed east stops there instead of being
+    # pushed out through the border. `worldborder center` centres integers on
+    # the block, so the centre is `x - 8.5` and the wall lands on `x + 2`.
+    wall = x + 2
+    center = [x - 8.5, z + 0.5]
+    results = {}
+    try:
+        host('command', command=f'worldborder center {x - 9} {z}')
+        host('command', command='worldborder set 20.5')
+        seen = None
+        for _ in range(10):
+            host.wait(2)
+            seen = [g('status').get('border') for g in (host, guest)]
+            if all(b and b['size'] == 20.5 and b['center'] == center for b in seen):
+                break
+        results['border'] = seen
+        for player, name in ((host, host.player), (guest, GUEST_NAME)):
+            host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+            host.wait(10)
+            host('command', command=f'tp @s {x+5.5} {y} {z+2.5}')
+            host('command', command=f'tp {GUEST_NAME} {x+5.5} {y} {z-1.5}')
+            host('command', command=f'tp {"@s" if player is host else GUEST_NAME} {x+1.65} {y} {z+0.5}')
+            player.wait(15)
+            before = pos_of(player)
+            assert abs(before[0] - (x + 1.65)) < 0.1, f'{name} did not reach the piston: {before}'
+            host('command', command=f'setblock {x-1} {y} {z} minecraft:redstone_block')
+            player.wait(30)
+            after = pos_of(player)
+            # The wall's inner face is at `wall`: the body's box stops there.
+            results[name] = round(after[0] - before[0], 3)
+            assert after[0] > before[0], f'the piston did not push {name}: {before} -> {after}'
+            assert after[0] <= wall - 0.3 + 0.01, f'the border did not stop {name}: {before} -> {after}'
+        host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+        host.wait(10)
+    finally:
+        host('command', command='worldborder center 0 0')
+        host('command', command='worldborder set 59999968')
     return results
 
 

From a934dac2bd240267bb02a9c3eac80a89367c09dd Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Tue, 27 Oct 2026 00:32:30 +0100
Subject: [PATCH 375/475] Save and load the difficulty through level.dat's
 difficulty_settings

---
 crates/horizon-client/src/game.rs      |  3 ++
 crates/horizon-client/src/game/chat.rs | 43 +++++---------------------
 2 files changed, 11 insertions(+), 35 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index db49087b2..bc2424316 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -10487,6 +10487,9 @@ impl Game<'_> {
         let level = &mut self.level;
         level.creative = self.creative;
         level.game_mode = mode;
+        // PrimaryLevelData.setDifficulty: /difficulty and the options button change it.
+        level.difficulty =
+            horizon_client::title::DIFFICULTIES[usize::from(self.ui.difficulty) & 3].into();
         level.time = self.world.game_time;
         level.weather = self.world.weather;
         level.day_time = self.world.day_time;
diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs
index 03174c009..94f7661b7 100644
--- a/crates/horizon-client/src/game/chat.rs
+++ b/crates/horizon-client/src/game/chat.rs
@@ -801,7 +801,11 @@ impl Game<'_> {
     pub(super) fn load_world_state(&mut self) {
         self.ui.rules = GameRules::load(&self.world_root);
         self.ui.clock = WorldClock::default();
-        self.ui.difficulty = read_difficulty(&self.world_root).unwrap_or(2);
+        // PrimaryLevelData: the difficulty comes back from level.dat's difficulty_settings.
+        self.ui.difficulty = horizon_client::title::DIFFICULTIES
+            .iter()
+            .position(|d| *d == self.level.difficulty)
+            .map_or(2, |i| i as u8);
         if let Ok(bytes) = std::fs::read(self.world_root.join("data/minecraft/world_clocks.dat"))
             && let Ok(raw) = horizon_world::compression::Compression::Gzip.decode(&bytes, 1 << 20)
             && let Ok((root, _)) =
@@ -826,9 +830,9 @@ impl Game<'_> {
         self.build_registries();
         self.sync_rules();
     }
-    /// Save the clock and the difficulty beside level.dat (Level.write saves
-    /// the game rules: a second writer of game_rules.dat could leave it with
-    /// the rules loaded when the world opened).
+    /// Save the clock beside level.dat (Level.write saves the game rules: a
+    /// second writer of game_rules.dat could leave it with the rules loaded
+    /// when the world opened).
     pub(super) fn save_world_state(&mut self) {
         if self.world_root.as_os_str().is_empty() {
             return;
@@ -876,9 +880,6 @@ impl Game<'_> {
         if let Err(e) = horizon_client::save::write_dat(&path, root) {
             log::warn!("the world clocks were not written: {e}");
         }
-        if let Err(e) = write_difficulty(&self.world_root, self.ui.difficulty) {
-            log::warn!("the difficulty was not written: {e}");
-        }
     }
     /// Death message in chat (CombatTracker.getDeathMessage, as far as the
     /// cause is known to the client).
@@ -988,34 +989,6 @@ pub fn screenshot_name(dir: &std::path::Path) -> String {
         n += 1;
     }
 }
-fn read_difficulty(world: &std::path::Path) -> Option<u8> {
-    let bytes = std::fs::read(world.join("level.dat")).ok()?;
-    let raw = horizon_world::compression::Compression::Gzip
-        .decode(&bytes, 64 << 20)
-        .ok()?;
-    let (root, _) =
-        horizon_world::nbt::read_named(&raw, horizon_world::nbt::Limits::default()).ok()?;
-    match root.tag.get("Data")?.get("Difficulty")? {
-        horizon_world::nbt::Tag::Byte(b) => Some((*b).clamp(0, 3) as u8),
-        _ => None,
-    }
-}
-/// Patch `Data.Difficulty` in level.dat (Level::write stores the default).
-fn write_difficulty(world: &std::path::Path, difficulty: u8) -> horizon_client::Result<()> {
-    use horizon_world::{compression::Compression, nbt};
-    let path = world.join("level.dat");
-    let bytes = std::fs::read(&path)?;
-    let raw = Compression::Gzip.decode(&bytes, 64 << 20)?;
-    let (mut root, _) = nbt::read_named(&raw, nbt::Limits::default()).map_err(|e| e.to_string())?;
-    if let Some(data) = root.tag.get_mut("Data")
-        && let Some(d) = data.get_mut("Difficulty")
-    {
-        *d = nbt::Tag::Byte(difficulty as i8);
-    }
-    let out = nbt::write_named(&root, nbt::Limits::default()).map_err(|e| e.to_string())?;
-    std::fs::write(&path, Compression::Gzip.encode(&out)?)?;
-    Ok(())
-}
 
 /// `IntegratedServer.getProfilePermissions` for the owner: `OWNER` (4) when
 /// commands are allowed, else `ALL` (0).

From e184ab7a424f4b1d9155c284a44bbada9244015c Mon Sep 17 00:00:00 2001
From: levzzz <86072227+levzzz5154@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:35:26 +0500
Subject: [PATCH 376/475] A villager that loses its job site offers its new
 profession's trades

The reported sequence in #1639: a villager works at a bench, the bench is
destroyed and it takes another bench's job, and then it does not open a
trading menu.

`Villager.setVillagerData` drops the offers (`offers = null`) when the
profession changes, so the next `AbstractVillager.getOffers` rolls the new
profession's trade set. The brain reaches that through `set_profession`,
which now also marks the offers as not made (#2009); this test covers the
whole reported sequence, from the lost job site to the new profession's
trades, so a villager that keeps the old profession's offers marked as made
cannot pass it.

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 crates/horizon-client/src/mobs/villager.rs | 47 ++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/crates/horizon-client/src/mobs/villager.rs b/crates/horizon-client/src/mobs/villager.rs
index aad0ec911..20280b190 100644
--- a/crates/horizon-client/src/mobs/villager.rs
+++ b/crates/horizon-client/src/mobs/villager.rs
@@ -905,6 +905,53 @@ mod tests {
         assert!(t.unset);
         assert_eq!(m.extra.variant2, 2);
     }
+    /// The reported sequence: a villager works at a bench, the bench is
+    /// destroyed (its job site is gone, so `ResetProfession` makes it
+    /// unemployed) and it takes another bench's job. The new profession's
+    /// trades are offered again.
+    ///
+    /// `Villager.setVillagerData` drops the offers (`offers = null`) when the
+    /// profession changes, so `AbstractVillager.getOffers` rolls the new
+    /// profession's trade set the next time the offers are asked for. A
+    /// villager that keeps its old offers marked as made never trades again:
+    /// it shakes its head instead of opening the trading menu.
+    #[test]
+    fn a_villager_that_loses_its_job_site_offers_its_new_profession_trades() {
+        let mut m = villager();
+        // The composter's job: the villager is a farmer.
+        set_profession(&mut m, 5);
+        assert_eq!(m.extra.variant2, 5);
+        // Its trades were made, so the offers are there.
+        let trade = m.extra.trade.get_or_insert_default();
+        trade.unset = false;
+        trade.offers = vec![crate::merchant::MerchantOffer {
+            base_cost_a: crate::merchant::ItemCost {
+                stack: ItemStack::new("minecraft:wheat", 20),
+            },
+            cost_b: None,
+            result: ItemStack::new("minecraft:emerald", 1),
+            uses: 0,
+            max_uses: 16,
+            reward_exp: true,
+            special_price_diff: 0,
+            demand: 0,
+            price_multiplier: 0.0,
+            xp: 1,
+        }];
+        // The work bench is destroyed: the job site is gone, so the villager
+        // is unemployed and its offers are dropped (`offers = null`).
+        set_profession(&mut m, NONE);
+        let t = m.extra.trade.as_ref().unwrap();
+        assert!(t.offers.is_empty());
+        assert!(t.unset);
+        // It takes the smithing table's job. The new profession's trades are
+        // rolled by the next `getOffers` (ensure_offers).
+        set_profession(&mut m, 13);
+        let t = m.extra.trade.as_ref().unwrap();
+        assert!(t.offers.is_empty());
+        assert!(t.unset);
+        assert_eq!(m.extra.variant2, 13);
+    }
 
     fn stack(item: &str, count: u32) -> ItemStack {
         ItemStack::new(item, count)

From b1450f1ef283e5f3902f43a775e080388ade2691 Mon Sep 17 00:00:00 2001
From: FusselTV <github@fussel.tv>
Date: Mon, 26 Oct 2026 23:51:40 +0100
Subject: [PATCH 377/475] Mobs: foxes, rabbits, goats and horses keep their
 state

finalizeSpawn picks a fox's type (red or snow), a rabbit's type, a goat's
screaming flag and horns and a horse's max health, but the save and the
load did not keep them: a snow fox came back red, every rabbit brown, a
goat that had lost a horn grew it back, and a new horse was saved with
the type's health (53) above the max health it rolled.

- Fox, Rabbit and Goat.addAdditionalSaveData: Type, RabbitType,
  IsScreamingGoat, HasLeftHorn and HasRightHorn are saved from the model
  and read back (an unknown rabbit type is brown, horns default to
  present, as vanilla reads them).
- The fields Horizon does not model (a fox's Trusted, Sleeping, Sitting,
  Crouching, a rabbit's MoreCarrotTicks, a horse's EatingHaystack and
  Bred) keep a loaded value or get vanilla's default.
- A loaded horse or llama gets its health clamped to its max health, as
  LivingEntity.setHealth does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/entity_nbt.rs | 103 ++++++++++++++++++++++++
 1 file changed, 103 insertions(+)

diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 8926b3bbe..8918c4b2d 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -244,6 +244,32 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         );
     }
     match id {
+        // Fox.addAdditionalSaveData; Horizon models only the type.
+        "minecraft:fox" => {
+            let kind = if m.extra.variant == 1 { "snow" } else { "red" };
+            map.insert("Type".into(), string(kind));
+            for (key, value) in [
+                ("Trusted", Tag::List(Vec::new())),
+                ("Sleeping", Tag::Byte(0)),
+                ("Sitting", Tag::Byte(0)),
+                ("Crouching", Tag::Byte(0)),
+            ] {
+                map.entry(key.into()).or_insert(value);
+            }
+        }
+        "minecraft:rabbit" => {
+            map.insert("RabbitType".into(), Tag::Int(i32::from(m.extra.variant)));
+            map.entry("MoreCarrotTicks".into()).or_insert(Tag::Int(0));
+        }
+        "minecraft:goat" => {
+            map.insert(
+                "IsScreamingGoat".into(),
+                Tag::Byte(i8::from(m.extra.screaming)),
+            );
+            let [left, right] = m.extra.lost_horns;
+            map.insert("HasLeftHorn".into(), Tag::Byte(i8::from(!left)));
+            map.insert("HasRightHorn".into(), Tag::Byte(i8::from(!right)));
+        }
         "minecraft:creeper" => {
             for (key, value) in [("Fuse", Tag::Short(30)), ("ExplosionRadius", Tag::Byte(3))] {
                 map.entry(key.into()).or_insert(value);
@@ -298,6 +324,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         | "minecraft:trader_llama" => {
             map.insert("Tame".into(), Tag::Byte(i8::from(m.extra.tame)));
             map.insert("Temper".into(), Tag::Int(i32::from(m.extra.variant3)));
+            // AbstractHorse.addAdditionalSaveData; Horizon models neither.
+            for key in ["EatingHaystack", "Bred"] {
+                map.entry(key.into()).or_insert(Tag::Byte(0));
+            }
             if let Some(owner) = m.extra.owner {
                 map.insert("Owner".into(), Tag::IntArray(owner.to_vec()));
             }
@@ -669,6 +699,12 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
         }
     }
     m.health = float(tag.get("Health")).map_or(m.attrs.max_health, |h| h as f32);
+    // LivingEntity.setHealth clamps to the max health: a horse or llama is made
+    // with the type's and saved before it drops to the one it rolled. (Only
+    // the base is read here, so the clamp would cut a leader zombie's bonus.)
+    if crate::mobs::equine::is_equine(m.species()) {
+        m.health = m.health.min(m.attrs.max_health);
+    }
     m.hurt_time = number(tag.get("HurtTime")).unwrap_or(0) as i32;
     // What it holds (equipment.mainhand / offhand), when saved.
     if let Some(eq) = tag.get("equipment") {
@@ -818,6 +854,24 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
         let sounds = crate::mobs::finalize::sound_variants(m.species());
         m.extra.sound_variant = sounds.iter().position(|n| *n == v).map(|i| i as u8);
     }
+    match m.species() {
+        crate::mobs::Species::Fox => {
+            m.extra.variant = u8::from(text(tag.get("Type")).as_deref() == Some("snow"));
+        }
+        crate::mobs::Species::Rabbit => {
+            // Rabbit.Variant.byId: an unknown id is brown.
+            m.extra.variant = match number(tag.get("RabbitType")).unwrap_or(0) {
+                v @ (0..=5 | 99) => v as u8,
+                _ => 0,
+            };
+        }
+        crate::mobs::Species::Goat => {
+            m.extra.screaming = flag(tag, "IsScreamingGoat");
+            let horn = |key| number(tag.get(key)).is_some_and(|v| v == 0);
+            m.extra.lost_horns = [horn("HasLeftHorn"), horn("HasRightHorn")];
+        }
+        _ => {}
+    }
     if m.species() == crate::mobs::Species::Cat {
         m.extra.owner = crate::save::uuid_from_tag(tag.get("Owner"));
         m.extra.tame = m.extra.owner.is_some();
@@ -2502,6 +2556,55 @@ mod sheep_nbt_tests {
             );
         }
     }
+
+    #[test]
+    fn foxes_rabbits_and_goats_keep_their_kind() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("items.json").exists() {
+            return;
+        }
+        let data = crate::mobs::MobTypes::load(&root).unwrap();
+        let types: HashMap<String, Arc<MobType>> = data
+            .types
+            .iter()
+            .map(|(k, v)| (k.clone(), Arc::new(v.clone())))
+            .collect();
+        let new = |kind: &str| Mob::new(1, types[kind].clone(), Vec3::new(0.0, 4.0, 0.0), 0.0);
+        let round_trip = |m: &Mob| {
+            let tag = mob_to_nbt(m, [1, 2, 3, 4], None);
+            (mob_from_nbt(&tag, &types, 2).unwrap(), tag)
+        };
+        let mut fox = new("minecraft:fox");
+        fox.extra.variant = 1;
+        let (back, tag) = round_trip(&fox);
+        assert_eq!(text(tag.get("Type")).as_deref(), Some("snow"));
+        assert_eq!(number(tag.get("Sleeping")), Some(0));
+        assert_eq!(back.extra.variant, 1);
+        let mut rabbit = new("minecraft:rabbit");
+        rabbit.extra.variant = 4;
+        let (back, tag) = round_trip(&rabbit);
+        assert_eq!(number(tag.get("RabbitType")), Some(4));
+        assert_eq!(back.extra.variant, 4);
+        let mut goat = new("minecraft:goat");
+        (goat.extra.screaming, goat.extra.lost_horns) = (true, [false, true]);
+        let (back, tag) = round_trip(&goat);
+        assert_eq!(number(tag.get("HasRightHorn")), Some(0));
+        assert_eq!(
+            (back.extra.screaming, back.extra.lost_horns),
+            (true, [false, true])
+        );
+        // A goat saved without horn flags has both, as vanilla reads it.
+        let bare = Tag::compound([
+            ("id", string("minecraft:goat")),
+            ("Pos", doubles(&[0.5, 64.0, 0.5])),
+        ]);
+        assert_eq!(
+            mob_from_nbt(&bare, &types, 3).unwrap().extra.lost_horns,
+            [false; 2]
+        );
+    }
 }
 
 #[cfg(test)]

From 731a35612addaf322fe04149c4a5d15f5498d650 Mon Sep 17 00:00:00 2001
From: levzzz <86072227+levzzz5154@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:38:01 +0500
Subject: [PATCH 378/475] Lock the benchmark's load gate: a scene waits for the
 chunks

The benchmark's readiness rule waits for the resident chunk count to reach
the view's target before "steady" means loaded, so a scene that starts with
an empty view (the integrated server has not sent its first chunk yet) is
measured after the world is really there. The rule had no test, so a change
could silently drop it. This adds one: a fake control that keeps the counts
steady and the queue empty for a second and a half, and only then lets the
chunks arrive, must not end the wait before they do. Without the gate the
wait ends after the quiet second and the test fails.

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 crates/horizon-client/src/benchmark.rs | 48 ++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/crates/horizon-client/src/benchmark.rs b/crates/horizon-client/src/benchmark.rs
index 12e38e78a..bd2e97be0 100644
--- a/crates/horizon-client/src/benchmark.rs
+++ b/crates/horizon-client/src/benchmark.rs
@@ -450,6 +450,54 @@ mod tests {
         assert_eq!(view_chunks(32), 2573);
         assert_eq!(view_chunks(0), 0);
     }
+    /// The status a fake control answers with: the player is where it should
+    /// be, nothing is queued, and the world holds `chunks` resident chunks.
+    fn status(chunks: u64) -> String {
+        serde_json::json!({
+            "player": {"position": [0.0, 64.0, 0.0]},
+            "pending_chunks": 0,
+            "screen": "playing",
+            "render_distance": 12,
+            "chunks": chunks,
+            "generated_chunks": chunks,
+            "meshed_sections": 0,
+            "streaming": {},
+        })
+        .to_string()
+    }
+
+    #[test]
+    fn the_load_waits_for_the_chunks_a_teleport_starts() {
+        // Right after a teleport the game reports steady counts and nothing
+        // queued for over a second, before the integrated server has sent the
+        // first chunk: the quiet rule alone would call that loaded, and the
+        // scene would be measured over an empty view (#1749).
+        const LATE: usize = 30;
+        let (tx, rx) = mpsc::channel::<Request>();
+        let polls = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
+        let counted = std::sync::Arc::clone(&polls);
+        let server = thread::spawn(move || {
+            let mut seen = 0;
+            while let Ok(request) = rx.recv() {
+                if request.line == "status" {
+                    let chunks = if seen < LATE { 0 } else { 400 };
+                    seen += 1;
+                    counted.store(seen, std::sync::atomic::Ordering::SeqCst);
+                    let _ = request.reply.send(status(chunks));
+                } else {
+                    let _ = request.reply.send("{}".to_owned());
+                }
+            }
+        });
+        let control = Control(tx);
+        wait_loaded(&control, |_| true).expect("the scene loads");
+        assert!(
+            polls.load(std::sync::atomic::Ordering::SeqCst) > LATE,
+            "the load finished before the chunks arrived"
+        );
+        drop(control);
+        let _ = server.join();
+    }
 
     #[test]
     fn yaw_matches_vanilla() {

From e11471cda092a0c26e90ac486fa22f35287aa49e Mon Sep 17 00:00:00 2001
From: "minimax-m3.1-flash" <noreply@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:38:22 +0500
Subject: [PATCH 379/475] Run the LAN harness headless

HORIZON_E2E_HEADLESS launches the games with --offscreen --no-pause, so the suite runs on a machine with no focused window: without it the games pause on the focus loss and wait_ready never completes. macOS keeps its offscreen launch.

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 tools/lan_e2e.py | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index 012e8f021..80de9e955 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -4743,9 +4743,18 @@ def run(ctl, out, resources, checks):
     host, guest = Game('host', ctl, resources), Game('guest', ctl, resources)
     # Either way explicitly: the game's default is the server thread.
     host.d.env['HORIZON_SERVER_THREAD'] = '1' if SERVER_THREAD else '0'
+    # The games render offscreen on macOS (a locked session gets no redraws) and, in a
+    # headless run (HORIZON_E2E_HEADLESS), on any machine with no focused window: they
+    # never pause on the focus loss there either, or the world would stand still.
+    headless = bool(os.environ.get('HORIZON_E2E_HEADLESS'))
+    launch = ['launch']
+    if sys.platform == 'darwin' or headless:
+        launch.append('--offscreen')
+    if headless:
+        launch.append('--no-pause')
     results = {}
     try:
-        host.pid = host('launch', wait=False, offscreen=sys.platform == 'darwin')['pid']
+        host.pid = host.raw(*launch)['pid']
         # Guests' commands need the world's Allow Commands as well as the LAN's (#372): a creative
         # world has them; everyone plays in survival.
         host.raw('open', 'Lan', 5, 'creative')
@@ -4759,7 +4768,7 @@ def run(ctl, out, resources, checks):
         host('command', command='gamerule spawn_mobs false')
         port = host.raw('lan', 'open', 0, 'commands')['port']
         host.player = host.raw('lan', 'status').get('host', 'Player')  # the host's profile name
-        guest.pid = guest('launch', wait=False, offscreen=sys.platform == 'darwin')['pid']
+        guest.pid = guest.raw(*launch)['pid']
         guest.raw('connect', f'127.0.0.1:{port}', GUEST_NAME)
         guest.raw('wait-for', 'loaded', '--timeout', 300)
         guest.wait(40)

From 5be7c02d0cfbdd43a90c9c79a48d1edb3da9df05 Mon Sep 17 00:00:00 2001
From: "minimax-m3.1-flash" <noreply@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:38:22 +0500
Subject: [PATCH 380/475] Cover the mining dig stop in the LAN harness (#1340,
 #1908)

A block the client breaks at once (a creative break, a dead bush) sends no STOP or ABORT, so the server has to forget the dig itself. Without it the server keeps mining the emptied cell: the block put back there is destroyed again (#1340) and the mining sound keeps playing at it (#1908, the cell's sound group is stone).

The new dig_stop check breaks a stone block in creative and a dead bush in survival for the host and the guest, then puts the block back and waits: it must stay, and no mining sound may play.

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 tools/lan_e2e.py | 53 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index 80de9e955..92ecb4ead 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -259,6 +259,8 @@ address. The script then checks, from both sides, what a guest's game used to ge
 - instant_digging: an instant survival break leaves no repeated stone hit sounds or stale server dig (#1908).
 - replant:   flowers and crops replanted after a short harvest click stay planted for both players;
              the server forgets the completed instant break (#1880).
+- dig_stop:  a block the client breaks at once (a creative break, a dead bush) leaves the
+             server no dig to keep: the block put back stays and no mining sound plays on (#1340, #1908).
 
 Each check is reported on its own (a failing one doesn't stop the others) and the screenshots of
 both sides go to --out (host-*.png, guest-*.png).
@@ -7345,5 +7347,56 @@ CHECKS += ['forced-levels']
 CHECK_FNS['forced-levels'] = check_forced_levels
 
 
+def check_dig_stop(host, guest, out):
+    """#1340 and #1908: a block the client breaks at once leaves the server no dig to keep.
+
+    MultiPlayerGameMode sends no STOP or ABORT for a creative break or an instant
+    survival break (its isDestroying stays false), so the server must forget the dig on
+    its own, as ServerPlayerGameMode.handleBlockBreakAction's creative and insta-mine
+    branches do. Otherwise the server keeps mining the old spot: the block put back
+    there is destroyed again (#1340) and the mining sound keeps playing at it (#1908).
+    """
+    result = {}
+    spots = apart(host, guest)
+    for label, player in (('host', host), ('guest', guest)):
+        x, y, z = spots[label]
+        cell = (x, y + 1, z + 2)
+        seen = result[label] = {}
+        for mode, block in (('creative', 'minecraft:stone'), ('survival', 'minecraft:dead_bush')):
+            player('command', command=f'gamemode {mode}')
+            player('command', command='clear @s')
+            host('command', command=f'fill {x - 1} {y} {z + 1} {x + 1} {y + 3} {z + 4} minecraft:air')
+            host('command', command=f'setblock {cell[0]} {cell[1]} {cell[2]} {block}')
+            player.wait(10)
+            before = {g.name: heard(g, 'minecraft:block.stone.hit') for g in (host, guest)}
+            player.raw('look-at', f'{cell[0] + 0.5:.2f}', f'{cell[1] + 0.4:.2f}', f'{cell[2] + 0.5:.2f}')
+            # One left-click, then the attack released.
+            player.raw('mouse', 'left', 'click')
+            player.wait(40)
+            seen[f'{mode} broken'] = host.raw('block', *cell).get('block')
+            seen[f'{mode} mining'] = player('state').get('mining')
+            # The block put back must stay: the server has no dig left to destroy it.
+            host('command', command=f'setblock {cell[0]} {cell[1]} {cell[2]} minecraft:stone')
+            player.wait(100)
+            seen[f'{mode} replacement'] = [g.raw('block', *cell).get('block') for g in (host, player)]
+            seen[f'{mode} hits'] = {g.name: heard(g, 'minecraft:block.stone.hit') - before[g.name]
+                                    for g in (host, guest)}
+            host('command', command=f'setblock {cell[0]} {cell[1]} {cell[2]} minecraft:air')
+        assert seen['creative broken'] == 'minecraft:air', f'{label}: the creative break failed: {seen}'
+        assert seen['survival broken'] == 'minecraft:air', f'{label}: the instant break failed: {seen}'
+        assert seen['creative mining'] is None, f'{label}: the client still digs: {seen}'
+        assert seen['survival mining'] is None, f'{label}: the client still digs: {seen}'
+        for mode in ('creative', 'survival'):
+            assert seen[f'{mode} replacement'] == ['minecraft:stone'] * 2, \
+                f'{label} {mode}: the server kept digging: {seen}'
+            assert all(hits == 0 for hits in seen[f'{mode} hits'].values()), \
+                f'{label} {mode}: the mining sound kept playing: {seen}'
+    return result
+
+
+CHECKS += ['dig_stop']
+CHECK_FNS['dig_stop'] = check_dig_stop
+
+
 if __name__ == '__main__':
     main()

From 9cebcc8d7fc6dea42402b08d83ca84c4698af6c0 Mon Sep 17 00:00:00 2001
From: Joansitoh <joan.programas@gmail.com>
Date: Tue, 27 Oct 2026 00:59:55 +0100
Subject: [PATCH 381/475] Launcher: a paste keeps the spaces at its ends

Pasting " --world Test" after an argument lost its leading space and
joined the two arguments. The first line of the clipboard is inserted as
it is.
---
 launcher/src/line_edit.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/launcher/src/line_edit.rs b/launcher/src/line_edit.rs
index 0647f5861..2889eb5f1 100644
--- a/launcher/src/line_edit.rs
+++ b/launcher/src/line_edit.rs
@@ -407,6 +407,12 @@ impl LineEdit {
     }
 }
 
+/// What a paste puts in a one-line field: the clipboard's first line, spaces at its ends kept
+/// (` --world Test` after an argument is a new argument).
+fn pasted(clipboard: &str) -> &str {
+    clipboard.lines().next().unwrap_or_default()
+}
+
 /// The keyboard in a field: moves the caret, edits, copies and pastes. Never returns Paste, Copy
 /// or Cut (they are done); Enter, Escape and Pass are the page's.
 pub(super) fn handle(edit: &mut LineEdit, ev: &KeyDownEvent, cx: &mut App) -> Key {
@@ -415,7 +421,7 @@ pub(super) fn handle(edit: &mut LineEdit, ev: &KeyDownEvent, cx: &mut App) -> Ke
     match edit.key(&k.key, k.key_char.as_deref(), command, k.modifiers.shift) {
         Key::Paste => {
             if let Some(text) = cx.read_from_clipboard().and_then(|c| c.text()) {
-                edit.insert(text.lines().next().unwrap_or_default().trim());
+                edit.insert(pasted(&text));
             }
             Key::Edited
         }

From fa4f38f824dd4f5536eb62d221ce8835c53db3cf Mon Sep 17 00:00:00 2001
From: levzzz <86072227+levzzz5154@users.noreply.github.com>
Date: Tue, 27 Oct 2026 05:01:07 +0500
Subject: [PATCH 382/475] commands: an unbounded selector reaches the other
 loaded levels

`Game::select` gathered its candidates from the level in place only, so
`@e[tag=...]` never found an entity in another dimension the server
still holds: vanilla's `EntitySelector` searches every loaded level
unless the selector carries a spatial constraint.

The selector now searches each loaded level in turn, and the commands
that act on the entity it found (`/data get entity`, `/kill`, `/tp`)
act on it in the level that holds it. The experience orbs and the
projectiles are named by their entity id, like the other entities, so
the entity a command acts on is the one the selector found.

Fixes #1524

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 crates/horizon-client/src/command/args.rs     |   8 +
 crates/horizon-client/src/game.rs             |   2 +-
 crates/horizon-client/src/game/commands.rs    | 263 ++++++++++++------
 .../horizon-client/src/game/commands/data.rs  |  28 +-
 crates/horizon-client/src/game/creatures.rs   |  15 +-
 crates/horizon-client/src/game/crossbow.rs    |   2 +-
 crates/horizon-client/src/game/dispenser.rs   |   2 +-
 crates/horizon-client/src/game/levels.rs      |   4 +
 crates/horizon-client/src/game/persist.rs     |   4 +-
 .../src/game/remote_projectiles.rs            |   2 +-
 crates/horizon-client/src/game/wind.rs        |   2 +-
 tools/command_exec_corpus.py                  |  12 +-
 12 files changed, 248 insertions(+), 96 deletions(-)

diff --git a/crates/horizon-client/src/command/args.rs b/crates/horizon-client/src/command/args.rs
index ccced67a7..d9528d3f2 100644
--- a/crates/horizon-client/src/command/args.rs
+++ b/crates/horizon-client/src/command/args.rs
@@ -551,6 +551,14 @@ impl Selector {
     pub fn single(&self) -> bool {
         self.limit <= 1
     }
+    /// `EntitySelectorParser.setWorldLimited`: a selector with a spatial
+    /// constraint (`distance` or a position) reaches the level the command
+    /// runs in only; an unbounded one reaches every loaded level.
+    pub fn world_limited(&self) -> bool {
+        self.distance.is_some()
+            || self.pos.iter().any(Option::is_some)
+            || self.delta.iter().any(Option::is_some)
+    }
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct BlockInput {
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index db49087b2..a154c7a18 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -9598,7 +9598,7 @@ impl Game<'_> {
             velocity,
             on_ground,
         );
-        self.creatures.projectiles.push(arrow);
+        self.add_projectile(arrow);
         self.player_projectile_shot();
         let pitch = 1.0 / (self.world.random.next_float() * 0.4 + 1.2) + power * 0.5;
         self.audio
diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs
index 22041c3b2..f79480428 100644
--- a/crates/horizon-client/src/game/commands.rs
+++ b/crates/horizon-client/src/game/commands.rs
@@ -42,9 +42,10 @@ pub(super) enum Target {
     Guest(u32),
     Mob(u32),
     Item(u32),
-    Orb(usize),
-    /// By index in `creatures.projectiles`.
-    Projectile(usize),
+    /// An experience orb, by its entity id.
+    Orb(u32),
+    /// A projectile, by its entity id.
+    Projectile(u32),
     Stand(u32),
     Frame(u32),
     Painting(u32),
@@ -340,14 +341,16 @@ impl Game<'_> {
                 .iter()
                 .find(|i| i.id == id)
                 .map(|i| [i.position.x, i.position.y, i.position.z]),
-            Target::Orb(i) => self
+            Target::Orb(id) => self
                 .orbs
-                .get(i)
+                .iter()
+                .find(|o| o.id == id)
                 .map(|o| [o.position.x, o.position.y, o.position.z]),
-            Target::Projectile(i) => self
+            Target::Projectile(id) => self
                 .creatures
                 .projectiles
-                .get(i)
+                .iter()
+                .find(|a| a.id == id)
                 .map(|a| [a.position.x, a.position.y, a.position.z]),
             Target::Stand(id) => self
                 .armor_stands
@@ -399,10 +402,11 @@ impl Game<'_> {
                 }),
             Target::Item(_) => "minecraft:item".into(),
             Target::Orb(_) => "minecraft:experience_orb".into(),
-            Target::Projectile(i) => self
+            Target::Projectile(id) => self
                 .creatures
                 .projectiles
-                .get(i)
+                .iter()
+                .find(|p| p.id == id)
                 .map_or_else(String::new, |p| p.kind.id().into()),
             Target::Stand(_) => "minecraft:armor_stand".into(),
             Target::Frame(id) => {
@@ -512,51 +516,72 @@ impl Game<'_> {
                 s.pos[2].unwrap_or(p[2]),
             ]
         };
-        let mut candidates: Vec<Target> = Vec::new();
+        let mut source_candidates: Vec<Target> = Vec::new();
         match (s.kind, self.command_source) {
             // @s: the executing entity (none for a server source).
-            ('s', Some(source)) => candidates.extend(source.entity),
-            ('s', None) => candidates.extend(self.source_entity()),
+            ('s', Some(source)) => source_candidates.extend(source.entity),
+            ('s', None) => source_candidates.extend(self.source_entity()),
             // A guest in place is among the players, in join order.
             _ if self.player.is_some() && self.lan_acting.is_none() => {
-                candidates.push(Target::Player);
+                source_candidates.push(Target::Player);
             }
             _ => {}
         }
         if s.kind != 's' {
-            use horizon_client::projectiles::ProjectileKind as K;
-            candidates.extend(self.player_candidates(s));
-            candidates.extend(
-                self.mobs
-                    .iter()
-                    .filter(|m| m.death_time == 0)
-                    .map(|m| Target::Mob(m.id)),
-            );
-            candidates.extend(self.dropped.iter().map(|i| Target::Item(i.id)));
-            candidates.extend((0..self.orbs.len()).map(Target::Orb));
-            candidates.extend(
-                self.creatures
-                    .projectiles
-                    .iter()
-                    .enumerate()
-                    // The kinds /data can write (entity_nbt).
-                    .filter(|(_, p)| {
-                        p.arrow.is_some()
-                            || matches!(p.kind, K::LargeFireball { .. } | K::SmallFireball)
-                    })
-                    .map(|(i, _)| Target::Projectile(i)),
-            );
-            candidates.extend(self.armor_stands.iter().map(|a| Target::Stand(a.id)));
-            candidates.extend(self.item_frames.iter().map(|f| Target::Frame(f.id)));
-            candidates.extend(self.paintings.iter().map(|p| Target::Painting(p.id)));
-            candidates.extend(self.boats.iter().map(|b| Target::Boat(b.id)));
-            candidates.extend(self.carts.iter().map(|c| Target::Cart(c.id)));
-            candidates.extend(self.others.iter().map(|o| Target::Other(o.id)));
+            source_candidates.extend(self.player_candidates(s));
         }
+        let source_dim = self.dim;
+        // A selector with a spatial constraint reaches the level the command
+        // runs in only; an unbounded one reaches every loaded level
+        // (EntitySelector.findEntities).
+        let dims = if s.world_limited() {
+            vec![source_dim]
+        } else {
+            self.loaded_dims()
+        };
+        let mut out: Vec<(Target, f64)> = Vec::new();
+        for dim in dims {
+            let back = self.enter_command_level(dim);
+            let mut candidates = Vec::new();
+            if dim == source_dim {
+                candidates.append(&mut source_candidates);
+            }
+            if s.kind != 's' {
+                candidates.extend(self.level_candidates());
+            }
+            out.extend(self.select_in_level(candidates, s, origin));
+            if let Some(back) = back {
+                self.enter_command_level(back);
+            }
+        }
+        match s.sort {
+            Sort::Nearest => out.sort_by(|a, b| a.1.total_cmp(&b.1)),
+            Sort::Furthest => out.sort_by(|a, b| b.1.total_cmp(&a.1)),
+            Sort::Random => {
+                for i in (1..out.len()).rev() {
+                    let j = self.world.random.next_int_bound(i as i32 + 1).unwrap_or(0) as usize;
+                    out.swap(i, j);
+                }
+            }
+            Sort::Arbitrary => {}
+        }
+        out.into_iter()
+            .take(s.limit.max(1))
+            .map(|(t, _)| t)
+            .collect()
+    }
+    /// The candidates of the level in place that pass the selector
+    /// (EntitySelector.getPredicate).
+    fn select_in_level(
+        &mut self,
+        candidates: Vec<Target>,
+        s: &Selector,
+        origin: [f64; 3],
+    ) -> Vec<(Target, f64)> {
         let level = self.experience.level;
         let creative = self.creative;
         let passing = self.selector_extra_filter(&candidates, s);
-        let mut out: Vec<(Target, f64)> = candidates
+        candidates
             .into_iter()
             .filter_map(|t| {
                 let p = self.target_position(t)?;
@@ -628,23 +653,95 @@ impl Game<'_> {
                 }
                 Some((t, d2))
             })
-            .collect();
-        match s.sort {
-            Sort::Nearest => out.sort_by(|a, b| a.1.total_cmp(&b.1)),
-            Sort::Furthest => out.sort_by(|a, b| b.1.total_cmp(&a.1)),
-            Sort::Random => {
-                for i in (1..out.len()).rev() {
-                    let j = self.world.random.next_int_bound(i as i32 + 1).unwrap_or(0) as usize;
-                    out.swap(i, j);
-                }
-            }
-            Sort::Arbitrary => {}
-        }
-        out.into_iter()
-            .take(s.limit.max(1))
-            .map(|(t, _)| t)
             .collect()
     }
+    /// The entities of the level in place a selector can find.
+    fn level_candidates(&self) -> Vec<Target> {
+        use horizon_client::projectiles::ProjectileKind as K;
+        let mut candidates = Vec::new();
+        candidates.extend(
+            self.mobs
+                .iter()
+                .filter(|m| m.death_time == 0)
+                .map(|m| Target::Mob(m.id)),
+        );
+        candidates.extend(self.dropped.iter().map(|i| Target::Item(i.id)));
+        candidates.extend(self.orbs.iter().map(|o| Target::Orb(o.id)));
+        candidates.extend(
+            self.creatures
+                .projectiles
+                .iter()
+                // The kinds /data can write (entity_nbt).
+                .filter(|p| {
+                    p.arrow.is_some()
+                        || matches!(p.kind, K::LargeFireball { .. } | K::SmallFireball)
+                })
+                .map(|p| Target::Projectile(p.id)),
+        );
+        candidates.extend(self.armor_stands.iter().map(|a| Target::Stand(a.id)));
+        candidates.extend(self.item_frames.iter().map(|f| Target::Frame(f.id)));
+        candidates.extend(self.paintings.iter().map(|p| Target::Painting(p.id)));
+        candidates.extend(self.boats.iter().map(|b| Target::Boat(b.id)));
+        candidates.extend(self.carts.iter().map(|c| Target::Cart(c.id)));
+        candidates.extend(self.others.iter().map(|o| Target::Other(o.id)));
+        candidates
+    }
+    /// The loaded levels, in the order the server holds them: the
+    /// overworld, the nether, the end (MinecraftServer.getAllLevels).
+    fn loaded_dims(&self) -> Vec<Dim> {
+        let mut dims = vec![self.dim];
+        dims.extend(self.levels.parked_dims());
+        dims.sort_by_key(|d| match d {
+            Dim::Overworld => 0,
+            Dim::Nether => 1,
+            Dim::End => 2,
+        });
+        dims
+    }
+    /// Whether the level in place holds the entity a target names.
+    fn level_holds(&self, t: Target) -> bool {
+        match t {
+            // A player is in no level of its own.
+            Target::Player | Target::Guest(_) => true,
+            Target::Mob(id) => self.mobs.iter().any(|m| m.id == id),
+            Target::Item(id) => self.dropped.iter().any(|i| i.id == id),
+            Target::Orb(id) => self.orbs.iter().any(|o| o.id == id),
+            Target::Projectile(id) => self.creatures.projectiles.iter().any(|p| p.id == id),
+            Target::Stand(id) => self.armor_stands.iter().any(|a| a.id == id),
+            Target::Frame(id) => self.item_frames.iter().any(|f| f.id == id),
+            Target::Painting(id) => self.paintings.iter().any(|p| p.id == id),
+            Target::Boat(id) => self.boats.iter().any(|b| b.id == id),
+            Target::Cart(id) => self.carts.iter().any(|c| c.id == id),
+            Target::Other(id) => self.others.iter().any(|o| o.id == id),
+        }
+    }
+    /// Run `f` with the level that holds the entity a target names in place
+    /// (the entity ids are unique across the loaded levels) and put the
+    /// level back afterwards. `f` does not run when no level holds the
+    /// entity.
+    pub(in crate::game) fn in_target_level<R>(
+        &mut self,
+        t: Target,
+        f: impl FnOnce(&mut Self) -> R,
+    ) -> Option<R> {
+        if self.level_holds(t) {
+            return Some(f(self));
+        }
+        for dim in self.levels.parked_dims() {
+            let back = self.enter_command_level(dim);
+            if self.level_holds(t) {
+                let r = f(self);
+                if let Some(back) = back {
+                    self.enter_command_level(back);
+                }
+                return Some(r);
+            }
+            if let Some(back) = back {
+                self.enter_command_level(back);
+            }
+        }
+        None
+    }
     fn entity_tag_matches(&self, tag: &str, ty: &str) -> bool {
         let path = self.options.resources.join(format!(
             "data/minecraft/tags/entity_type/{}.json",
@@ -1104,6 +1201,10 @@ impl Game<'_> {
         Ok(targets.len() as i32)
     }
     fn teleport_to(&mut self, t: Target, pos: [f64; 3], rotation: Option<[f32; 2]>) {
+        // An entity in another level is teleported in the level that holds it.
+        let _ = self.in_target_level(t, |g| g.teleport_to_in_level(t, pos, rotation));
+    }
+    fn teleport_to_in_level(&mut self, t: Target, pos: [f64; 3], rotation: Option<[f32; 2]>) {
         let v = Vec3::new(pos[0], pos[1], pos[2]);
         match t {
             Target::Guest(_) => {
@@ -1152,14 +1253,14 @@ impl Game<'_> {
                     i.previous = v;
                 }
             }
-            Target::Orb(i) => {
-                if let Some(o) = self.orbs.get_mut(i) {
+            Target::Orb(id) => {
+                if let Some(o) = self.orbs.iter_mut().find(|o| o.id == id) {
                     o.position = v;
                     o.previous = v;
                 }
             }
-            Target::Projectile(i) => {
-                if let Some(a) = self.creatures.projectiles.get_mut(i) {
+            Target::Projectile(id) => {
+                if let Some(a) = self.creatures.projectiles.iter_mut().find(|a| a.id == id) {
                     a.position = v;
                     a.previous = v;
                 }
@@ -1558,6 +1659,10 @@ impl Game<'_> {
         Ok(duration.unwrap_or(-1))
     }
     fn kill_target(&mut self, t: Target) {
+        // An entity in another level is killed in the level that holds it.
+        let _ = self.in_target_level(t, |g| g.kill_target_in_level(t));
+    }
+    fn kill_target_in_level(&mut self, t: Target) {
         match t {
             Target::Guest(_) => {
                 self.for_player(t, |g| g.kill_target(Target::Player));
@@ -1577,16 +1682,13 @@ impl Game<'_> {
                 }
             }
             Target::Item(id) => self.dropped.retain(|i| i.id != id),
-            Target::Orb(i) => {
-                if i < self.orbs.len() {
-                    self.orbs[i].age = u32::MAX / 2;
+            Target::Orb(id) => {
+                if let Some(o) = self.orbs.iter_mut().find(|o| o.id == id) {
+                    o.age = u32::MAX / 2;
                 }
             }
-            // cmd_kill goes from the highest index down.
-            Target::Projectile(i) => {
-                if i < self.creatures.projectiles.len() {
-                    self.creatures.projectiles.remove(i);
-                }
+            Target::Projectile(id) => {
+                self.creatures.projectiles.retain(|p| p.id != id);
             }
             Target::Stand(id) => self.armor_stands.retain(|a| a.id != id),
             Target::Frame(id) => self.item_frames.retain(|f| f.id != id),
@@ -1595,6 +1697,8 @@ impl Game<'_> {
             Target::Cart(id) => self.carts.retain(|c| c.id != id),
             Target::Other(id) => self.others.retain(|o| o.id != id),
         }
+        // The orbs marked for removal are gone (Entity.kill removes them).
+        self.orbs.retain(|o| o.age < u32::MAX / 2);
     }
     fn cmd_kill(&mut self, ctx: &Context) -> R<i32> {
         let targets = if ctx.get("targets").is_some() {
@@ -1602,19 +1706,18 @@ impl Game<'_> {
         } else {
             vec![self.implied_player()]
         };
-        let names: Vec<Text> = targets.iter().map(|&t| self.target_name(t)).collect();
-        // Remove indexed entities from the back so earlier indices stay valid.
-        let mut ordered = targets.clone();
-        ordered.sort_by_key(|t| {
-            std::cmp::Reverse(match t {
-                Target::Orb(i) | Target::Projectile(i) => *i,
-                _ => 0,
-            })
-        });
-        for t in ordered {
+        let mut names: Vec<Text> = Vec::new();
+        for &t in &targets {
+            // The name of an entity in another level is read there.
+            let name = match self.in_target_level(t, |g| g.target_name(t)) {
+                Some(name) => name,
+                None => self.target_name(t),
+            };
+            names.push(name);
+        }
+        for &t in &targets {
             self.kill_target(t);
         }
-        self.orbs.retain(|o| o.age < u32::MAX / 2);
         let message = if targets.len() == 1 {
             Text::translate("commands.kill.success.single", &[names[0].clone()])
         } else {
diff --git a/crates/horizon-client/src/game/commands/data.rs b/crates/horizon-client/src/game/commands/data.rs
index ac16c5e7c..6dc5b6a75 100644
--- a/crates/horizon-client/src/game/commands/data.rs
+++ b/crates/horizon-client/src/game/commands/data.rs
@@ -31,8 +31,13 @@ fn set_key(tag: &mut Tag, key: &str, value: Tag) {
 impl Game<'_> {
     // ---- entity data ---------------------------------------------------
 
-    /// `NbtPredicate.getEntityTagToCompare`: the entity as saved.
+    /// `NbtPredicate.getEntityTagToCompare`: the entity as saved. An entity
+    /// in another level is read in the level that holds it.
     pub(in crate::game) fn entity_nbt(&mut self, t: Target) -> Option<Tag> {
+        self.in_target_level(t, |g| g.entity_nbt_in_level(t))
+            .flatten()
+    }
+    fn entity_nbt_in_level(&mut self, t: Target) -> Option<Tag> {
         let player_uuid = self.level.player_uuid;
         Some(match t {
             Target::Guest(_) => {
@@ -113,9 +118,11 @@ impl Game<'_> {
                 let o = self.others.iter().find(|o| o.id == id)?.clone();
                 self.other_to_nbt(&o, uuid)
             }
-            Target::Orb(i) => entity_nbt::orb_to_nbt(self.orbs.get(i)?, random_uuid()),
-            Target::Projectile(i) => {
-                let p = self.creatures.projectiles.get(i)?;
+            Target::Orb(id) => {
+                entity_nbt::orb_to_nbt(self.orbs.iter().find(|o| o.id == id)?, random_uuid())
+            }
+            Target::Projectile(id) => {
+                let p = self.creatures.projectiles.iter().find(|p| p.id == id)?;
                 let owner = if p.owner == Some(horizon_client::mobs::Who::Player) {
                     player_uuid
                 } else {
@@ -397,6 +404,19 @@ impl Game<'_> {
     }
     pub(super) fn cmd_data(&mut self, id: &str, ctx: &Context) -> R<i32> {
         let target = self.data_ref(ctx, 0)?;
+        // An entity in another level is read and written in the level that
+        // holds it.
+        if let DataRef::Entity(t) = &target {
+            let t = *t;
+            let target = target.clone();
+            return match self.in_target_level(t, |g| g.cmd_data_in(id, ctx, target)) {
+                Some(r) => r,
+                None => Err(err("argument.entity.notfound.entity", &[])),
+            };
+        }
+        self.cmd_data_in(id, ctx, target)
+    }
+    fn cmd_data_in(&mut self, id: &str, ctx: &Context, target: DataRef) -> R<i32> {
         match id {
             "data.merge" => {
                 let Some(Arg::Str(nbt)) = ctx.get("nbt") else {
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index e895cb7f7..a5fb497d7 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -892,6 +892,15 @@ impl Game<'_> {
             self.spawn_item(d, at, [0.0, 0.2, 0.0], 10);
         }
     }
+    /// Adds a projectile, giving it an id from the entity counter
+    /// (`Entity.id`, the same counter as the rest) when it has none.
+    pub(super) fn add_projectile(&mut self, mut p: horizon_client::projectiles::Projectile) {
+        if p.id == 0 {
+            self.next_entity += 1;
+            p.id = self.next_entity;
+        }
+        self.creatures.projectiles.push(p);
+    }
     pub(super) fn handle_mob_events(&mut self, events: Vec<MobEvent>) -> Result<()> {
         for e in events {
             match e {
@@ -1078,7 +1087,7 @@ impl Game<'_> {
                     self.next_entity += 1;
                     p.id = self.next_entity;
                     let (owner, at) = (p.owner, [p.position.x, p.position.y, p.position.z]);
-                    self.creatures.projectiles.push(p);
+                    self.add_projectile(p);
                     self.projectile_event("minecraft:projectile_shoot", owner, at);
                 }
                 MobEvent::Spawn(mut m) => {
@@ -2160,7 +2169,7 @@ impl Game<'_> {
             }
         }
         if keep {
-            self.creatures.projectiles.push(arrow);
+            self.add_projectile(arrow);
         }
     }
     /// `TargetBlock.onProjectileHit`: a target block takes its power from
@@ -3162,7 +3171,7 @@ impl Game<'_> {
             velocity,
             on_ground,
         );
-        self.creatures.projectiles.push(proj);
+        self.add_projectile(proj);
         self.player_projectile_shot();
         // ItemStack.use's applyAfterUseComponentSideEffects: the pearl's
         // second is the `use_cooldown` component, as for any thrown item.
diff --git a/crates/horizon-client/src/game/crossbow.rs b/crates/horizon-client/src/game/crossbow.rs
index bc49c4b90..d66610183 100644
--- a/crates/horizon-client/src/game/crossbow.rs
+++ b/crates/horizon-client/src/game/crossbow.rs
@@ -222,7 +222,7 @@ impl Game<'_> {
                     a.pierce = pierce;
                 }
                 arrow.shoot(&mut self.world.random, dir.to_array(), power, 1.0);
-                self.creatures.projectiles.push(arrow);
+                self.add_projectile(arrow);
             }
             self.player_projectile_shot();
             let pitch = if index == 0 {
diff --git a/crates/horizon-client/src/game/dispenser.rs b/crates/horizon-client/src/game/dispenser.rs
index 61725c6ab..670750f63 100644
--- a/crates/horizon-client/src/game/dispenser.rs
+++ b/crates/horizon-client/src/game/dispenser.rs
@@ -1034,7 +1034,7 @@ impl Game<'_> {
                     a.pickup = horizon_client::arrows::Pickup::Allowed;
                 }
                 shot.shoot(&mut own, dir, power, uncertainty);
-                self.creatures.projectiles.push(shot);
+                self.add_projectile(shot);
             }
         }
     }
diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs
index 29bf6d511..d41485e2d 100644
--- a/crates/horizon-client/src/game/levels.rs
+++ b/crates/horizon-client/src/game/levels.rs
@@ -120,6 +120,10 @@ impl Levels {
             .iter_mut()
             .map(|(d, p)| (*d, &mut p.world.chunks))
     }
+    /// The levels that are not in place, by dimension.
+    pub(super) fn parked_dims(&self) -> Vec<Dim> {
+        self.parked.keys().copied().collect()
+    }
 }
 
 impl Game<'_> {
diff --git a/crates/horizon-client/src/game/persist.rs b/crates/horizon-client/src/game/persist.rs
index b5e650e70..09622cf18 100644
--- a/crates/horizon-client/src/game/persist.rs
+++ b/crates/horizon-client/src/game/persist.rs
@@ -193,12 +193,12 @@ impl Game<'_> {
                             if let Some(a) = p.arrow.as_mut() {
                                 a.last_state = in_block.and_then(|t| self.state_from_nbt(&t));
                             }
-                            self.creatures.projectiles.push(p);
+                            self.add_projectile(p);
                         }
                     }
                     "minecraft:fireball" | "minecraft:small_fireball" => {
                         if let Some(p) = entity_nbt::fireball_from_nbt(&tag, player_uuid) {
-                            self.creatures.projectiles.push(p);
+                            self.add_projectile(p);
                         }
                     }
                     "minecraft:falling_block" => {
diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs
index 897999c6b..52210cf3d 100644
--- a/crates/horizon-client/src/game/remote_projectiles.rs
+++ b/crates/horizon-client/src/game/remote_projectiles.rs
@@ -166,7 +166,7 @@ impl Game<'_> {
                 p.velocity = velocity;
                 p.yaw = yaw;
                 p.pitch = pitch;
-                self.creatures.projectiles.push(p);
+                self.add_projectile(p);
             }
         }
         true
diff --git a/crates/horizon-client/src/game/wind.rs b/crates/horizon-client/src/game/wind.rs
index fb24102ba..63ac2641d 100644
--- a/crates/horizon-client/src/game/wind.rs
+++ b/crates/horizon-client/src/game/wind.rs
@@ -68,7 +68,7 @@ impl Game<'_> {
             velocity,
             on_ground,
         );
-        self.creatures.projectiles.push(proj);
+        self.add_projectile(proj);
         let pitch = 0.4 / (self.world.random.next_float() * 0.4 + 0.8);
         self.audio
             .play("minecraft:entity.wind_charge.throw", Some(eye), 0.5, pitch);
diff --git a/tools/command_exec_corpus.py b/tools/command_exec_corpus.py
index d8f925ef0..c3f579772 100644
--- a/tools/command_exec_corpus.py
+++ b/tools/command_exec_corpus.py
@@ -533,13 +533,21 @@ def execute():
 
 def levels():
     """A nether portal round trip: on the way back the Overworld's entities (the
-    pig left by `entities`) are found and a summon names what it summoned."""
+    pig left by `entities`) are found and a summon names what it summoned. An
+    unbounded selector also reaches the level the player is not in, while a
+    bounded one does not."""
     return [
         *setup('/fill 2 231 12 5 236 12 minecraft:obsidian', '/fill 3 232 12 4 235 12 minecraft:nether_portal[axis=x]',
-               '/tp @s 3.5 232 12.5 0 0'),
+               '/tp @s 3.5 232 12.5 0 0',
+               # A cow in the Overworld, in a chunk that stays loaded while the
+               # player is in the nether.
+               '/forceload add 0 0',
+               '/summon minecraft:cow 10.5 210 4.5 {NoAI:1b,NoGravity:1b,Tags:["remote_cow"]}'),
         {'op': 'portal'},
         {'op': 'settle'},
         cmd('/execute if dimension minecraft:the_nether run say through the portal'),
+        cmd('/data get entity @e[tag=remote_cow,limit=1] Pos'),
+        cmd('/data get entity @e[tag=remote_cow,distance=..128,limit=1] Pos'),
         {'op': 'portal'},
         {'op': 'settle'},
         cmd('/execute if dimension minecraft:overworld run say back through the portal'),

From 76bebec833470750b47644a97ebdd79539778cae Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Tue, 27 Oct 2026 01:01:53 +0100
Subject: [PATCH 383/475] Stop vexes suffocating inside blocks

---
 crates/horizon-client/src/mobs/ai.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 3406c09d7..e1951aa66 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -520,14 +520,19 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     }
     m.first_tick = false;
     if m.alive() {
-        // LivingEntity.baseTick: suffocation inside full blocks.
+        // LivingEntity.baseTick: suffocation inside full blocks. Entity.isInWall
+        // is false under noPhysics, which Vex.tick holds while it ticks.
         let (ex, ey, ez) = (
             m.position.x.floor() as i32,
             m.eye_y().floor() as i32,
             m.position.z.floor() as i32,
         );
         let at_eye = w.facts.get(w.world.block(ex, ey, ez));
-        if at_eye.full_collision && at_eye.solid_render && m.width() < 1.0 {
+        if at_eye.full_collision
+            && at_eye.solid_render
+            && m.width() < 1.0
+            && m.species() != Species::Vex
+        {
             m.damage(1.0, Damage::of(DamageKind::InWall));
         }
         // Air supply and drowning (WaterAnimal.handleAirSupply for aquatic mobs).

From 0db65d7a6192b6700d871cf3579edb63018343c2 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:06:57 +0100
Subject: [PATCH 384/475] Cargo.toml: one workspace member per line

Each new crate then adds one line instead of rewriting the whole list, so
PRs that add crates at the same time stop conflicting (the crate split's
#2160 conflicted on it three times).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Cargo.toml | 39 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index f0529d098..f256fff20 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,43 @@
 [workspace]
 exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"]
-members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-hdr", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "crates/horizon-mod-sdk/examples/beacons", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/zoom", "xtask", "mods/official/recipes"]
+members = [
+    "crates/horizon-core",
+    "crates/horizon-dualsense",
+    "crates/horizon-threads",
+    "crates/horizon-hdr",
+    "crates/horizon-world",
+    "crates/horizon-client",
+    "crates/horizon-server-files",
+    "crates/horizon-server",
+    "crates/horizon-bots",
+    "crates/horizon-assets",
+    "crates/horizon-protocol",
+    "crates/horizon-theme",
+    "crates/horizon-prepare",
+    "crates/horizon-telemetry",
+    "crates/horizon-bench",
+    "crates/horizon-friends",
+    "crates/horizon-relay",
+    "crates/horizon-mod-sdk",
+    "crates/horizon-mods",
+    "crates/horizon-mods/tests/guest",
+    "crates/horizon-mods/tests/ui_guest",
+    "crates/cargo-horizon-mod",
+    "crates/horizon-port-pack",
+    "crates/horizon-shaders",
+    "crates/horizon-shader-api",
+    "crates/horizon-release-sign",
+    "crates/horizon-mod-sdk/examples/coords-hud",
+    "crates/horizon-mod-sdk/examples/predator-missile",
+    "crates/horizon-mod-sdk/examples/welcome",
+    "crates/horizon-mod-sdk/examples/beacons",
+    "mods/official/fps-overlay",
+    "mods/official/keystrokes",
+    "mods/official/minimap",
+    "mods/official/zoom",
+    "xtask",
+    "mods/official/recipes",
+]
 resolver = "2"
 
 [workspace.package]

From 498de72da2ffa7a6726f32104540f3d4a16e6312 Mon Sep 17 00:00:00 2001
From: "minimax-m3.1-flash" <noreply@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:59:19 +0500
Subject: [PATCH 385/475] Frog: walk at vanilla's speed

Vanilla's frog uses a SmoothSwimmingMoveControl(85, 10, 0.02, 0.1, true), so
a walking frog covers 0.1 blocks a tick (its movement speed attribute is 1.0
and the controller's outside-water speed is 0.1). Horizon gave every generic
animal the plain ground controller, which drives the mob at the attribute
itself: a frog walked ten times too fast, jittered, teleported and flew
(#2213).

The regression test fails without the change.
---
 crates/horizon-client/src/mobs/ai.rs | 52 ++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 3406c09d7..3abedea5f 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -186,6 +186,20 @@ pub fn register(m: &mut Mob) {
             if m.species() == Species::Turtle {
                 super::turtle::register(m);
             }
+            if m.species() == Species::Frog {
+                // `Frog()`: SmoothSwimmingMoveControl(85, 10, 0.02, 0.1, true).
+                // The frog's movement speed is 1.0, so the controller's 0.1
+                // outside-water speed is what keeps a walking frog at
+                // vanilla's pace; the plain ground controller walks ten
+                // times too fast (#2213).
+                m.ai.mov.kind = super::control::MoveKind::SmoothSwimming {
+                    max_turn_x: 85.0,
+                    max_turn_y: 10.0,
+                    in_water: 0.02,
+                    outside: 0.1,
+                    gravity: true,
+                };
+            }
         }
         Family::Inert => {}
         Family::Witch => super::witch::register(m),
@@ -1701,3 +1715,41 @@ mod despawn_tests {
         }
     }
 }
+
+#[cfg(test)]
+mod frog_tests {
+    use super::*;
+    use crate::mobs::MobTypes;
+    use crate::mobs::control::MoveKind;
+    use std::sync::Arc;
+
+    /// `Frog()`: `new SmoothSwimmingMoveControl<>(this, 85, 10, 0.02F, 0.1F, true)`.
+    /// The frog's movement speed is 1.0, so the controller's 0.1 outside-water
+    /// speed is what keeps a walking frog at vanilla's pace. The plain ground
+    /// controller walks it ten times too fast, which is the jitter, the
+    /// teleporting and the flying of #2213.
+    #[test]
+    fn a_frog_walks_at_the_vanilla_speed() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("entity-types.json").exists() {
+            return;
+        }
+        let data = MobTypes::load(&root).unwrap();
+        let kind = Arc::new(data.types.get("minecraft:frog").unwrap().clone());
+        assert_eq!(kind.speed, 1.0, "the frog's movement speed attribute");
+        let mut m = Mob::new(1, kind, Vec3::new(0.0, 4.0, 0.0), 0.0);
+        register(&mut m);
+        assert_eq!(
+            m.ai.mov.kind,
+            MoveKind::SmoothSwimming {
+                max_turn_x: 85.0,
+                max_turn_y: 10.0,
+                in_water: 0.02,
+                outside: 0.1,
+                gravity: true,
+            }
+        );
+    }
+}

From 9ab0e2b6a8bfa5a96de27f6fc7b05d5b990158e0 Mon Sep 17 00:00:00 2001
From: levzzz <86072227+levzzz5154@users.noreply.github.com>
Date: Tue, 27 Oct 2026 05:08:40 +0500
Subject: [PATCH 386/475] Cover the slime block's push and bounce in the LAN
 harness

A piston pushing a slime block moves the body in front of it and bounces
it: the block's swept collision shape pushes the body out of the way, and
the slime block sets the body's velocity along the push axis
(`PistonMovingBlockEntity.moveCollidedEntities`, the `causeBounce` branch).
The new `piston-slime` LAN case checks both for the host and the guest, with
a plain block as the control: a plain block only pushes the body 0.81
blocks, the slime block pushes and bounces it 2.5.

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 tools/lan_e2e.py | 62 +++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 61 insertions(+), 1 deletion(-)

diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index 585b3000b..72b069965 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -298,7 +298,7 @@ CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sp
           'arrows', 'kills', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles',
           'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing',
           'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push',
-          'piston-push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles',
+          'piston-push', 'piston-slime', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles',
           'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects',
           'portals', 'distance', 'growth', 'doors', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'hands',
           'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption',
@@ -2506,6 +2506,65 @@ def piston_push_at_border(host, guest):
     return results
 
 
+def check_piston_slime(host, guest, out):
+    """A piston pushing a slime block: the block pushes the body in front of
+    it and bounces it (`PistonMovingBlockEntity.moveCollidedEntities`)."""
+    hx, _, hz = pos_of(host)
+    x, y, z = (int(hx // 16) * 16 + 8, 100, int(hz // 16) * 16 + 8)
+    results = {}
+
+    def setup():
+        # The previous case may have left a mob where the body stands.
+        host('command', command='kill @e[type=minecraft:pig]')
+        host('command', command=f'setblock {x} {y} {z} minecraft:air')
+        host.wait(10)
+        host('command', command=f'fill {x-4} {y-1} {z-4} {x+7} {y-1} {z+4} minecraft:stone')
+        host('command', command=f'fill {x-4} {y} {z-4} {x+7} {y+5} {z+4} minecraft:air')
+        host('command', command=f'setblock {x} {y} {z} minecraft:piston[facing=east]')
+        host.wait(5)
+
+    for player, name in ((host, host.player), (guest, GUEST_NAME)):
+        setup()
+        host('command', command=f'setblock {x+1} {y} {z} minecraft:slime_block')
+        host('command', command=f'tp @s {x+5.5} {y} {z+2.5}')
+        host('command', command=f'tp {GUEST_NAME} {x+5.5} {y} {z-1.5}')
+        host('command', command=f'tp {"@s" if player is host else GUEST_NAME} {x+2.5} {y} {z+0.5}')
+        player.wait(15)
+        before = pos_of(player)
+        assert abs(before[0] - (x + 2.5)) < 0.1, f'{name} did not reach the slime: {before}'
+        host('command', command=f'setblock {x-1} {y} {z} minecraft:redstone_block')
+        # The bounce sets the velocity along the push axis; it decays fast, so
+        # sample it while the block is still moving.
+        speed = 0.0
+        for _ in range(6):
+            player.wait(2)
+            speed = max(speed, player('state')['player']['velocity'][0])
+        after = pos_of(player)
+        results[name] = round(after[0] - before[0], 3)
+        # The block pushes the body out of its way, and the bounce launches it.
+        assert results[name] > 1.5, f'the slime block did not push and bounce {name}: {before} -> {after}'
+        assert speed > 0.05, f'the slime block did not bounce {name}: {speed}'
+        host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+        player.wait(10)
+    # A plain block only pushes: the body is not launched.
+    setup()
+    host('command', command=f'setblock {x+1} {y} {z} minecraft:stone')
+    host('command', command=f'tp @s {x+2.5} {y} {z+0.5}')
+    host.wait(15)
+    before = pos_of(host)
+    host('command', command=f'setblock {x-1} {y} {z} minecraft:redstone_block')
+    speed = 0.0
+    for _ in range(6):
+        host.wait(2)
+        speed = max(speed, host('state')['player']['velocity'][0])
+    after = pos_of(host)
+    results['stone'] = round(after[0] - before[0], 3)
+    assert results['stone'] < 1.5, f'a plain block bounced the player: {before} -> {after}'
+    host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+    host.wait(10)
+    return results
+
+
 def check_plates(host, guest, out):
     guest('command', command='gamemode survival')
     x, y, z = (int(v // 1) for v in pos_of(guest))
@@ -4819,6 +4878,7 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour,
              'recipes': check_recipes, 'trials': check_trials, 'walls': check_walls,
              'effects': check_effects, 'portals': check_portals, 'distance': check_distance,
              'clicks': check_clicks, 'sleep': check_sleep, 'push': check_push, 'piston-push': check_piston_push,
+             'piston-slime': check_piston_slime,
              'eat': check_eat, 'eating': check_eating, 'xp': check_xp,
              'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast,
              'light': check_light, 'plates': check_plates, 'swings': check_swings,

From bedba4a3d9a4bf2d3fe5e873ca49f8b6a1009c2c Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:08:50 +0100
Subject: [PATCH 387/475] lan_e2e fireworks: count newly red pixels, take the
 later shots 4 ticks after the burst

On playhorizon (frames drawn on the CPU) a screenshot takes ~0.6 s: with a
16-tick wait the later shots came after the sparks' lifetime, and the setup's
own red chat lines, gone by then, made the host's count negative.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tools/lan_e2e.py | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index 03e0e888f..fe76b288b 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -2971,13 +2971,15 @@ def check_fireworks(host, guest, out):
         game('command', command=f'tp @s {x + dx + 0.5} {y} {z + 0.5}')
         game.raw('look-at', x + 0.5, y + 1.5, z + 3.5)
 
-    def red(path):
+    def reds(path):
+        """The red pixels' positions, above the hotbar."""
         rows, bpp = png_rows(path)
-        # Exclude the hotbar and chat at the bottom of the view.
-        return sum(row[i] > 80 and row[i] > 2 * row[i + 1] and row[i] > 2 * row[i + 2]
-                   for row in rows[:len(rows) * 3 // 4] for i in range(0, len(row), bpp))
+        return {(y, i) for y, row in enumerate(rows[:len(rows) * 3 // 4]) for i in range(0, len(row), bpp)
+                if row[i] > 80 and row[i] > 2 * row[i + 1] and row[i] > 2 * row[i + 2]}
 
-    baseline = {g.name: red(g.shot(out, 'fireworks-before')) for g in (host, guest)}
+    # Red where the view had none: the setup's own red chat lines (a fill that changed nothing) are in the
+    # baseline, and fade out before the later shots, which a plain count difference would take as missing sparks.
+    baseline = {g.name: reds(g.shot(out, 'fireworks-before')) for g in (host, guest)}
     before = {g.name: made(g, 'flash') for g in (host, guest)}
     host('command', command='item replace entity @s weapon.mainhand with minecraft:firework_rocket'
          '[fireworks={flight_duration:0,explosions:[{shape:"large_ball",colors:[I;16711680],has_trail:true}]}]')
@@ -2990,12 +2992,14 @@ def check_fireworks(host, guest, out):
             break
     flashes = {g.name: made(g, 'flash') - before[g.name] for g in (host, guest)}
     assert all(n == 1 for n in flashes.values()), f'configured burst missing or duplicated: {flashes}'
-    # Capture both views before decoding PNGs: decoding must not consume the sparks' lifetime.
+    # Capture both views before decoding PNGs: decoding must not consume the sparks' lifetime (48-59 ticks). A
+    # screenshot takes ~0.6 s where the frame is drawn on the CPU (lavapipe), so the later shots come 4 ticks after
+    # the burst's, not more: by then the tracked rocket is gone.
     burst_shots = {g.name: g.shot(out, 'fireworks-burst') for g in (host, guest)}
-    host.wait(16)
+    host.wait(4)
     trail_shots = {g.name: g.shot(out, 'fireworks-trail-fade') for g in (host, guest)}
-    burst = {name: red(path) - baseline[name] for name, path in burst_shots.items()}
-    trails = {name: red(path) - baseline[name] for name, path in trail_shots.items()}
+    burst = {name: len(reds(path) - baseline[name]) for name, path in burst_shots.items()}
+    trails = {name: len(reds(path) - baseline[name]) for name, path in trail_shots.items()}
     rockets = {g.name: g('status')['rockets'] for g in (host, guest)}
     assert not any(rockets.values()), f'exploded rocket remains: {rockets}'
     assert all(n > 20 for n in burst.values()), f'no red burst: {burst}'

From 1af4d0e432dda2c68c295d3eb00411cb316b1d64 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:10:36 +0100
Subject: [PATCH 388/475] parity: a workspace crate's features count through
 the sources they gate

A manifest line defining or turning on a workspace crate's feature no longer
makes the manifests count, if every source naming the feature (or one it turns
on) changed too, as in a split, where the new crate's files are all new.
#2215 (horizon-items with a test-support feature) now selects 209 harnesses
instead of 354.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/test_parity_runner.py | 21 +++++++++++++++
 tools/parity.py             | 53 +++++++++++++++++++++++++++++++++----
 2 files changed, 69 insertions(+), 5 deletions(-)

diff --git a/tests/test_parity_runner.py b/tests/test_parity_runner.py
index 20b3b1efb..39d3cc783 100644
--- a/tests/test_parity_runner.py
+++ b/tests/test_parity_runner.py
@@ -440,5 +440,26 @@ class WorkspaceManifestTests(unittest.TestCase):
         resolver = {"Cargo.toml": '[workspace]\nmembers = ["a"]\nresolver = "3"\n'}
         self.assertEqual(self.verdict({"Cargo.toml": '[workspace]\nmembers = ["a"]\nresolver = "2"\n'}, resolver), set())
 
+    def test_a_feature_of_a_workspace_crate_counts_through_its_sources(self):
+        items = '[package]\nname = "horizon-items"\n\n[features]\ntest-support = []\n'
+        client = self.CLIENT + '\n[dev-dependencies]\nhorizon-items = { path = "../horizon-items", features = ["test-support"] }\n'
+        head = {"crates/horizon-items/Cargo.toml": items, "crates/horizon-client/Cargo.toml": client,
+                "crates/horizon-items/src/lib.rs": '#[cfg(feature = "test-support")]\npub fn for_tests() {}\n'}
+        base = {"crates/horizon-client/Cargo.toml": self.CLIENT}
+        # The new crate's files are all changed, the code the feature gates with them.
+        self.assertEqual(self.verdict(base, head), {"crates/horizon-items/Cargo.toml", "crates/horizon-client/Cargo.toml"})
+        # Turning on a feature of a crate whose gated code didn't change selects as before.
+        world = '[package]\nname = "horizon-world"\n\n[features]\nextra = ["more"]\nmore = []\n'
+        with tempfile.TemporaryDirectory() as temp, mock.patch.object(parity, "ROOT", Path(temp)):
+            Path(temp, "crates/horizon-world/src").mkdir(parents=True)
+            Path(temp, "crates/horizon-world/Cargo.toml").write_text(world)
+            Path(temp, "crates/horizon-world/src/lib.rs").write_text('#[cfg(feature = "more")]\nfn x() {}\n')
+            self.assertFalse(parity.feature_sources_changed("horizon-world", "extra", {"crates/horizon-client/Cargo.toml"}))
+            self.assertTrue(parity.feature_sources_changed("horizon-world", "extra", {"crates/horizon-world/src/lib.rs"}))
+            self.assertFalse(parity.feature_sources_changed("horizon-nothing", "extra", set()))
+        # A feature that reaches an external package counts.
+        optional = {"crates/horizon-client/Cargo.toml": self.CLIENT + '\n[features]\nfast = ["wgpu/x"]\n'}
+        self.assertEqual(self.verdict({"crates/horizon-client/Cargo.toml": self.CLIENT}, optional), set())
+
     def test_without_a_base_everything_counts(self):
         self.assertEqual(parity.workspace_only_manifests({"Cargo.lock"}, None), set())
diff --git a/tools/parity.py b/tools/parity.py
index 76da59b4c..e79da823f 100644
--- a/tools/parity.py
+++ b/tools/parity.py
@@ -1248,9 +1248,14 @@ def trace_main(output, script, arguments):
 SHARED_INPUTS = {"research-lock.json", "Cargo.lock"}
 # Manifest sections that say what a crate is and where its targets are, not what it builds with.
 MANIFEST_SECTION_KEPT = re.compile(r"\[\[?(?:package|lib|bin|example|test|bench|lints|badges)\b[^\]]*\]\]?$")
-# A workspace crate named as a dependency (by path, or from the workspace's own table), or listed as a member.
-WORKSPACE_LINE = re.compile(r'(?:horizon[\w-]*|cargo-horizon-mod|xtask)\s*=\s*(?:\{[^}]*\b(?:path|workspace)\s*=[^}]*\}|true)'
-                            r'|(?:horizon[\w-]*|cargo-horizon-mod|xtask)\.workspace\s*=\s*true|"crates/[^"]+",?')
+WORKSPACE_CRATE = r"(horizon[\w-]*|cargo-horizon-mod|xtask)"
+# A workspace crate named as a dependency (by path, or from the workspace's own table) without choosing its features,
+# or listed as a member.
+WORKSPACE_LINE = re.compile(WORKSPACE_CRATE + r'\s*=\s*(?:\{(?![^}]*\bfeatures\b)[^}]*\b(?:path|workspace)\s*=[^}]*\}|true)'
+                            r'|' + WORKSPACE_CRATE + r'\.workspace\s*=\s*true|"crates/[^"]+",?')
+# A workspace crate named as a dependency with some of its features turned on.
+WORKSPACE_FEATURES = re.compile(WORKSPACE_CRATE + r'\s*=\s*\{(?=[^}]*\b(?:path|workspace)\s*=)(?![^}]*default-features)'
+                                r'[^}]*\bfeatures\s*=\s*\[([^\]]*)\][^}]*\}')
 
 
 def git_show(base, path):
@@ -1263,12 +1268,14 @@ def manifest_lines(text):
     """A Cargo.toml's lines that decide what is built: (section, line) pairs, without its package's identity and
     targets, comments, or workspace crates (whose code counts through its own sources)."""
     lines, section = set(), ""
+    name = re.search(r'^\[package\][^\[]*?^name\s*=\s*"([^"]+)"', text or "", re.M | re.S)
     for raw in (text or "").splitlines():
         line = re.sub(r"\s+", " ", raw.split("#", 1)[0]).strip()
         if not line:
             continue
         if line.startswith("["):
-            section = line
+            # A crate's features are its own: the same line in two crates means two things.
+            section = f"[features] of {name.group(1) if name else '?'}" if line == "[features]" else line
             continue
         if MANIFEST_SECTION_KEPT.match(section) or WORKSPACE_LINE.fullmatch(line) or \
                 section == "[workspace]" and (line.startswith("members =") or line.startswith('"') or line == "]"):
@@ -1297,7 +1304,43 @@ def workspace_only_manifests(changed, base):
     before = set().union(*(manifest_lines(git_show(base, path)) for path in tomls)) if tomls else set()
     after = set().union(*(manifest_lines((ROOT / path).read_text(encoding="utf-8") if (ROOT / path).exists() else None)
                           for path in tomls)) if tomls else set()
-    return set(manifests) if before == after else set()
+    # Workspace crates' features that a changed line defines or turns on: they change what compiles of that crate's
+    # sources, which is fine only where every source naming them changed too (a split: the crate's files are new).
+    gated = set()
+    for section, line in before ^ after:
+        wanted = WORKSPACE_FEATURES.fullmatch(line)
+        if wanted:
+            gated |= {(wanted.group(1), feature) for feature in re.findall(r'"([^"]+)"', wanted.group(2))}
+        elif section.startswith("[features] of ") and re.fullmatch(r'[\w-]+ = \[(?: ?"[\w-]+",?)*\s*\]', line):
+            gated.add((section[len("[features] of "):], line.split(" ", 1)[0]))
+        else:
+            return set()  # an external package, a feature reaching one ("dep:", "crate/feature"), a build setting
+    return set(manifests) if all(feature_sources_changed(crate, feature, changed) for crate, feature in gated) else set()
+
+
+def feature_sources_changed(crate, feature, changed):
+    """Whether every Rust source of workspace crate `crate` that names `feature`, or a feature it turns on, is in
+    changed (False where the crate isn't found)."""
+    listed = subprocess.run(["git", "ls-files", "*Cargo.toml"], cwd=ROOT, capture_output=True, text=True)
+    manifests = [ROOT / path for path in listed.stdout.split()] if listed.returncode == 0 else list(ROOT.rglob("Cargo.toml"))
+    for manifest in manifests:
+        text = manifest.read_text(encoding="utf-8") if manifest.exists() else ""
+        if re.search(r'^\[package\][^\[]*?^name\s*=\s*"' + re.escape(crate) + '"', text, re.M | re.S):
+            break
+    else:
+        return False
+    table = re.search(r"^\[features\]\n(.*?)(?=^\[|\Z)", text, re.M | re.S)
+    implies = {name: re.findall(r'"([^"]+)"', value) for name, value in
+               re.findall(r'^([\w-]+)\s*=\s*\[([^\]]*)\]', table.group(1) if table else "", re.M)}
+    names, todo = set(), [feature]
+    while todo:
+        name = todo.pop()
+        if name not in names:
+            names.add(name)
+            todo += [implied for implied in implies.get(name, []) if "/" not in implied and ":" not in implied]
+    named = re.compile(r'feature\s*=\s*"(?:' + "|".join(map(re.escape, sorted(names))) + r')"')
+    return all(path.relative_to(ROOT).as_posix() in changed for path in manifest.parent.rglob("*.rs")
+               if named.search(path.read_text(encoding="utf-8", errors="replace")))
 
 
 def changed_files(ref):

From 844441874a8b77d3a4185024650c293f49674a5d Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:11:27 +0100
Subject: [PATCH 389/475] docs: workspace crate features in a split

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/parity-workflow.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md
index 4d20d32be..6cb235c3c 100644
--- a/docs/parity-workflow.md
+++ b/docs/parity-workflow.md
@@ -64,7 +64,7 @@ A harness can declare, at the top level of its script:
 
 ### Which harnesses a change affects
 
-`--changed` and `--changed-files` narrow each harness's Rust sources to those its probes can reach (`tools/parity_reach.py`), so a change to one module of `horizon-client` no longer reruns every harness whose probe links the crate. The narrowing works on items, not files: from the probe modules a harness ran (or the binary it built), a free item (fn, type, const, static) is reached when a reached item names it in its own module, through a path or an import of a module that is named, or through a glob import; an inherent impl's methods count one by one once their type is reached and their name is mentioned; a trait impl counts once its trait and its type are reached (std's traits and types always are); a macro counts once invoked. Names match by spelling, so the result only over-approximates. A reached file's parent modules count through their `mod` declarations of it, compared with the merge base; Rust files a change adds take part, a dependency that was deleted counts as changed, code under `#[cfg(test)]` never counts, and a harness whose probe can't be found keeps every source. Parses are cached by content in `reach-cache.json` of the shared parity folder (beside `passes/`), so a new worktree starts warm; a harness's search stops as soon as it reaches a changed file, and after `PARITY_REACH_BUDGET` seconds (default 180) the remaining harnesses count every source their probes link, so choosing never holds a slow machine for long. `--by-crate` turns the narrowing off. With `--changed`, `Cargo.lock` and `Cargo.toml` changes that only add, remove or move workspace crates (a crate split: no registry or git package, version, feature, dependency or build setting changed across them, compared with the merge base) don't count: the moved code counts through its sources. #2160's split went from 352 harnesses to 123 this way (its own changes to the runner still select them all). On the last 20 pull requests merged on 2026-10-25, the harnesses picked went from 2255 to 1061 (2384 to 1592 harness-minutes; game-binary harnesses, which link all of `game/`, set the floor), and every harness a CI parity run failed in the week before was still picked; every source file a sample of probes executed (LLVM `-C instrument-coverage`) is among those kept. Building the graph takes 15 s cold, under a second warm, and up to a minute and a half on a change that reaches many harnesses.
+`--changed` and `--changed-files` narrow each harness's Rust sources to those its probes can reach (`tools/parity_reach.py`), so a change to one module of `horizon-client` no longer reruns every harness whose probe links the crate. The narrowing works on items, not files: from the probe modules a harness ran (or the binary it built), a free item (fn, type, const, static) is reached when a reached item names it in its own module, through a path or an import of a module that is named, or through a glob import; an inherent impl's methods count one by one once their type is reached and their name is mentioned; a trait impl counts once its trait and its type are reached (std's traits and types always are); a macro counts once invoked. Names match by spelling, so the result only over-approximates. A reached file's parent modules count through their `mod` declarations of it, compared with the merge base; Rust files a change adds take part, a dependency that was deleted counts as changed, code under `#[cfg(test)]` never counts, and a harness whose probe can't be found keeps every source. Parses are cached by content in `reach-cache.json` of the shared parity folder (beside `passes/`), so a new worktree starts warm; a harness's search stops as soon as it reaches a changed file, and after `PARITY_REACH_BUDGET` seconds (default 180) the remaining harnesses count every source their probes link, so choosing never holds a slow machine for long. `--by-crate` turns the narrowing off. With `--changed`, `Cargo.lock` and `Cargo.toml` changes that only add, remove or move workspace crates (a crate split: no registry or git package, version, feature, dependency or build setting changed across them, compared with the merge base) don't count: the moved code counts through its sources. A workspace crate's feature that such a change defines or turns on is allowed only where every source naming it changed too (the new crate's own files). #2160's split went from 352 harnesses to 123 this way (its own changes to the runner still select them all). On the last 20 pull requests merged on 2026-10-25, the harnesses picked went from 2255 to 1061 (2384 to 1592 harness-minutes; game-binary harnesses, which link all of `game/`, set the floor), and every harness a CI parity run failed in the week before was still picked; every source file a sample of probes executed (LLVM `-C instrument-coverage`) is among those kept. Building the graph takes 15 s cold, under a second warm, and up to a minute and a half on a change that reaches many harnesses.
 
 ## The gate
 

From 1d0d827f3aa2ce9199c17c8872122abf48ebdfd9 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:13:35 +0100
Subject: [PATCH 390/475] Launcher: instances, each with its own game folder

The game's folder stays the default instance, "Horizon", where it is; imported
and registry modpacks are listed as instances in their own folders; new ones
go to instances/<slug>/ in the game's folder, empty (the player's options and
offline name) or a copy of another (never sessions, logs or telemetry). Names,
icons and groups live in the launcher's instances.json, so nothing moves.
Play, `play --instance` and MCP play start the selected instance, which
follows the launcher's data collection answer and No AI. Crash reports are
read from the run's own folder.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md            |  63 ++++
 launcher/README.md                   |  14 +-
 launcher/src/backend.rs              |  10 +-
 launcher/src/browser/horizon/pack.rs |   2 +-
 launcher/src/cli.rs                  |  97 +++++++
 launcher/src/instances.rs            | 414 +++++++++++++++++++++++++++
 launcher/src/instances/tests.rs      | 203 +++++++++++++
 launcher/src/lib.rs                  |   1 +
 launcher/src/main.rs                 |  18 +-
 launcher/src/mcp.rs                  |   7 +
 launcher/src/modpacks.rs             |   6 +-
 11 files changed, 823 insertions(+), 12 deletions(-)
 create mode 100644 launcher/src/instances.rs
 create mode 100644 launcher/src/instances/tests.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 1e9fb7722..e233cc9a9 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -50,6 +50,7 @@ Start the client.
 
     horizon-launcher play
 
+- `--instance`: The instance to play (its name or id; default: the selected one)
 - `--world`: Open or create this world (a folder under saves) at once
 - `--creative`: Creative mode for a new world
 - `--join`: Join a friend's world with its invite code
@@ -257,6 +258,68 @@ Upload a benchmark report (docs/benchmark-report.md); it is printed first.
 
 MCP: `data_benchmark`, only when the player asks.
 
+## `horizon-launcher instance list`
+
+The instances, each with its game folder (* = the one Play starts).
+
+    horizon-launcher instance list
+
+MCP: `instance_list`.
+
+## `horizon-launcher instance create`
+
+Make an instance: empty but for your options and name, or a copy of another one's worlds, options and packs.
+
+    horizon-launcher instance create <NAME>
+
+- `NAME`
+- `--copy`: The instance to copy (its name or id)
+
+MCP: `instance_create`.
+
+## `horizon-launcher instance rename`
+
+Rename an instance (its folder stays).
+
+    horizon-launcher instance rename <INSTANCE> <NAME>
+
+- `INSTANCE`
+- `NAME`
+
+MCP: `instance_rename`.
+
+## `horizon-launcher instance icon`
+
+Set an instance's icon: a block or item name from your prepared files (grass_block), a colour (#3fa7d6), or none.
+
+    horizon-launcher instance icon <INSTANCE> <ICON>
+
+- `INSTANCE`
+- `ICON`
+
+MCP: `instance_icon`.
+
+## `horizon-launcher instance group`
+
+Put an instance in a sidebar group, or take it out with no group.
+
+    horizon-launcher instance group <INSTANCE> [GROUP]
+
+- `INSTANCE`
+- `GROUP`
+
+MCP: `instance_group`.
+
+## `horizon-launcher instance select`
+
+Make Play start this instance.
+
+    horizon-launcher instance select <INSTANCE>
+
+- `INSTANCE`
+
+MCP: `instance_select`.
+
 ## `horizon-launcher modpack list`
 
 The imported packs and their coverage (the default).
diff --git a/launcher/README.md b/launcher/README.md
index 9c6f3a9d9..89df726d1 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -69,6 +69,14 @@ The opening, then Play ([clip](docs/opening.webm)):
   access controls, one click changes them so friends you share with reach only the server's
   port (Remove the limit undoes it); custom access controls are never rewritten, the page gives
   the rule to add instead. Horizon never turns on Funnel.
+- **Instances**: separate game folders, each with its own worlds, options and packs. The game's
+  folder stays the first one, "Horizon", exactly where it was; imported and registry modpacks are
+  instances too, in their own folders as before; new ones go to `instances/<name>/` in the game's
+  folder, empty but for the player's options and name, or a copy of another instance (never its
+  sign-in sessions, logs or data collection state). Names, icons (a block or item texture from the
+  player's prepared files, or a colour) and groups are kept in `instances.json` in the launcher's
+  data folder, so renaming moves nothing. Every instance follows the launcher's data collection
+  answer and No AI.
 - **Patch notes**: each release's notes, newest first, with a link to GitHub Sponsors. Quiet "Discord" and "Website" links sit in the footer.
 
 Data lives in the platform's data directory (`~/.local/share/horizon-launcher` on Linux,
@@ -152,7 +160,7 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
     horizon-launcher install <tag|latest>
     horizon-launcher remove <tag>
     horizon-launcher prepare [--minecraft <dir>] [--version <tag>]
-    horizon-launcher play [--version <tag>] [--arg <ARG>]...   start the client; --arg passes an extra argument through (repeatable)
+    horizon-launcher play [--version <tag>] [--instance <name>] [--arg <ARG>]...   start the client; --arg passes an extra argument through (repeatable)
     horizon-launcher server [--dir <dir>] [--version <tag>] [--accept-eula]
     horizon-launcher notes [<tag>]                  patch notes as plain text
     horizon-launcher links                          the Discord, sponsor and website links
@@ -164,6 +172,10 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
     horizon-launcher account sign-out <name>
     horizon-launcher account select <name>          play as this account
     horizon-launcher account offline                play without an account
+    horizon-launcher instance [list]                the instances and their game folders (* = Play starts it)
+    horizon-launcher instance create <name> [--copy <instance>]   empty, or a copy of one's worlds, options and packs
+    horizon-launcher instance rename|icon|group <instance> <value>  icon: a block or item name, #rrggbb or none
+    horizon-launcher instance select <instance>     make Play start it
     horizon-launcher modpack [list]                 the imported packs and their coverage
     horizon-launcher modpack import <pack>          a .mrpack, CurseForge zip or instance folder
     horizon-launcher modpack port <pack> [--from <dir>] [--version <tag>]   get the jars and carry them over
diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs
index 55a78193a..dbd54aeee 100644
--- a/launcher/src/backend.rs
+++ b/launcher/src/backend.rs
@@ -1585,9 +1585,10 @@ pub fn newest_crash_report() -> Option<PathBuf> {
     crash_reports_in(&crash_reports_dir()).pop()
 }
 
-/// The newest crash report written at or after `since` (one from the run that started then).
-pub fn crash_report_since(since: std::time::SystemTime) -> Option<PathBuf> {
-    crash_report_in_since(&crash_reports_dir(), since)
+/// The newest crash report the game playing in `home` wrote at or after `since` (one from the
+/// run that started then).
+pub fn crash_report_since(home: &Path, since: std::time::SystemTime) -> Option<PathBuf> {
+    crash_report_in_since(&home.join("crash-reports"), since)
 }
 
 fn crash_report_in_since(dir: &Path, since: std::time::SystemTime) -> Option<PathBuf> {
@@ -2517,6 +2518,9 @@ pub enum Appearance {
 #[derive(Default, serde::Serialize, serde::Deserialize)]
 pub struct Settings {
     pub selected: Option<String>,
+    /// The instance Play starts (`instances`), by id. Unset means Horizon, the game's home.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub instance: Option<String>,
     pub minecraft_dir: Option<PathBuf>,
     pub server_dir: Option<PathBuf>,
     /// Unset means on: only a player who turned it off has `false` here. 0.1.1 wrote its
diff --git a/launcher/src/browser/horizon/pack.rs b/launcher/src/browser/horizon/pack.rs
index 95235a505..2b8e2db9e 100644
--- a/launcher/src/browser/horizon/pack.rs
+++ b/launcher/src/browser/horizon/pack.rs
@@ -37,7 +37,7 @@ pub fn list() -> Vec<Installed> {
     list_in(&packs_dir())
 }
 
-fn list_in(dir: &Path) -> Vec<Installed> {
+pub(crate) fn list_in(dir: &Path) -> Vec<Installed> {
     let mut packs: Vec<Installed> = fs::read_dir(dir)
         .into_iter()
         .flatten()
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 7d6ff7514..22a850c02 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -3,6 +3,7 @@
 use clap::{Parser, Subcommand};
 use horizon_launcher::account::{self, Accounts};
 use horizon_launcher::backend::{self, Release};
+use horizon_launcher::instances;
 use std::io::{IsTerminal, Write};
 use std::path::PathBuf;
 use std::process::Command;
@@ -155,6 +156,32 @@ enum ModpackCmd {
     Remove { pack: String },
 }
 
+#[derive(Subcommand)]
+enum InstanceCmd {
+    /// The instances, each with its game folder (* = the one Play starts)
+    List,
+    /// Make an instance: empty but for your options and name, or a copy of another one's
+    /// worlds, options and packs
+    Create {
+        name: String,
+        /// The instance to copy (its name or id)
+        #[arg(long)]
+        copy: Option<String>,
+    },
+    /// Rename an instance (its folder stays)
+    Rename { instance: String, name: String },
+    /// Set an instance's icon: a block or item name from your prepared files (grass_block),
+    /// a colour (#3fa7d6), or none
+    Icon { instance: String, icon: String },
+    /// Put an instance in a sidebar group, or take it out with no group
+    Group {
+        instance: String,
+        group: Option<String>,
+    },
+    /// Make Play start this instance
+    Select { instance: String },
+}
+
 #[derive(Subcommand)]
 enum ModsCmd {
     /// What the browser installed (the default)
@@ -261,6 +288,9 @@ enum Cmd {
     Play {
         #[arg(long)]
         version: Option<String>,
+        /// The instance to play (its name or id; default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
         /// Open or create this world (a folder under saves) at once
         #[arg(long)]
         world: Option<String>,
@@ -341,6 +371,11 @@ enum Cmd {
         #[command(subcommand)]
         action: Option<DataCmd>,
     },
+    /// Instances: separate game folders, each with its own worlds, options and packs
+    Instance {
+        #[command(subcommand)]
+        action: Option<InstanceCmd>,
+    },
     /// Modpacks: import a Java pack, see its coverage report, port what this computer can and
     /// play it as its own profile (docs/modpacks.md)
     Modpack {
@@ -606,12 +641,18 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
         }
         Cmd::Play {
             version,
+            instance,
             world,
             creative,
             join,
             arg,
         } => {
             let mut cmd = backend::client(&backend::resolve_version(version.as_deref())?)?;
+            let instance = match instance {
+                Some(name) => instances::find(&name)?,
+                None => instances::selected(),
+            };
+            instances::apply(&mut cmd, &instance)?;
             if let Some(code) = join {
                 backend::join_friend(&mut cmd, &code)?;
             }
@@ -784,6 +825,7 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
                 println!("Horizon is in the applications menu.");
             }
         }
+        Cmd::Instance { action } => instance(action.unwrap_or(InstanceCmd::List), as_json)?,
         Cmd::Modpack { action } => modpack(action.unwrap_or(ModpackCmd::List), as_json)?,
         Cmd::Mods { action } => mods(action.unwrap_or(ModsCmd::List), as_json)?,
         Cmd::Servers { action } => servers(action.unwrap_or(ServersCmd::List), as_json)?,
@@ -1337,6 +1379,61 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
     Ok(())
 }
 
+fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
+    use instances::Icon;
+    let value = |i: &instances::Instance, selected: bool| {
+        serde_json::json!({
+            "id": i.id, "name": i.name, "kind": format!("{:?}", i.kind).to_lowercase(),
+            "home": i.home, "icon": i.icon, "group": i.group, "selected": selected,
+        })
+    };
+    let line = |i: &instances::Instance, selected: bool| {
+        let mark = if selected { "*" } else { " " };
+        let group = i
+            .group
+            .as_ref()
+            .map(|g| format!("  [{g}]"))
+            .unwrap_or_default();
+        println!(
+            "{mark} {} ({}){group}\n    {}",
+            i.name,
+            i.id,
+            i.home.display()
+        );
+    };
+    let changed = |i: instances::Instance| {
+        let selected = i.id == instances::selected().id;
+        match as_json {
+            true => json(value(&i, selected)),
+            false => line(&i, selected),
+        }
+    };
+    match action {
+        InstanceCmd::List => {
+            let selected = instances::selected().id;
+            let all = instances::list();
+            if as_json {
+                json(all.iter().map(|i| value(i, i.id == selected)).collect());
+            } else {
+                all.iter().for_each(|i| line(i, i.id == selected));
+            }
+        }
+        InstanceCmd::Create { name, copy } => changed(instances::create(&name, copy.as_deref())?),
+        InstanceCmd::Rename { instance, name } => {
+            changed(instances::edit(&instance, |m| m.name = Some(name))?)
+        }
+        InstanceCmd::Icon { instance, icon } => {
+            let icon = (icon != "none").then(|| Icon::parse(&icon)).transpose()?;
+            changed(instances::edit(&instance, |m| m.icon = icon)?)
+        }
+        InstanceCmd::Group { instance, group } => {
+            changed(instances::edit(&instance, |m| m.group = group)?)
+        }
+        InstanceCmd::Select { instance } => changed(instances::select(&instance)?),
+    }
+    Ok(())
+}
+
 fn modpack(action: ModpackCmd, as_json: bool) -> Result<(), String> {
     use horizon_launcher::browser::horizon;
     use horizon_launcher::modpacks::{self, Imported};
diff --git a/launcher/src/instances.rs b/launcher/src/instances.rs
new file mode 100644
index 000000000..d2e74dde1
--- /dev/null
+++ b/launcher/src/instances.rs
@@ -0,0 +1,414 @@
+//! Instances: separate game folders, each with its own worlds, options and packs.
+//!
+//! Nothing that exists moves. The game's home (`backend::game_home`) stays the default instance,
+//! "Horizon", with its saves and options where they are. Imported modpacks (`ports/<pack>/home/`)
+//! and registry modpacks (`horizon-packs/<id>/home/`) are instances too, played from their own
+//! folders as before. New instances get `instances/<slug>/` in the game's home. What the player
+//! chooses about an instance (its name, icon, group) is kept in `instances.json` in the
+//! launcher's data folder, so renaming one never moves a folder.
+use crate::backend;
+use crate::browser::horizon::pack as registry_pack;
+use crate::modpacks;
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+/// The default instance's id: the game's home itself.
+pub const DEFAULT: &str = "horizon";
+const FILE: &str = "instances.json";
+/// Where new instances live, in the game's home.
+const OWN: &str = "instances";
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Kind {
+    /// The game's home: what every player had before instances.
+    Default,
+    /// Made in the launcher: `instances/<slug>/`.
+    Own,
+    /// An imported Java modpack (modpacks.rs).
+    Port,
+    /// A modpack from Horizon's registry.
+    Pack,
+}
+
+/// What an instance shows in the sidebar: a block or item texture from the player's prepared
+/// files (never shipped), or a colour.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Icon {
+    /// A texture name: `grass_block` (block/ is looked in first, then item/).
+    Texture(String),
+    /// `#rrggbb`.
+    Colour(String),
+}
+
+impl Icon {
+    /// `#3fa7d6` is a colour; a texture's name is lowercase letters, digits and `_`.
+    pub fn parse(text: &str) -> Result<Icon, String> {
+        let text = text.trim();
+        if let Some(hex) = text.strip_prefix('#') {
+            if hex.len() == 6 && hex.chars().all(|c| c.is_ascii_hexdigit()) {
+                return Ok(Icon::Colour(format!("#{}", hex.to_ascii_lowercase())));
+            }
+        } else if !text.is_empty()
+            && text
+                .chars()
+                .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_')
+        {
+            return Ok(Icon::Texture(text.into()));
+        }
+        Err(format!(
+            "{text}: give a block or item name (grass_block) or a colour (#3fa7d6)"
+        ))
+    }
+
+    /// The texture's file in prepared resources, if it is a texture they hold.
+    pub fn texture(&self, resources: &Path) -> Option<PathBuf> {
+        let Icon::Texture(name) = self else {
+            return None;
+        };
+        let textures = resources.join("assets/minecraft/textures");
+        ["block", "item"]
+            .iter()
+            .map(|kind| textures.join(kind).join(format!("{name}.png")))
+            .find(|p| p.is_file())
+    }
+}
+
+/// The player's choices about one instance.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Meta {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub icon: Option<Icon>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group: Option<String>,
+}
+
+/// `instances.json`: each instance's choices, by id.
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+struct Store {
+    #[serde(default)]
+    instances: BTreeMap<String, Meta>,
+}
+
+impl Store {
+    fn load(data: &Path) -> Store {
+        fs::read_to_string(data.join(FILE))
+            .ok()
+            .and_then(|t| serde_json::from_str(&t).ok())
+            .unwrap_or_default()
+    }
+    fn save(&self, data: &Path) -> Result<(), String> {
+        fs::create_dir_all(data).map_err(|e| format!("{}: {e}", data.display()))?;
+        let text = serde_json::to_string_pretty(self).unwrap();
+        fs::write(data.join(FILE), text).map_err(|e| format!("{FILE}: {e}"))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Instance {
+    /// `horizon`, an own instance's folder name, `port:<pack>` or `pack:<id>`.
+    pub id: String,
+    pub name: String,
+    pub kind: Kind,
+    /// The folder the pack's tools work in: the game's home for Default and Own instances.
+    pub work: PathBuf,
+    /// The game folder it plays in: saves, options.txt, packs.
+    pub home: PathBuf,
+    pub icon: Option<Icon>,
+    pub group: Option<String>,
+}
+
+/// The instances, by the default game home and the launcher's data folder: Horizon first, then
+/// by group and name.
+pub fn list() -> Vec<Instance> {
+    list_in(&backend::game_home(), &backend::data_dir())
+}
+
+fn list_in(game_home: &Path, data: &Path) -> Vec<Instance> {
+    let store = Store::load(data);
+    let mut found = vec![(
+        DEFAULT.to_string(),
+        "Horizon".to_string(),
+        Kind::Default,
+        game_home.to_path_buf(),
+        game_home.to_path_buf(),
+    )];
+    let mut own: Vec<_> = fs::read_dir(game_home.join(OWN))
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter(|e| e.path().is_dir())
+        .filter_map(|e| e.file_name().into_string().ok())
+        .collect();
+    own.sort();
+    for slug in own {
+        let dir = game_home.join(OWN).join(&slug);
+        found.push((slug.clone(), slug, Kind::Own, dir.clone(), dir));
+    }
+    for p in modpacks::list_in(&game_home.join("ports")) {
+        let home = modpacks::profile_home(&p.work);
+        found.push((
+            format!("port:{}", p.slug),
+            p.title().into(),
+            Kind::Port,
+            p.work,
+            home,
+        ));
+    }
+    for p in registry_pack::list_in(&game_home.join("horizon-packs")) {
+        let home = registry_pack::home(&p.work);
+        found.push((format!("pack:{}", p.id), p.name, Kind::Pack, p.work, home));
+    }
+    let mut out: Vec<Instance> = found
+        .into_iter()
+        .map(|(id, name, kind, work, home)| {
+            let meta = store.instances.get(&id).cloned().unwrap_or_default();
+            Instance {
+                name: meta.name.unwrap_or(name),
+                icon: meta.icon,
+                group: meta.group,
+                id,
+                kind,
+                work,
+                home,
+            }
+        })
+        .collect();
+    out[1..].sort_by_key(|i| (i.group.clone(), i.name.to_lowercase()));
+    out
+}
+
+/// The instance an id, a name (any case) or a pack's folder name names.
+pub fn find(query: &str) -> Result<Instance, String> {
+    find_in(&list(), query)
+}
+
+fn find_in(all: &[Instance], query: &str) -> Result<Instance, String> {
+    let q = query.trim();
+    let bare = |id: &str| id.split_once(':').map_or(id, |(_, rest)| rest).to_string();
+    all.iter()
+        .find(|i| i.id == q)
+        .or_else(|| all.iter().find(|i| i.name.eq_ignore_ascii_case(q)))
+        .or_else(|| all.iter().find(|i| bare(&i.id) == q))
+        .cloned()
+        .ok_or_else(|| format!("No instance {q}: horizon-launcher instance list shows them"))
+}
+
+/// The instance Play starts: the one picked in the launcher, else Horizon.
+pub fn selected() -> Instance {
+    let all = list();
+    backend::Settings::load()
+        .instance
+        .and_then(|id| all.iter().find(|i| i.id == id).cloned())
+        .unwrap_or_else(|| all[0].clone())
+}
+
+pub fn select(query: &str) -> Result<Instance, String> {
+    let instance = find(query)?;
+    let mut settings = backend::Settings::load();
+    settings.instance = (instance.kind != Kind::Default).then(|| instance.id.clone());
+    settings.save();
+    Ok(instance)
+}
+
+/// What a copy of a game folder leaves out: other instances and packs, logs and crash reports,
+/// caches, data collection's state, and sign-in sessions (a session never leaves its folder).
+const NOT_COPIED: &[&str] = &[
+    OWN,
+    "ports",
+    "horizon-packs",
+    "logs",
+    "crash-reports",
+    "sessions",
+    "telemetry",
+    "mod-browser",
+    ".horizon-cache",
+];
+
+/// Files of the player, not of one instance, that a new instance starts with: the keys and video
+/// settings, and the offline name (so the player stays the same player in its worlds).
+const PLAYER_FILES: &[&str] = &["options.txt", "horizon-player.txt"];
+
+/// Creates an instance named `name`: empty but for the player's options and offline name, or a
+/// copy of `from`'s game folder (its worlds, options and packs). Nothing of `from` changes.
+pub fn create(name: &str, from: Option<&str>) -> Result<Instance, String> {
+    let from = from.map(find).transpose()?;
+    create_in(
+        &backend::game_home(),
+        &backend::data_dir(),
+        name,
+        from.as_ref(),
+    )
+}
+
+fn create_in(
+    game_home: &Path,
+    data: &Path,
+    name: &str,
+    from: Option<&Instance>,
+) -> Result<Instance, String> {
+    let name = name.trim();
+    if name.is_empty() {
+        return Err("An instance needs a name.".into());
+    }
+    let all = list_in(game_home, data);
+    if all.iter().any(|i| i.name.eq_ignore_ascii_case(name)) {
+        return Err(format!("There is already an instance called {name}."));
+    }
+    if let Some(from) = from.filter(|f| matches!(f.kind, Kind::Port | Kind::Pack)) {
+        return Err(format!(
+            "{} plays its pack's mods: import the pack again for a second copy.",
+            from.name
+        ));
+    }
+    let base = modpacks::slug(name);
+    let taken = |s: &str| s == DEFAULT || game_home.join(OWN).join(s).exists();
+    let slug = (1..)
+        .map(|n| {
+            if n == 1 {
+                base.clone()
+            } else {
+                format!("{base}-{n}")
+            }
+        })
+        .find(|s| !taken(s))
+        .unwrap();
+    let dir = game_home.join(OWN).join(&slug);
+    let made = match from {
+        Some(from) => copy_home(&from.home, &dir),
+        None => fs::create_dir_all(&dir).and_then(|()| {
+            for f in PLAYER_FILES {
+                let own = game_home.join(f);
+                if own.is_file() {
+                    fs::copy(own, dir.join(f))?;
+                }
+            }
+            Ok(())
+        }),
+    };
+    if let Err(e) = made {
+        let _ = fs::remove_dir_all(&dir);
+        return Err(format!("Could not make {}: {e}", dir.display()));
+    }
+    let mut store = Store::load(data);
+    let meta = store.instances.entry(slug.clone()).or_default();
+    meta.name = (name != slug).then(|| name.to_string());
+    meta.icon = from.and_then(|f| f.icon.clone());
+    meta.group = from.and_then(|f| f.group.clone());
+    store.save(data)?;
+    find_in(&list_in(game_home, data), &slug)
+}
+
+fn copy_home(from: &Path, to: &Path) -> std::io::Result<()> {
+    fs::create_dir_all(to)?;
+    for entry in fs::read_dir(from)? {
+        let entry = entry?;
+        let name = entry.file_name();
+        if NOT_COPIED.iter().any(|n| name == *n) {
+            continue;
+        }
+        let path = entry.path();
+        if entry.file_type()?.is_dir() {
+            copy_dir(&path, &to.join(&name))?;
+        } else {
+            fs::copy(&path, to.join(&name))?;
+        }
+    }
+    Ok(())
+}
+
+fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
+    fs::create_dir_all(to)?;
+    for entry in fs::read_dir(from)? {
+        let entry = entry?;
+        let target = to.join(entry.file_name());
+        if entry.file_type()?.is_dir() {
+            copy_dir(&entry.path(), &target)?;
+        } else {
+            fs::copy(entry.path(), target)?;
+        }
+    }
+    Ok(())
+}
+
+/// Changes what the player chose about an instance: its name, icon or group. No folder moves.
+pub fn edit(query: &str, change: impl FnOnce(&mut Meta)) -> Result<Instance, String> {
+    edit_in(&backend::game_home(), &backend::data_dir(), query, change)
+}
+
+fn edit_in(
+    game_home: &Path,
+    data: &Path,
+    query: &str,
+    change: impl FnOnce(&mut Meta),
+) -> Result<Instance, String> {
+    let all = list_in(game_home, data);
+    let instance = find_in(&all, query)?;
+    let mut store = Store::load(data);
+    let meta = store.instances.entry(instance.id.clone()).or_default();
+    change(meta);
+    meta.name = meta.name.take().map(|n| n.trim().to_string());
+    meta.group = meta
+        .group
+        .take()
+        .map(|g| g.trim().to_string())
+        .filter(|g| !g.is_empty());
+    if let Some(name) = &meta.name {
+        if name.is_empty() {
+            return Err("An instance needs a name.".into());
+        }
+        if all
+            .iter()
+            .any(|i| i.id != instance.id && i.name.eq_ignore_ascii_case(name))
+        {
+            return Err(format!("There is already an instance called {name}."));
+        }
+    }
+    store.save(data)?;
+    find_in(&list_in(game_home, data), &instance.id)
+}
+
+/// Turns the game's command into this instance: its own game folder, and a pack's mods. The
+/// player's answers that hold everywhere follow it in: data collection and No AI as the
+/// launcher has them, and options.txt and the offline name when it has none yet.
+pub fn apply(cmd: &mut Command, instance: &Instance) -> Result<(), String> {
+    match instance.kind {
+        Kind::Default => return Ok(()),
+        Kind::Own => {
+            fs::create_dir_all(&instance.home)
+                .map_err(|e| format!("{}: {e}", instance.home.display()))?;
+            cmd.current_dir(&instance.home)
+                .env("HORIZON_HOME", &instance.home);
+        }
+        Kind::Port | Kind::Pack => modpacks::apply_profile(cmd, &instance.work)?,
+    }
+    follow_player(&backend::game_home(), &instance.home);
+    Ok(())
+}
+
+fn follow_player(game_home: &Path, home: &Path) {
+    for f in PLAYER_FILES {
+        if !home.join(f).exists() && game_home.join(f).is_file() {
+            let _ = fs::copy(game_home.join(f), home.join(f));
+        }
+    }
+    let consent = horizon_telemetry::consent::Consent::path(game_home);
+    if consent.is_file() {
+        let to = horizon_telemetry::consent::Consent::path(home);
+        let _ = fs::create_dir_all(to.parent().unwrap());
+        let _ = fs::copy(consent, to);
+    }
+    let no_ai = horizon_core::no_ai::is_on(game_home);
+    if horizon_core::no_ai::is_on(home) != no_ai {
+        let _ = horizon_core::no_ai::set(home, no_ai);
+    }
+}
+
+#[cfg(test)]
+#[path = "instances/tests.rs"]
+mod tests;
diff --git a/launcher/src/instances/tests.rs b/launcher/src/instances/tests.rs
new file mode 100644
index 000000000..586b620b3
--- /dev/null
+++ b/launcher/src/instances/tests.rs
@@ -0,0 +1,203 @@
+use super::*;
+use std::collections::BTreeMap;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-instances-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+fn put(path: &Path, text: &str) {
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(path, text).unwrap();
+}
+
+/// Every file under `dir`, relative, with its bytes.
+fn files(dir: &Path) -> BTreeMap<PathBuf, Vec<u8>> {
+    fn walk(root: &Path, dir: &Path, out: &mut BTreeMap<PathBuf, Vec<u8>>) {
+        for e in fs::read_dir(dir).unwrap().flatten() {
+            let p = e.path();
+            if p.is_dir() {
+                walk(root, &p, out);
+            } else {
+                out.insert(p.strip_prefix(root).unwrap().into(), fs::read(&p).unwrap());
+            }
+        }
+    }
+    let mut out = BTreeMap::new();
+    walk(dir, dir, &mut out);
+    out
+}
+
+/// A game home as a player has it before instances: worlds, options, packs, a session, an
+/// imported modpack and a registry modpack with their own worlds.
+fn player_home(home: &Path) {
+    put(&home.join("saves/World/level.dat"), "world");
+    put(&home.join("saves/World/region/r.0.0.mca"), "region");
+    put(&home.join("saves/Other/level.dat"), "other");
+    put(&home.join("options.txt"), "fov:90\n");
+    put(&home.join("horizon-player.txt"), "name:Player123\n");
+    put(&home.join("resourcepacks/faithful.zip"), "pack");
+    put(&home.join("logs/latest.log"), "log");
+    put(&home.join("sessions/a.json"), "token");
+    put(&home.join("telemetry/consent.json"), "{}");
+    let pack = horizon_port_pack::import::Pack {
+        name: "Small Pack".into(),
+        ..Default::default()
+    };
+    put(
+        &home.join("ports/small-pack/pack.json"),
+        &serde_json::to_string(&pack).unwrap(),
+    );
+    put(
+        &home.join("ports/small-pack/home/saves/Modded/level.dat"),
+        "modded",
+    );
+    put(
+        &home.join("horizon-packs/cozy/pack.json"),
+        r#"{"id":"cozy","name":"Cozy","version":"1.0.0","sha256":"00","mods":[]}"#,
+    );
+    put(
+        &home.join("horizon-packs/cozy/home/saves/Cozy/level.dat"),
+        "cozy",
+    );
+}
+
+#[test]
+fn existing_worlds_stay_where_they_are_and_every_folder_becomes_an_instance() {
+    let root = scratch("migrate");
+    let (home, data) = (root.join("horizon"), root.join("launcher"));
+    player_home(&home);
+    let before = files(&home);
+
+    // A launcher with instances, on a player's existing folders: no instances.json yet.
+    let all = list_in(&home, &data);
+    let ids: Vec<&str> = all.iter().map(|i| i.id.as_str()).collect();
+    assert_eq!(ids, [DEFAULT, "pack:cozy", "port:small-pack"]);
+    assert_eq!(all[0].name, "Horizon");
+    assert_eq!(all[0].home, home);
+    assert_eq!(all[1].home, home.join("horizon-packs/cozy/home"));
+    assert_eq!(all[2].name, "Small Pack");
+    assert_eq!(all[2].home, home.join("ports/small-pack/home"));
+
+    // Everything the player can do with instances, then not one byte of theirs has moved.
+    let empty = create_in(&home, &data, "Survival", None).unwrap();
+    let copy = create_in(&home, &data, "My copy", Some(&all[0])).unwrap();
+    edit_in(&home, &data, DEFAULT, |m| m.name = Some("Main".into())).unwrap();
+    edit_in(&home, &data, "Small Pack", |m| {
+        m.icon = Some(Icon::Texture("diamond".into()));
+        m.group = Some("Modded".into());
+    })
+    .unwrap();
+    let after = files(&home);
+    for (path, bytes) in &before {
+        assert_eq!(after.get(path), Some(bytes), "{} changed", path.display());
+    }
+    assert!(!data.join("settings.json").exists());
+
+    // The empty one has only the player's options and name; the copy has the worlds and
+    // packs, never the sessions, logs, data collection or other instances.
+    assert_eq!(empty.home, home.join("instances/survival"));
+    let empty_files: Vec<PathBuf> = files(&empty.home).into_keys().collect();
+    assert_eq!(
+        empty_files,
+        [PathBuf::from("horizon-player.txt"), "options.txt".into()]
+    );
+    let copied = files(&copy.home);
+    for kept in [
+        "saves/World/region/r.0.0.mca",
+        "saves/Other/level.dat",
+        "resourcepacks/faithful.zip",
+    ] {
+        assert_eq!(copied[Path::new(kept)], before[Path::new(kept)]);
+    }
+    assert!(copied.keys().all(|p| {
+        let top = p.components().next().unwrap().as_os_str().to_str().unwrap();
+        !NOT_COPIED.contains(&top)
+    }));
+
+    let all = list_in(&home, &data);
+    assert_eq!(all[0].name, "Main");
+    let port = find_in(&all, "port:small-pack").unwrap();
+    assert_eq!(port.group.as_deref(), Some("Modded"));
+    assert_eq!(port.home, home.join("ports/small-pack/home"));
+    fs::remove_dir_all(&root).unwrap();
+}
+
+#[test]
+fn names_stay_unique_and_packs_are_not_copied() {
+    let root = scratch("names");
+    let (home, data) = (root.join("horizon"), root.join("launcher"));
+    player_home(&home);
+    create_in(&home, &data, "Survival", None).unwrap();
+    assert!(create_in(&home, &data, "survival", None).is_err());
+    assert!(create_in(&home, &data, "  ", None).is_err());
+    // Another name with the same folder name gets the next free folder.
+    let second = create_in(&home, &data, "Survival!", None).unwrap();
+    assert_eq!(second.id, "survival-2");
+    assert_eq!(second.name, "Survival!");
+    assert!(edit_in(&home, &data, "survival-2", |m| m.name =
+        Some("SURVIVAL".into()))
+    .is_err());
+    let port = find_in(&list_in(&home, &data), "small-pack").unwrap();
+    assert!(create_in(&home, &data, "Pack copy", Some(&port)).is_err());
+    assert!(!home.join("instances/pack-copy").exists());
+    // An empty group is no group.
+    let grouped = edit_in(&home, &data, "Survival", |m| m.group = Some(" ".into())).unwrap();
+    assert_eq!(grouped.group, None);
+    fs::remove_dir_all(&root).unwrap();
+}
+
+#[test]
+fn an_instance_follows_the_players_answers() {
+    let root = scratch("follow");
+    let (main, own) = (root.join("main"), root.join("own"));
+    put(&main.join("options.txt"), "fov:90\n");
+    put(&main.join("horizon-player.txt"), "name:Player123\n");
+    put(&main.join("telemetry/consent.json"), r#"{"version":1}"#);
+    horizon_core::no_ai::set(&main, true).unwrap();
+    put(&own.join("options.txt"), "fov:70\n");
+    follow_player(&main, &own);
+    assert_eq!(
+        fs::read_to_string(own.join("options.txt")).unwrap(),
+        "fov:70\n"
+    );
+    assert_eq!(
+        fs::read_to_string(own.join("horizon-player.txt")).unwrap(),
+        "name:Player123\n"
+    );
+    assert_eq!(
+        fs::read_to_string(own.join("telemetry/consent.json")).unwrap(),
+        r#"{"version":1}"#
+    );
+    assert!(horizon_core::no_ai::is_on(&own));
+    horizon_core::no_ai::set(&main, false).unwrap();
+    follow_player(&main, &own);
+    assert!(!horizon_core::no_ai::is_on(&own));
+    fs::remove_dir_all(&root).unwrap();
+}
+
+#[test]
+fn icons_are_a_texture_name_or_a_colour() {
+    assert_eq!(Icon::parse("#3FA7D6"), Ok(Icon::Colour("#3fa7d6".into())));
+    assert_eq!(
+        Icon::parse("grass_block"),
+        Ok(Icon::Texture("grass_block".into()))
+    );
+    for bad in ["#12345", "../x", "Grass", "", "#zzzzzz"] {
+        assert!(Icon::parse(bad).is_err(), "{bad}");
+    }
+    let root = scratch("icon");
+    put(
+        &root.join("assets/minecraft/textures/item/diamond.png"),
+        "png",
+    );
+    let diamond = Icon::Texture("diamond".into()).texture(&root).unwrap();
+    assert!(diamond.ends_with("item/diamond.png"));
+    assert_eq!(Icon::Texture("stone".into()).texture(&root), None);
+    fs::remove_dir_all(&root).unwrap();
+}
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index 3cba3ed10..f1779c332 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -7,6 +7,7 @@ pub mod desktop;
 #[cfg(unix)]
 pub mod game_app;
 pub mod heads;
+pub mod instances;
 pub mod modpacks;
 pub mod mojang;
 pub mod process;
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 7cc6d0ccd..4003f5725 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -33,6 +33,7 @@ use gpui::{
 };
 use horizon_launcher::account::{self, Accounts, SignIn, SignInState};
 use horizon_launcher::backend::{self, Job, Msg, Release, Running, Settings, Updates};
+use horizon_launcher::instances;
 use horizon_launcher::telemetry;
 use scrollbar::Scrollbar;
 use std::borrow::Cow;
@@ -535,13 +536,16 @@ impl Launcher {
                             Err(e) => self.client_error = Some(format!("Playing offline: {e}")),
                         }
                         self.accounts = Accounts::load();
-                        if let Some(work) = self.starting_pack.take() {
-                            if let Err(e) =
+                        // A pack's Play button plays that pack; Play plays the selected instance.
+                        let profile = match self.starting_pack.take() {
+                            Some(work) => {
                                 horizon_launcher::modpacks::apply_profile(&mut cmd, &work)
-                            {
-                                self.client_error = Some(e);
-                                continue;
                             }
+                            None => instances::apply(&mut cmd, &instances::selected()),
+                        };
+                        if let Err(e) = profile {
+                            self.client_error = Some(e);
+                            continue;
                         }
                         if let Some(code) = self.joining.take() {
                             if let Err(e) = backend::join_friend(&mut cmd, &code) {
@@ -668,10 +672,12 @@ impl Launcher {
                         }
                         Job::Client => {
                             self.client = None;
+                            // The run's own game folder: an instance's or a pack's keeps its reports.
+                            let home = self.client_home.clone().unwrap_or_else(backend::game_home);
                             let report = self
                                 .client_started
                                 .take()
-                                .and_then(backend::crash_report_since);
+                                .and_then(|since| backend::crash_report_since(&home, since));
                             if error.is_some() && report.is_none() && self.switched_to_dx12() {
                                 self.client_error = Some(
                                     "Horizon's Vulkan renderer crashed while starting on this \
diff --git a/launcher/src/mcp.rs b/launcher/src/mcp.rs
index 8aff5aa13..cb4636429 100644
--- a/launcher/src/mcp.rs
+++ b/launcher/src/mcp.rs
@@ -6,6 +6,7 @@ use crate::cli_tools;
 use crate::game_tools::{self, GameTools};
 use horizon_launcher::account::{self, Accounts, SignIn, SignInState};
 use horizon_launcher::backend::{self, Job, Logged};
+use horizon_launcher::instances;
 use serde_json::{json, Value};
 use std::io::{BufRead, Write};
 use std::path::PathBuf;
@@ -29,6 +30,7 @@ fn session_tools() -> Value {
     json!([
         { "name": "play", "description": "Start the Horizon client (a game window on the player's screen) under agent control: the game_* tools then play it. Returns once it has started; game_wait_ready waits for the world. CLI: horizon-launcher play",
           "inputSchema": { "type": "object", "properties": { "version": version,
+            "instance": { "type": "string", "description": "The instance to play, by name or id (instance_list). Default: the selected one." },
             "world": { "type": "string", "description": "Open or create this world (a folder under saves) at once." },
             "creative": { "type": "boolean", "description": "Creative mode for a new world." },
             "join": { "type": "string", "description": "Join a friend's world with its invite code. Only when the player asks." },
@@ -68,6 +70,11 @@ impl Session {
                 }
                 let tag = backend::resolve_version(arg_str(args, "version"))?;
                 let mut cmd = backend::client(&tag)?;
+                let instance = match arg_str(args, "instance") {
+                    Some(name) => instances::find(name)?,
+                    None => instances::selected(),
+                };
+                instances::apply(&mut cmd, &instance)?;
                 cmd.args(game_tools::control_args());
                 if let Some(world) = arg_str(args, "world") {
                     cmd.arg("--world").arg(world);
diff --git a/launcher/src/modpacks.rs b/launcher/src/modpacks.rs
index acd8241a5..3b8e9451f 100644
--- a/launcher/src/modpacks.rs
+++ b/launcher/src/modpacks.rs
@@ -135,7 +135,11 @@ pub fn load(work: &Path) -> Result<Imported, String> {
 
 /// Every imported pack, by name.
 pub fn list() -> Vec<Imported> {
-    let mut packs: Vec<Imported> = fs::read_dir(ports_dir())
+    list_in(&ports_dir())
+}
+
+pub(crate) fn list_in(ports: &Path) -> Vec<Imported> {
+    let mut packs: Vec<Imported> = fs::read_dir(ports)
         .into_iter()
         .flatten()
         .flatten()

From 6087b01f667ec9ca453b95fee6ae2658eb67fc9c Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:21:06 +0100
Subject: [PATCH 391/475] test_friends: put the guest on cleared, flat ground
 before it walks

Since #2501 a player new to the world spawns at a random free spot near the
world spawn, as vanilla's PlayerSpawnFinder does. The guest often stood against
a hill, so walking forward moved it less than a block, or terrain hid the block
it had to aim at: friends_integration failed on every run on the Mac mini.

The host now clears a floor beside itself and teleports the guest there before
the movement checks, and the block check waits for the guest to stand still.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tools/test_friends.py | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/tools/test_friends.py b/tools/test_friends.py
index fd3d626a9..763b0b220 100644
--- a/tools/test_friends.py
+++ b/tools/test_friends.py
@@ -137,6 +137,24 @@ def guest_pos(host, name):
     return next(g['position'] for g in guests if g['name'] == name)
 
 
+def open_ground(host, guest, name):
+    """Puts the guest on a cleared, flat floor beside the host and returns where it stands.
+
+    A player new to the world spawns at a random free spot near the world spawn, as in vanilla
+    (`PlayerSpawnFinder`), often against a hill: walking and aiming need known, open ground.
+    Commands, not the control socket: the server has the last word on where the guest stands.
+    """
+    hp = host('status')['player']['position']
+    x, y, z = math.floor(hp[0]) - 6, math.floor(hp[1]), math.floor(hp[2])
+    host(f'command fill {x - 2} {y - 1} {z - 2} {x + 4} {y - 1} {z + 8} minecraft:stone')
+    host(f'command fill {x - 2} {y} {z - 2} {x + 4} {y + 3} {z + 8} minecraft:air')
+    spot = [x + 0.5, float(y), z + 0.5]
+    host(f'command tp {name} {spot[0]} {spot[1]} {spot[2]} 0 0')
+    guest.wait('status', lambda v: math.dist(v['player']['position'], spot) < 0.01 and v['player']['on_ground'], 20,
+               'the guest on its ground')
+    return spot
+
+
 def play_together(host, guest, name, round_index):
     """Chat, movement and blocks seen from both sides."""
     host.wait('lan status', lambda v: any(g['name'] == name and g['placed'] for g in v['guests']), 60,
@@ -150,6 +168,7 @@ def play_together(host, guest, name, round_index):
     guest.wait('status', lambda v: any(f'hello from the host {round_index}' in l for l in v['server']['chat']), 30,
                'host chat on the guest')
     # The guest walks; the host sees it move.
+    open_ground(host, guest, name)
     before = guest_pos(host, name)
     guest('look 0 0')
     guest('key w down')
@@ -167,7 +186,8 @@ def play_together(host, guest, name, round_index):
     guest.wait('status', lambda v: any(math.dist(p, target) < 0.6 for p in v['server']['player_positions']), 20,
                'host movement on the guest')
     # A block the host places, which the guest sees and then breaks.
-    gp = guest('status')['player']['position']
+    gp = guest.wait('status', lambda v: v['player']['on_ground'] and math.hypot(v['player']['velocity'][0],
+                    v['player']['velocity'][2]) < 1e-3, 10, 'the guest standing still')['player']['position']
     feet = [math.floor(gp[0]), math.floor(gp[1]), math.floor(gp[2])]
     block = [feet[0] + 2, feet[1] + 1, feet[2]]
     # Clear the line of sight (the test terrain has hills), then the block at eye level.

From a76456b036df5f1e654dec863a8b5116c6e945e2 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:21:56 +0100
Subject: [PATCH 392/475] Launcher: instances in the sidebar, and a dialog to
 make and edit them

The sidebar lists the instances by group with their icons (a texture from the
player's prepared files, drawn as pixels, or a colour); clicking one selects it
for Play. + makes one, empty or a copy of the selected one (copied in the
background); Home's Instance row edits its name, group and icon, copies it, and
opens its folder. The dialog's name and group are the launcher's shared text
fields.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 launcher/README.md             |   4 +-
 launcher/src/instances_page.rs | 583 +++++++++++++++++++++++++++++++++
 launcher/src/main.rs           |  90 ++---
 launcher/src/modpacks_page.rs  |   1 +
 launcher/src/servers_page.rs   |  14 +-
 5 files changed, 621 insertions(+), 71 deletions(-)
 create mode 100644 launcher/src/instances_page.rs

diff --git a/launcher/README.md b/launcher/README.md
index 89df726d1..50ca6829c 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -76,7 +76,9 @@ The opening, then Play ([clip](docs/opening.webm)):
   sign-in sessions, logs or data collection state). Names, icons (a block or item texture from the
   player's prepared files, or a colour) and groups are kept in `instances.json` in the launcher's
   data folder, so renaming moves nothing. Every instance follows the launcher's data collection
-  answer and No AI.
+  answer and No AI. In the window, **+** beside Instances makes one, the sidebar lists them by
+  group (click one to play it), and Home's Instance row has Edit (name, group, icon), Copy and
+  Open folder.
 - **Patch notes**: each release's notes, newest first, with a link to GitHub Sponsors. Quiet "Discord" and "Website" links sit in the footer.
 
 Data lives in the platform's data directory (`~/.local/share/horizon-launcher` on Linux,
diff --git a/launcher/src/instances_page.rs b/launcher/src/instances_page.rs
new file mode 100644
index 000000000..ce6c1d42e
--- /dev/null
+++ b/launcher/src/instances_page.rs
@@ -0,0 +1,583 @@
+//! Instances in the window (`horizon_launcher::instances`): the sidebar's list, by group, and the
+//! dialog that makes one (empty, or a copy of the selected one) or changes its name, group and
+//! icon.
+use super::*;
+use gpui::RenderImage;
+use horizon_launcher::instances::{self, Icon, Instance, Kind as InstanceKind};
+use servers_page::Field;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+/// Textures offered as icons, when the player's prepared files hold them: block faces and items
+/// that read well at sidebar size.
+const TEXTURES: [&str; 24] = [
+    "grass_block_side",
+    "oak_planks",
+    "oak_log",
+    "cobblestone",
+    "bricks",
+    "bookshelf",
+    "crafting_table_front",
+    "tnt_side",
+    "sand",
+    "snow",
+    "ice",
+    "obsidian",
+    "netherrack",
+    "end_stone",
+    "glowstone",
+    "diamond_ore",
+    "diamond",
+    "emerald",
+    "apple",
+    "ender_pearl",
+    "iron_pickaxe",
+    "diamond_sword",
+    "bow",
+    "book",
+];
+
+/// Colours offered as icons: Horizon's accent and a few that sit beside it in both themes.
+const COLOURS: [&str; 8] = [
+    "#5b3fd6", "#3f7fd6", "#2f9e8f", "#4f9e2f", "#c9a227", "#d9732f", "#c4405a", "#7d7591",
+];
+
+/// The dialog: a new instance (`editing` None) or one being changed. Its name and group are the
+/// text fields `Field::InstanceName` and `Field::InstanceGroup`.
+pub(super) struct InstanceDialog {
+    editing: Option<String>,
+    /// A new instance copies the selected one's worlds, options and packs.
+    copy: bool,
+    icon: Option<Icon>,
+    error: Option<String>,
+    busy: bool,
+}
+
+/// The instances and their icons as images, kept between frames.
+#[derive(Default)]
+pub(super) struct Instances {
+    pub(super) list: Vec<Instance>,
+    pub(super) dialog: Option<InstanceDialog>,
+    icons: HashMap<(String, u32), Option<Arc<RenderImage>>>,
+}
+
+impl Launcher {
+    pub(super) fn reload_instances(&mut self) {
+        self.instances.list = instances::list();
+    }
+
+    /// The instance Play starts.
+    pub(super) fn selected_instance(&self) -> Option<&Instance> {
+        let id = self
+            .settings
+            .instance
+            .as_deref()
+            .unwrap_or(instances::DEFAULT);
+        let list = &self.instances.list;
+        list.iter().find(|i| i.id == id).or(list.first())
+    }
+
+    fn select_instance(&mut self, instance: &Instance) {
+        self.settings.instance =
+            (instance.kind != InstanceKind::Default).then(|| instance.id.clone());
+        self.settings.save();
+    }
+
+    /// A texture from the selected version's prepared files, its first frame, drawn as pixels.
+    fn texture_image(&mut self, name: &str, size: f32) -> Option<Arc<RenderImage>> {
+        let tag = self.selected().filter(|t| backend::is_prepared(t))?.clone();
+        let scale = self.scale;
+        self.instances
+            .icons
+            .entry((name.to_string(), (size * scale) as u32))
+            .or_insert_with(|| {
+                let path = Icon::Texture(name.into()).texture(&backend::resources(&tag))?;
+                let png = image::open(path).ok()?.to_rgba8();
+                let w = png.width() as usize;
+                // An animated texture is its frames one under another: the first is square.
+                let texels: Vec<[u8; 4]> = png.pixels().take(w * w).map(|p| p.0).collect();
+                Some(art::bake(&texels, w, w, size / w as f32, scale))
+            })
+            .clone()
+    }
+
+    /// An instance's icon, `size` points square.
+    pub(super) fn instance_icon(&mut self, instance: &Instance, size: f32) -> AnyElement {
+        let t = self.theme;
+        let framed = |d: Div| {
+            d.flex()
+                .flex_none()
+                .items_center()
+                .justify_center()
+                .size(px(size))
+                .border_2()
+                .border_color(t.outline)
+        };
+        match &instance.icon {
+            Some(Icon::Colour(hex)) => {
+                let rgb = u32::from_str_radix(&hex[1..], 16).unwrap_or(0);
+                return framed(div().bg(gpui::rgb(rgb)))
+                    .child(
+                        blocks::pixel((size * 0.42).round(), FontWeight::BOLD)
+                            .text_color(gpui::white())
+                            .child(initial(&instance.name)),
+                    )
+                    .into_any_element();
+            }
+            Some(Icon::Texture(name)) => {
+                if let Some(image) = self.texture_image(name, size - 8.) {
+                    return framed(div().bg(t.well))
+                        .child(gpui::img(image).size(px(size - 8.)))
+                        .into_any_element();
+                }
+            }
+            None if instance.kind == InstanceKind::Default => {
+                if let Some(grass) = self.vanilla_icon() {
+                    return div()
+                        .flex()
+                        .items_center()
+                        .justify_center()
+                        .size(px(size))
+                        .child(gpui::img(grass).size(px(size - 4.)))
+                        .into_any_element();
+                }
+            }
+            None => {}
+        }
+        blocks::slot(None, &instance.name, size, &t).into_any_element()
+    }
+
+    /// The sidebar's instances: those without a group, then each group under its name.
+    pub(super) fn instance_items(
+        &mut self,
+        heading: impl Fn(String) -> Div,
+        cx: &mut Context<Self>,
+    ) -> Vec<AnyElement> {
+        let t = self.theme;
+        let tag = self.selected().cloned();
+        let prepared = tag.as_deref().is_some_and(backend::is_prepared);
+        let status = if tag.is_none() {
+            "No version installed"
+        } else if prepared {
+            "Ready"
+        } else {
+            "Needs preparing"
+        };
+        let selected = self.selected_instance().map(|i| i.id.clone());
+        let on_packs = self.page == Page::Mods && self.mods.on_modpacks();
+        let mut out = Vec::new();
+        let mut group = None;
+        for i in self.instances.list.clone() {
+            if i.group != group {
+                group = i.group.clone();
+                if let Some(g) = &group {
+                    out.push(heading(g.to_uppercase()).into_any_element());
+                }
+            }
+            let (open, sub) = match i.kind {
+                InstanceKind::Default | InstanceKind::Own => (
+                    self.page == Page::Play && selected.as_ref() == Some(&i.id),
+                    status.to_string(),
+                ),
+                InstanceKind::Port => {
+                    let slug = &i.id["port:".len()..];
+                    let summary = self.packs.iter().find(|p| p.slug == slug);
+                    (
+                        on_packs && self.pack_open.as_deref() == Some(slug),
+                        summary.map_or_else(|| "Modpack".into(), |p| p.summary()),
+                    )
+                }
+                InstanceKind::Pack => (false, "From Horizon's registry".into()),
+            };
+            let dot = matches!(i.kind, InstanceKind::Default | InstanceKind::Own).then(|| {
+                div()
+                    .absolute()
+                    .left(px(42.))
+                    .top(px(42.))
+                    .size(px(10.))
+                    .bg(if prepared { t.success } else { t.warn })
+                    .border_2()
+                    .border_color(t.side)
+            });
+            let icon = self.instance_icon(&i, 44.);
+            let clicked = i.clone();
+            out.push(
+                blocks::side_item(format!("side-instance-{}", i.id).into(), open, &t)
+                    .child(icon)
+                    .children(dot)
+                    .child(
+                        div()
+                            .flex()
+                            .flex_col()
+                            .min_w_0()
+                            .child(
+                                blocks::pixel(15., FontWeight::MEDIUM)
+                                    .text_color(t.ink)
+                                    .truncate()
+                                    .child(i.name.clone()),
+                            )
+                            .child(
+                                text(theme::CAPTION)
+                                    .text_color(t.muted)
+                                    .truncate()
+                                    .child(sub),
+                            ),
+                    )
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        match clicked.kind {
+                            InstanceKind::Default | InstanceKind::Own => {
+                                this.select_instance(&clicked);
+                                this.go(Page::Play);
+                            }
+                            InstanceKind::Port => {
+                                this.show_modpack(Some(clicked.id["port:".len()..].into()))
+                            }
+                            InstanceKind::Pack => this.show_modpack(None),
+                        }
+                        cx.notify();
+                    }))
+                    .into_any_element(),
+            );
+        }
+        out
+    }
+
+    /// Opens the dialog for a new instance, or for changing `editing`.
+    pub(super) fn open_instance_dialog(&mut self, editing: Option<Instance>) {
+        let (name, group) = editing
+            .as_ref()
+            .map(|i| (i.name.clone(), i.group.clone().unwrap_or_default()))
+            .unwrap_or_default();
+        *self.servers.text(Field::InstanceName) = name;
+        *self.servers.text(Field::InstanceGroup) = group;
+        self.servers.focus_soon = Some(Field::InstanceName);
+        self.instances.dialog = Some(InstanceDialog {
+            icon: editing.as_ref().and_then(|i| i.icon.clone()),
+            editing: editing.map(|i| i.id),
+            copy: false,
+            error: None,
+            busy: false,
+        });
+    }
+
+    /// Escape closes the dialog. Whether it did.
+    pub(super) fn instance_escape(&mut self) -> bool {
+        if self.instances.dialog.as_ref().is_some_and(|d| !d.busy) {
+            self.instances.dialog = None;
+            return true;
+        }
+        false
+    }
+
+    /// Creates or changes the instance as the dialog says. A copy can be gigabytes of worlds, so
+    /// the work runs in the background.
+    pub(super) fn save_instance(&mut self, cx: &mut Context<Self>) {
+        let selected = self.selected_instance().map(|i| i.id.clone());
+        let name = self.servers.value(Field::InstanceName).trim().to_string();
+        let group = Some(self.servers.value(Field::InstanceGroup).to_string());
+        let Some(d) = self.instances.dialog.as_mut().filter(|d| !d.busy) else {
+            return;
+        };
+        let icon = d.icon.clone();
+        let editing = d.editing.clone();
+        let copy = selected.filter(|_| d.copy);
+        d.busy = true;
+        d.error = None;
+        let task = cx.background_executor().spawn(async move {
+            let id = match editing {
+                Some(id) => id,
+                None => instances::create(&name, copy.as_deref())?.id,
+            };
+            instances::edit(&id, |m| {
+                m.name = Some(name);
+                m.group = group;
+                m.icon = icon;
+            })
+        });
+        cx.spawn(async move |this, cx| {
+            let result = task.await;
+            let _ = this.update(cx, |this, cx| {
+                match result {
+                    Ok(instance) => {
+                        this.instances.dialog = None;
+                        this.select_instance(&instance);
+                        this.reload_instances();
+                        if matches!(instance.kind, InstanceKind::Default | InstanceKind::Own) {
+                            this.go(Page::Play);
+                        }
+                    }
+                    Err(e) => {
+                        if let Some(d) = &mut this.instances.dialog {
+                            d.busy = false;
+                            d.error = Some(e);
+                        }
+                    }
+                }
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    pub(super) fn instance_dialog(&mut self, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
+        let t = self.theme;
+        let d = self.instances.dialog.as_ref()?;
+        let (editing, copy, icon, error, busy) = (
+            d.editing.is_some(),
+            d.copy,
+            d.icon.clone(),
+            d.error.clone(),
+            d.busy,
+        );
+        let from = self
+            .selected_instance()
+            .map_or_else(|| "Horizon".into(), |i| i.name.clone());
+        let row = |label: &'static str, control: AnyElement| {
+            div()
+                .flex()
+                .flex_col()
+                .gap(px(8.))
+                .child(caps(label).text_color(t.muted))
+                .child(control)
+        };
+        let mut body = div()
+            .flex()
+            .flex_col()
+            .gap(px(20.))
+            .p(px(24.))
+            .child(
+                blocks::pixel(22., FontWeight::MEDIUM)
+                    .text_color(t.ink)
+                    .child(if editing {
+                        "Edit instance"
+                    } else {
+                        "New instance"
+                    }),
+            )
+            .child(row(
+                "Name",
+                self.field(Field::InstanceName, "My instance", 400., cx)
+                    .into_any_element(),
+            ));
+        if !editing {
+            let weak = cx.entity().downgrade();
+            body = body.child(row(
+                "Start from",
+                segments(
+                    "instance-from",
+                    &[(false, "Empty"), (true, "A copy of the selected one")],
+                    copy,
+                    &t,
+                    move |copy, _, cx| {
+                        let _ = weak.update(cx, |this, cx| {
+                            if let Some(d) = &mut this.instances.dialog {
+                                d.copy = copy;
+                            }
+                            cx.notify();
+                        });
+                    },
+                )
+                .into_any_element(),
+            ));
+            body = body.child(text(theme::CAPTION).text_color(t.muted).child(if copy {
+                format!("{from}'s worlds, options and packs are copied; {from} stays as it is.")
+            } else {
+                "Its own worlds and packs; your options and player name come along.".to_string()
+            }));
+        }
+        body = body.child(row(
+            "Group",
+            self.field(Field::InstanceGroup, "No group", 400., cx)
+                .into_any_element(),
+        ));
+        let mut tiles = div().flex().flex_wrap().gap(px(6.));
+        let tile = |id: String, chosen: bool| {
+            div()
+                .id(SharedString::from(id))
+                .flex()
+                .items_center()
+                .justify_center()
+                .size(px(40.))
+                .border_2()
+                .border_color(if chosen { t.accent } else { t.rule })
+                .cursor_pointer()
+                .hover(move |s| s.border_color(t.outline))
+        };
+        let none = icon.is_none();
+        tiles = tiles.child(
+            tile("instance-icon-none".into(), none)
+                .child(text(theme::MICRO).text_color(t.muted).child("NONE"))
+                .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                    if let Some(d) = &mut this.instances.dialog {
+                        d.icon = None;
+                    }
+                    cx.notify();
+                })),
+        );
+        for name in TEXTURES {
+            let Some(image) = self.texture_image(name, 28.) else {
+                continue;
+            };
+            let chosen = icon == Some(Icon::Texture(name.into()));
+            tiles = tiles.child(
+                tile(format!("instance-icon-{name}"), chosen)
+                    .bg(t.well)
+                    .child(gpui::img(image).size(px(28.)))
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        if let Some(d) = &mut this.instances.dialog {
+                            d.icon = Some(Icon::Texture(name.into()));
+                        }
+                        cx.notify();
+                    })),
+            );
+        }
+        for hex in COLOURS {
+            let chosen = icon == Some(Icon::Colour(hex.into()));
+            let rgb = u32::from_str_radix(&hex[1..], 16).unwrap_or(0);
+            tiles = tiles.child(
+                tile(format!("instance-icon-{hex}"), chosen)
+                    .child(div().size(px(28.)).bg(gpui::rgb(rgb)))
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        if let Some(d) = &mut this.instances.dialog {
+                            d.icon = Some(Icon::Colour(hex.into()));
+                        }
+                        cx.notify();
+                    })),
+            );
+        }
+        body = body.child(row("Icon", tiles.into_any_element()));
+        if self.selected().is_none_or(|t| !backend::is_prepared(t)) {
+            body = body.child(
+                text(theme::CAPTION)
+                    .text_color(t.muted)
+                    .child("Block and item icons come from your prepared game files: prepare a version to see them."),
+            );
+        }
+        if let Some(e) = error {
+            body = body.child(text(theme::CAPTION).text_color(t.danger).child(e));
+        }
+        let cancel = button("instance-cancel", "Cancel", Kind::Secondary, &t);
+        let label = match (editing, busy, copy) {
+            (_, true, true) => "Copying…",
+            (true, false, _) => "Save",
+            _ => "Create",
+        };
+        let save = button("instance-save", label, Kind::Primary, &t);
+        // A modpack becomes an instance by being imported, on the Mods page.
+        let import = (!editing && !busy).then(|| {
+            button("instance-import", "Import a modpack…", Kind::Ghost, &t)
+                .mr_auto()
+                .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                    this.instances.dialog = None;
+                    this.show_modpack(None);
+                    cx.notify();
+                }))
+        });
+        let foot = div()
+            .flex()
+            .justify_end()
+            .gap(px(8.))
+            .px(px(24.))
+            .py(px(16.))
+            .border_t_1()
+            .border_color(t.rule)
+            .children(import);
+        let foot = if busy {
+            foot.child(disabled(cancel)).child(disabled(save))
+        } else {
+            foot.child(cancel.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                this.instances.dialog = None;
+                cx.notify();
+            })))
+            .child(save.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                this.save_instance(cx);
+                cx.notify();
+            })))
+        };
+        let card = plate(&t)
+            .flex()
+            .flex_col()
+            .w_full()
+            .max_w(px(560.))
+            .bg(t.page)
+            .border_1()
+            .border_color(t.rule)
+            .child(body)
+            .child(foot);
+        Some(
+            div()
+                .id("instance-dialog")
+                .absolute()
+                .top_0()
+                .left_0()
+                .size_full()
+                .flex()
+                .flex_col()
+                .items_center()
+                .px(px(32.))
+                .py(px(24.))
+                .bg(t.page.opacity(0.92))
+                .on_scroll_wheel(|_, _, cx| cx.stop_propagation())
+                .occlude()
+                .child(card),
+        )
+    }
+
+    /// The Play page's row for the selected instance: its folder, and changing or copying it.
+    pub(super) fn instance_row(&mut self, n: usize, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let instance = self.selected_instance()?.clone();
+        let (home, edit, name) = (
+            instance.home.clone(),
+            instance.clone(),
+            instance.name.clone(),
+        );
+        let actions = div()
+            .flex()
+            .gap(px(8.))
+            .child(
+                button("instance-edit", "Edit…", Kind::Ghost, &t).on_click(cx.listener(
+                    move |this, _: &ClickEvent, _, cx| {
+                        this.open_instance_dialog(Some(edit.clone()));
+                        cx.notify();
+                    },
+                )),
+            )
+            .child(
+                button("instance-copy", "Copy…", Kind::Ghost, &t).on_click(cx.listener(
+                    move |this, _: &ClickEvent, _, cx| {
+                        this.open_instance_dialog(None);
+                        *this.servers.text(Field::InstanceName) = format!("{name} copy");
+                        if let Some(d) = &mut this.instances.dialog {
+                            d.copy = true;
+                        }
+                        cx.notify();
+                    },
+                )),
+            )
+            .child(
+                button("instance-folder", "Open folder", Kind::Ghost, &t).on_click(
+                    move |_, _, cx| {
+                        let _ = std::fs::create_dir_all(&home);
+                        cx.open_with_system(&home);
+                    },
+                ),
+            );
+        Some(index_row(
+            n,
+            "Instance",
+            Some(div().child(instance.name.clone()).into_any_element()),
+            Some(actions.into_any_element()),
+            &t,
+        ))
+    }
+}
+
+/// The first letter or digit of a name, for an icon without a picture.
+fn initial(name: &str) -> String {
+    name.chars()
+        .find(|c| c.is_alphanumeric())
+        .unwrap_or('?')
+        .to_uppercase()
+        .to_string()
+}
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 4003f5725..b9f556d69 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -12,6 +12,7 @@ mod collection;
 mod console;
 mod cull;
 mod game_tools;
+mod instances_page;
 mod internet;
 mod markdown;
 mod mcp;
@@ -223,6 +224,8 @@ struct Launcher {
     starting_pack: Option<std::path::PathBuf>,
     /// The Mods page: the browser's search, installs and updates (`mods_page.rs`).
     mods: mods_page::Mods,
+    /// The instances, for the sidebar and Play, and their dialog (`instances_page.rs`).
+    instances: instances_page::Instances,
     /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar.
     offline_name: Option<String>,
     /// The player's servers, for the sidebar until the Servers page has read them.
@@ -379,11 +382,13 @@ impl Launcher {
             pack_error: None,
             starting_pack: None,
             mods: mods_page::Mods::new(cx),
+            instances: instances_page::Instances::default(),
             offline_name: offline_name(),
             side_servers: horizon_launcher::servers::list(),
             art: art::Art::default(),
             scale: window.scale_factor(),
         };
+        this.reload_instances();
         if this.bench.is_some() {
             this.perf.keep_local_log(false);
         }
@@ -1575,7 +1580,7 @@ impl Launcher {
     fn sidebar(&mut self, cx: &mut Context<Self>) -> Stateful<Div> {
         let t = self.theme;
         self.load_packs();
-        let heading = |label: &'static str| {
+        let heading = |label: String| {
             div()
                 .flex()
                 .items_center()
@@ -1606,7 +1611,7 @@ impl Launcher {
                 .border_2()
                 .border_color(t.side)
         };
-        let add = keyboard(div().id("add-pack"), &t)
+        let add = keyboard(div().id("add-instance"), &t)
             .flex()
             .items_center()
             .justify_center()
@@ -1618,79 +1623,23 @@ impl Launcher {
             .hover(move |s| s.bg(t.raised))
             .child(blocks::icon("plus", 14., t.ink_soft))
             .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
-                this.show_modpack(None);
+                this.open_instance_dialog(None);
                 cx.notify();
             }));
-        let mut list = div()
+        let list = div()
             .flex()
             .flex_col()
             .gap(px(4.))
-            .child(heading("INSTANCES").child(add));
-        // Horizon itself, with a grass block from the player's own prepared files.
-        let tag = self.selected().cloned();
-        let prepared = tag.as_deref().is_some_and(backend::is_prepared);
-        let grass = self.vanilla_icon();
-        let on_play = self.page == Page::Play;
-        list = list.child(
-            blocks::side_item("side-horizon".into(), on_play, &t)
-                .child(match grass {
-                    Some(g) => div()
-                        .flex()
-                        .items_center()
-                        .justify_center()
-                        .size(px(44.))
-                        .child(gpui::img(g).size(px(40.))),
-                    None => blocks::slot(None, "Horizon", 44., &t),
-                })
-                .child(dot(if prepared { t.success } else { t.warn }))
-                .child(
-                    div()
-                        .flex()
-                        .flex_col()
-                        .min_w_0()
-                        .child(title("Horizon".into()))
-                        .child(sub(if tag.is_none() {
-                            "No version installed"
-                        } else if prepared {
-                            "Vanilla · ready"
-                        } else {
-                            "Needs preparing"
-                        }
-                        .into())),
-                )
-                .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
-                    this.go(Page::Play);
-                    cx.notify();
-                })),
-        );
-        let on_packs = self.page == Page::Mods && self.mods.on_modpacks();
-        for p in &self.packs {
-            let slug = p.slug.clone();
-            let open = on_packs && self.pack_open.as_ref() == Some(&p.slug);
-            list = list.child(
-                blocks::side_item(format!("side-pack-{slug}").into(), open, &t)
-                    .child(blocks::slot(None, p.title(), 44., &t))
-                    .child(
-                        div()
-                            .flex()
-                            .flex_col()
-                            .min_w_0()
-                            .child(title(p.title().to_string()))
-                            .child(sub(p.summary())),
-                    )
-                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
-                        this.show_modpack(Some(slug.clone()));
-                        cx.notify();
-                    })),
-            );
-        }
+            .child(heading("INSTANCES".into()).child(add))
+            .children(self.instance_items(heading, cx));
         let servers: Vec<_> = self
             .servers
             .sidebar_list()
             .map(<[_]>::to_vec)
             .unwrap_or_else(|| self.side_servers.clone());
+        let mut list = list;
         if !servers.is_empty() {
-            list = list.child(heading("SERVERS"));
+            list = list.child(heading("SERVERS".into()));
         }
         for e in servers {
             let up = self.servers.is_up(&e.dir);
@@ -2074,15 +2023,16 @@ impl Launcher {
             .flex()
             .flex_col()
             .child(section_title("Ready to play", "check", &t).mb(px(12.)))
+            .children(self.instance_row(1, cx))
             .child(index_row(
-                1,
+                2,
                 "Resources",
                 Some(div().child(resources_value).into_any_element()),
                 Some(prepare.into_any_element()),
                 &t,
             ))
             .child(index_row(
-                2,
+                3,
                 "Minecraft folder",
                 Some(minecraft),
                 Some(
@@ -2098,7 +2048,7 @@ impl Launcher {
             // offline, in a build that can sign in.
             if self.accounts.selected().is_none() && account::client_id().is_some() {
                 rows = rows.child(index_row(
-                    4,
+                    5,
                     "Playing offline",
                     Some(
                         div()
@@ -3064,7 +3014,7 @@ impl Launcher {
             join = disabled(join);
         }
         index_row(
-            3,
+            4,
             "Join a friend",
             Some(
                 div()
@@ -3523,6 +3473,7 @@ impl Render for Launcher {
                         }
                     }
                     "escape" if this.servers_escape() => {}
+                    "escape" if this.instance_escape() => {}
                     _ => return,
                 }
                 cx.stop_propagation();
@@ -3583,6 +3534,9 @@ impl Render for Launcher {
                 root = root.child(dialog);
             }
         }
+        if let Some(dialog) = self.instance_dialog(cx) {
+            root = root.child(dialog);
+        }
         if self.asking_consent() {
             root = root.child(self.consent_screen(cx));
         }
diff --git a/launcher/src/modpacks_page.rs b/launcher/src/modpacks_page.rs
index 25df3966f..2f10b2773 100644
--- a/launcher/src/modpacks_page.rs
+++ b/launcher/src/modpacks_page.rs
@@ -132,6 +132,7 @@ impl Launcher {
             self.mods.report_list.reset();
             self.packs = modpacks::list();
             self.registry_packs = horizon_pack::list();
+            self.reload_instances();
             if self.pack_open.is_none() {
                 self.pack_open = self.packs.first().map(|p| p.slug.clone());
             }
diff --git a/launcher/src/servers_page.rs b/launcher/src/servers_page.rs
index 0a5618768..0237f34f9 100644
--- a/launcher/src/servers_page.rs
+++ b/launcher/src/servers_page.rs
@@ -32,10 +32,13 @@ pub(super) enum Field {
     Port,
     Token,
     Email,
+    /// The instance dialog's (`instances_page.rs`).
+    InstanceName,
+    InstanceGroup,
 }
 
 impl Field {
-    const ALL: [Field; 9] = [
+    const ALL: [Field; 11] = [
         Field::Name,
         Field::Seed,
         Field::Players,
@@ -45,6 +48,8 @@ impl Field {
         Field::Port,
         Field::Token,
         Field::Email,
+        Field::InstanceName,
+        Field::InstanceGroup,
     ];
 }
 
@@ -163,7 +168,7 @@ pub(super) struct Servers {
     focus: HashMap<Field, FocusHandle>,
     focused: Option<Field>,
     /// The field to put the keyboard in on the next frame.
-    focus_soon: Option<Field>,
+    pub(super) focus_soon: Option<Field>,
     /// A suggested value shown selected: the first key typed replaces it.
     selected: Option<Field>,
     /// A field whose value was refused, and why: shown under it until it's edited.
@@ -961,11 +966,15 @@ impl Launcher {
                     command,
                 );
                 match typed {
+                    Key::Enter if matches!(f, Field::InstanceName | Field::InstanceGroup) => {
+                        this.save_instance(cx)
+                    }
                     Key::Enter => this.field_enter(f),
                     Key::Escape => {
                         if this.servers.create.is_some() && !this.servers.creating {
                             this.servers.create = None;
                         }
+                        this.instance_escape();
                         window.blur();
                     }
                     Key::Paste => {
@@ -1017,6 +1026,7 @@ impl Launcher {
             Field::Port => self.save_port(),
             Field::Token => self.save_token(),
             Field::Email => self.invite_friend(),
+            Field::InstanceName | Field::InstanceGroup => {}
         }
     }
 

From 90f27552459e7868afad4a8527149eb790db6c0c Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:25:31 +0100
Subject: [PATCH 393/475] Launcher: a Horizon version per instance

An instance plays the launcher's version, which follows updates, unless it is
kept on another installed one: the Play page's picker pins the selected
instance (picking the version marked "follows updates" unpins it), and
`instance version <instance> <tag|latest>` does it from the CLI. play,
`play --instance` and MCP play use the pin; a pack's Play uses its instance's.
The sidebar shows a pinned instance's version, or that it is not installed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md       | 10 +++++++++
 launcher/README.md              |  5 ++++-
 launcher/src/cli.rs             | 19 +++++++++++++++--
 launcher/src/instances.rs       | 24 +++++++++++++++++++++
 launcher/src/instances/tests.rs | 23 ++++++++++++++++++++
 launcher/src/instances_page.rs  | 38 ++++++++++++++++++++++++---------
 launcher/src/main.rs            | 32 +++++++++++++++++++++------
 launcher/src/mcp.rs             |  6 +++---
 launcher/src/modpacks_page.rs   |  8 ++++++-
 9 files changed, 142 insertions(+), 23 deletions(-)

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index e233cc9a9..6faaeed74 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -320,6 +320,16 @@ Make Play start this instance.
 
 MCP: `instance_select`.
 
+## `horizon-launcher instance version`
+
+Keep an instance on one installed Horizon version, or "latest" to follow updates again.
+
+    horizon-launcher instance version <INSTANCE> <VERSION>
+
+- `INSTANCE`
+
+MCP: `instance_version`.
+
 ## `horizon-launcher modpack list`
 
 The imported packs and their coverage (the default).
diff --git a/launcher/README.md b/launcher/README.md
index 50ca6829c..ea4ebc39c 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -78,7 +78,9 @@ The opening, then Play ([clip](docs/opening.webm)):
   data folder, so renaming moves nothing. Every instance follows the launcher's data collection
   answer and No AI. In the window, **+** beside Instances makes one, the sidebar lists them by
   group (click one to play it), and Home's Instance row has Edit (name, group, icon), Copy and
-  Open folder.
+  Open folder. Each instance plays the launcher's version, which follows updates, unless the Play
+  page's version picker keeps it on another installed one (to keep an old world on the version
+  it was made with); picking the version marked "follows updates" lets it follow again.
 - **Patch notes**: each release's notes, newest first, with a link to GitHub Sponsors. Quiet "Discord" and "Website" links sit in the footer.
 
 Data lives in the platform's data directory (`~/.local/share/horizon-launcher` on Linux,
@@ -178,6 +180,7 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
     horizon-launcher instance create <name> [--copy <instance>]   empty, or a copy of one's worlds, options and packs
     horizon-launcher instance rename|icon|group <instance> <value>  icon: a block or item name, #rrggbb or none
     horizon-launcher instance select <instance>     make Play start it
+    horizon-launcher instance version <instance> <tag|latest>   keep it on one installed version, or follow updates
     horizon-launcher modpack [list]                 the imported packs and their coverage
     horizon-launcher modpack import <pack>          a .mrpack, CurseForge zip or instance folder
     horizon-launcher modpack port <pack> [--from <dir>] [--version <tag>]   get the jars and carry them over
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 22a850c02..8addbd191 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -180,6 +180,8 @@ enum InstanceCmd {
     },
     /// Make Play start this instance
     Select { instance: String },
+    /// Keep an instance on one installed Horizon version, or "latest" to follow updates again
+    Version { instance: String, version: String },
 }
 
 #[derive(Subcommand)]
@@ -647,11 +649,11 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
             join,
             arg,
         } => {
-            let mut cmd = backend::client(&backend::resolve_version(version.as_deref())?)?;
             let instance = match instance {
                 Some(name) => instances::find(&name)?,
                 None => instances::selected(),
             };
+            let mut cmd = backend::client(&instance.resolve_version(version.as_deref())?)?;
             instances::apply(&mut cmd, &instance)?;
             if let Some(code) = join {
                 backend::join_friend(&mut cmd, &code)?;
@@ -1385,6 +1387,7 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
         serde_json::json!({
             "id": i.id, "name": i.name, "kind": format!("{:?}", i.kind).to_lowercase(),
             "home": i.home, "icon": i.icon, "group": i.group, "selected": selected,
+            "version": i.version,
         })
     };
     let line = |i: &instances::Instance, selected: bool| {
@@ -1394,8 +1397,13 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
             .as_ref()
             .map(|g| format!("  [{g}]"))
             .unwrap_or_default();
+        let pinned = i
+            .version
+            .as_ref()
+            .map(|v| format!("  {v}"))
+            .unwrap_or_default();
         println!(
-            "{mark} {} ({}){group}\n    {}",
+            "{mark} {} ({}){pinned}{group}\n    {}",
             i.name,
             i.id,
             i.home.display()
@@ -1430,6 +1438,13 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
             changed(instances::edit(&instance, |m| m.group = group)?)
         }
         InstanceCmd::Select { instance } => changed(instances::select(&instance)?),
+        InstanceCmd::Version { instance, version } => {
+            let pin = match version.as_str() {
+                "latest" => None,
+                tag => Some(backend::resolve_version(Some(tag))?),
+            };
+            changed(instances::edit(&instance, |m| m.version = pin)?)
+        }
     }
     Ok(())
 }
diff --git a/launcher/src/instances.rs b/launcher/src/instances.rs
index d2e74dde1..4945ba813 100644
--- a/launcher/src/instances.rs
+++ b/launcher/src/instances.rs
@@ -86,6 +86,10 @@ pub struct Meta {
     pub icon: Option<Icon>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub group: Option<String>,
+    /// The Horizon version this instance plays, kept when newer ones are installed. None: the
+    /// launcher's own version, which follows updates.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
 }
 
 /// `instances.json`: each instance's choices, by id.
@@ -121,6 +125,25 @@ pub struct Instance {
     pub home: PathBuf,
     pub icon: Option<Icon>,
     pub group: Option<String>,
+    /// Its pinned Horizon version, if any (`Meta::version`).
+    pub version: Option<String>,
+}
+
+impl Instance {
+    /// The installed version this instance plays: its pinned one, else `requested` (the
+    /// command line's `--version`) or the launcher's (`backend::resolve_version`).
+    pub fn resolve_version(&self, requested: Option<&str>) -> Result<String, String> {
+        match (requested, &self.version) {
+            (None, Some(pinned)) => backend::resolve_version(Some(pinned)).map_err(|_| {
+                format!(
+                    "{} plays {pinned}, which is not installed: install it, or horizon-launcher \
+                     instance version \"{}\" latest",
+                    self.name, self.name
+                )
+            }),
+            _ => backend::resolve_version(requested),
+        }
+    }
 }
 
 /// The instances, by the default game home and the launcher's data folder: Horizon first, then
@@ -172,6 +195,7 @@ fn list_in(game_home: &Path, data: &Path) -> Vec<Instance> {
                 name: meta.name.unwrap_or(name),
                 icon: meta.icon,
                 group: meta.group,
+                version: meta.version,
                 id,
                 kind,
                 work,
diff --git a/launcher/src/instances/tests.rs b/launcher/src/instances/tests.rs
index 586b620b3..f1c94f5b8 100644
--- a/launcher/src/instances/tests.rs
+++ b/launcher/src/instances/tests.rs
@@ -201,3 +201,26 @@ fn icons_are_a_texture_name_or_a_colour() {
     assert_eq!(Icon::Texture("stone".into()).texture(&root), None);
     fs::remove_dir_all(&root).unwrap();
 }
+
+#[test]
+fn an_instance_keeps_its_own_version_until_it_follows_updates_again() {
+    let root = scratch("version");
+    let (home, data) = (root.join("horizon"), root.join("launcher"));
+    player_home(&home);
+    create_in(&home, &data, "Old world", None).unwrap();
+    let pinned = edit_in(&home, &data, "Old world", |m| {
+        m.version = Some("v0.1.0".into())
+    })
+    .unwrap();
+    assert_eq!(pinned.version.as_deref(), Some("v0.1.0"));
+    // Renaming keeps it; the other instances follow the launcher's version.
+    let renamed = edit_in(&home, &data, "old-world", |m| m.name = Some("Older".into())).unwrap();
+    assert_eq!(renamed.version.as_deref(), Some("v0.1.0"));
+    assert!(list_in(&home, &data)
+        .iter()
+        .filter(|i| i.id != "old-world")
+        .all(|i| i.version.is_none()));
+    let follows = edit_in(&home, &data, "Older", |m| m.version = None).unwrap();
+    assert_eq!(follows.version, None);
+    fs::remove_dir_all(&root).unwrap();
+}
diff --git a/launcher/src/instances_page.rs b/launcher/src/instances_page.rs
index ce6c1d42e..a414ca227 100644
--- a/launcher/src/instances_page.rs
+++ b/launcher/src/instances_page.rs
@@ -77,6 +77,25 @@ impl Launcher {
         list.iter().find(|i| i.id == id).or(list.first())
     }
 
+    /// The installed version `instance` plays: its own, else the launcher's.
+    pub(super) fn version_of(&self, instance: &Instance) -> Option<&String> {
+        match &instance.version {
+            Some(own) => self.installed.iter().find(|t| *t == own),
+            None => self.launcher_version(),
+        }
+    }
+
+    /// Keeps the selected instance on `tag`, or lets it follow the launcher's version.
+    pub(super) fn pin_version(&mut self, tag: Option<String>) {
+        let Some(id) = self.selected_instance().map(|i| i.id.clone()) else {
+            return;
+        };
+        match instances::edit(&id, |m| m.version = tag) {
+            Ok(_) => self.reload_instances(),
+            Err(e) => self.client_error = Some(e),
+        }
+    }
+
     fn select_instance(&mut self, instance: &Instance) {
         self.settings.instance =
             (instance.kind != InstanceKind::Default).then(|| instance.id.clone());
@@ -154,15 +173,6 @@ impl Launcher {
         cx: &mut Context<Self>,
     ) -> Vec<AnyElement> {
         let t = self.theme;
-        let tag = self.selected().cloned();
-        let prepared = tag.as_deref().is_some_and(backend::is_prepared);
-        let status = if tag.is_none() {
-            "No version installed"
-        } else if prepared {
-            "Ready"
-        } else {
-            "Needs preparing"
-        };
         let selected = self.selected_instance().map(|i| i.id.clone());
         let on_packs = self.page == Page::Mods && self.mods.on_modpacks();
         let mut out = Vec::new();
@@ -174,10 +184,18 @@ impl Launcher {
                     out.push(heading(g.to_uppercase()).into_any_element());
                 }
             }
+            let tag = self.version_of(&i).cloned();
+            let prepared = tag.as_deref().is_some_and(backend::is_prepared);
             let (open, sub) = match i.kind {
                 InstanceKind::Default | InstanceKind::Own => (
                     self.page == Page::Play && selected.as_ref() == Some(&i.id),
-                    status.to_string(),
+                    match (&tag, &i.version) {
+                        (None, Some(own)) => format!("{own} is not installed"),
+                        (None, None) => "No version installed".into(),
+                        (Some(_), _) if !prepared => "Needs preparing".into(),
+                        (Some(tag), Some(_)) => format!("Ready · {tag}"),
+                        (Some(_), None) => "Ready".into(),
+                    },
                 ),
                 InstanceKind::Port => {
                     let slug = &i.id["port:".len()..];
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index b9f556d69..de87ceecc 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -764,7 +764,15 @@ impl Launcher {
         switched
     }
 
+    /// The version Play starts: the selected instance's own, else the launcher's.
     fn selected(&self) -> Option<&String> {
+        self.selected_instance()
+            .and_then(|i| self.version_of(i))
+            .or_else(|| self.launcher_version())
+    }
+
+    /// The launcher's version: what instances without one of their own play.
+    fn launcher_version(&self) -> Option<&String> {
         self.settings
             .selected
             .as_ref()
@@ -1850,16 +1858,20 @@ impl Launcher {
                 .absolute()
                 .top(px(66.))
                 .right_0()
-                .w(px(240.))
+                .w(px(300.))
                 .p(px(6.))
                 .border_2()
                 .border_color(t.outline)
                 .bg(t.surface)
                 .flex()
                 .flex_col();
+            // Picking a version keeps the selected instance on it; the launcher's own version
+            // (newest unless chosen otherwise on Versions) follows updates.
+            let follows = self.launcher_version().cloned();
             for tag in &self.installed {
                 let selected = self.selected() == Some(tag);
                 let tag = tag.clone();
+                let latest = follows.as_ref() == Some(&tag);
                 menu = menu.child(
                     div()
                         .id(SharedString::from(format!("pick-{tag}")))
@@ -1875,12 +1887,20 @@ impl Launcher {
                         .cursor_pointer()
                         .hover(move |s| s.bg(t.plate_soft))
                         .child(tag.clone())
-                        .when(selected, |d| {
-                            d.child(div().size(px(6.)).rounded_full().bg(t.accent))
-                        })
+                        .child(
+                            div()
+                                .flex()
+                                .items_center()
+                                .gap(px(8.))
+                                .when(latest, |d| {
+                                    d.child(caps("follows updates").text_color(t.muted))
+                                })
+                                .when(selected, |d| {
+                                    d.child(div().size(px(6.)).rounded_full().bg(t.accent))
+                                }),
+                        )
                         .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
-                            this.settings.selected = Some(tag.clone());
-                            this.settings.save();
+                            this.pin_version((!latest).then(|| tag.clone()));
                             this.picker_open = false;
                             cx.notify();
                         })),
diff --git a/launcher/src/mcp.rs b/launcher/src/mcp.rs
index cb4636429..d03f3d567 100644
--- a/launcher/src/mcp.rs
+++ b/launcher/src/mcp.rs
@@ -25,7 +25,7 @@ struct Session {
 /// The tools the session runs itself, under their CLI names: they keep a process (the game, a
 /// server) or a sign-in going between calls. Every other CLI command is generated (cli_tools.rs).
 fn session_tools() -> Value {
-    let version = json!({ "type": "string", "description": "An installed version tag such as v2026.10.13. Default: the selected version." });
+    let version = json!({ "type": "string", "description": "An installed version tag such as v2026.10.13. Default: the selected version (play: the instance's own first)." });
     let none = json!({ "type": "object", "properties": {} });
     json!([
         { "name": "play", "description": "Start the Horizon client (a game window on the player's screen) under agent control: the game_* tools then play it. Returns once it has started; game_wait_ready waits for the world. CLI: horizon-launcher play",
@@ -68,12 +68,12 @@ impl Session {
                 if self.client.as_ref().is_some_and(|c| c.finished().is_none()) {
                     return Err("The client is already running.".into());
                 }
-                let tag = backend::resolve_version(arg_str(args, "version"))?;
-                let mut cmd = backend::client(&tag)?;
                 let instance = match arg_str(args, "instance") {
                     Some(name) => instances::find(name)?,
                     None => instances::selected(),
                 };
+                let tag = instance.resolve_version(arg_str(args, "version"))?;
+                let mut cmd = backend::client(&tag)?;
                 instances::apply(&mut cmd, &instance)?;
                 cmd.args(game_tools::control_args());
                 if let Some(world) = arg_str(args, "world") {
diff --git a/launcher/src/modpacks_page.rs b/launcher/src/modpacks_page.rs
index 2f10b2773..7f1b95ad9 100644
--- a/launcher/src/modpacks_page.rs
+++ b/launcher/src/modpacks_page.rs
@@ -116,7 +116,13 @@ impl Launcher {
     }
 
     fn play_pack(&mut self, work: PathBuf) {
-        let Some(tag) = self.selected().cloned() else {
+        // The pack's instance plays its own version, if it has one.
+        let pack = self.instances.list.iter().find(|i| i.work == work);
+        let Some(tag) = pack
+            .and_then(|i| self.version_of(i))
+            .or_else(|| self.launcher_version())
+            .cloned()
+        else {
             return;
         };
         if self.client.is_some() || self.starting_client.is_some() {

From ee0af20e16cc4ec5e3ad3240dccdde8dec3fe8fb Mon Sep 17 00:00:00 2001
From: socksprox <info@shadowfly.net>
Date: Tue, 27 Oct 2026 01:27:41 +0100
Subject: [PATCH 394/475] Cap the view scale's render distance by the server's

streaming.radius reverts to the client setting in apply_settings, so
an options change on a server with a lower view distance raised every
entity's render range past vanilla's. min(render_distance,
remote.view_distance) is Options.getEffectiveRenderDistance.

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 crates/horizon-client/src/game/entity_culling.rs | 11 ++++++++---
 crates/horizon-client/src/game/remote.rs         |  4 +++-
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/crates/horizon-client/src/game/entity_culling.rs b/crates/horizon-client/src/game/entity_culling.rs
index 4377b2f8d..971639a42 100644
--- a/crates/horizon-client/src/game/entity_culling.rs
+++ b/crates/horizon-client/src/game/entity_culling.rs
@@ -63,10 +63,15 @@ impl Game<'_> {
 impl Game<'_> {
     /// Entity.setViewScale (LevelExtractor.extractVisibleEntities): the entity
     /// distance option times the render distance's boost — 1 at 8 chunks, 2.5
-    /// at 20 or more (`streaming.radius` is the effective render distance).
+    /// at 20 or more. The render distance is the client setting, capped by
+    /// the server's view distance when connected
+    /// (Options.getEffectiveRenderDistance).
     pub(super) fn view_scale(&self) -> f64 {
-        (f64::from(self.streaming.radius) / 8.0).clamp(1.0, 2.5)
-            * f64::from(self.settings.entity_distance)
+        let distance = match &self.remote {
+            Some(r) => self.settings.render_distance.min(r.view_distance),
+            None => self.settings.render_distance,
+        };
+        (f64::from(distance) / 8.0).clamp(1.0, 2.5) * f64::from(self.settings.entity_distance)
     }
 }
 
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index e9f30e84b..698dbb903 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -123,7 +123,9 @@ pub(super) struct Remote {
     pub(super) chunk_format: Arc<ChunkFormat>,
     /// Decodes chunk packets as they arrive, off the frame.
     decoder: ChunkDecoder,
-    view_distance: i32,
+    /// Options.serverRenderDistance: the server's view distance from the
+    /// login or the last chunk-cache-radius packet.
+    pub(super) view_distance: i32,
     sequence: i32,
     position_sender: horizon_client::player_sync::PositionSender,
     last_input: u8,

From c70e2fae7411ab094c5f5a37d186dab9ee7c1b9e Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:37:31 +0100
Subject: [PATCH 395/475] Launcher: worlds of an instance, with backup, copy
 and delete

Home lists the selected instance's worlds from their level.dat (name, mode,
version, last played) with their size and picture. Back up zips one into
backups/ as vanilla's Make Backup does; Copy makes "<name> (1)" with that
name in its level.dat; Delete moves it to the system's trash after a
confirmation (the file manager call on macOS, no Finder permission);
Open folder. `horizon-launcher worlds list|backup|copy|delete`, and their
MCP tools (delete needs confirm). level.dat is read with horizon-world's NBT.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md    |  43 +++++
 launcher/Cargo.lock          | 225 +++++++++++++++++++++++++-
 launcher/Cargo.toml          |   6 +
 launcher/README.md           |   7 +
 launcher/src/cli.rs          | 100 ++++++++++++
 launcher/src/cli_tools.rs    |   1 +
 launcher/src/lib.rs          |   1 +
 launcher/src/main.rs         |   9 ++
 launcher/src/worlds.rs       | 270 +++++++++++++++++++++++++++++++
 launcher/src/worlds/tests.rs | 157 ++++++++++++++++++
 launcher/src/worlds_page.rs  | 298 +++++++++++++++++++++++++++++++++++
 11 files changed, 1111 insertions(+), 6 deletions(-)
 create mode 100644 launcher/src/worlds.rs
 create mode 100644 launcher/src/worlds/tests.rs
 create mode 100644 launcher/src/worlds_page.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 6faaeed74..5d46c10cd 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -330,6 +330,49 @@ Keep an instance on one installed Horizon version, or "latest" to follow updates
 
 MCP: `instance_version`.
 
+## `horizon-launcher worlds list`
+
+The worlds: name, mode, version, last played and size (the default).
+
+    horizon-launcher worlds list
+
+- `--instance`: The instance (default: the selected one)
+
+MCP: `worlds_list`.
+
+## `horizon-launcher worlds backup`
+
+Zip a world into the instance's backups/ folder, as the game's Make Backup does.
+
+    horizon-launcher worlds backup <WORLD>
+
+- `WORLD`: Its folder or name
+- `--instance`
+
+MCP: `worlds_backup`.
+
+## `horizon-launcher worlds copy`
+
+Copy a world beside it, as "<name> (1)".
+
+    horizon-launcher worlds copy <WORLD>
+
+- `WORLD`
+- `--instance`
+
+MCP: `worlds_copy`.
+
+## `horizon-launcher worlds delete`
+
+Move a world to the system's trash.
+
+    horizon-launcher worlds delete <WORLD>
+
+- `WORLD`
+- `--instance`
+
+MCP: `worlds_delete`, needs `confirm: true`.
+
 ## `horizon-launcher modpack list`
 
 The imported packs and their coverage (the default).
diff --git a/launcher/Cargo.lock b/launcher/Cargo.lock
index dd9313df6..dbd21a37f 100644
--- a/launcher/Cargo.lock
+++ b/launcher/Cargo.lock
@@ -70,6 +70,15 @@ dependencies = [
  "equator",
 ]
 
+[[package]]
+name = "android_system_properties"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "anstream"
 version = "1.0.0"
@@ -919,6 +928,17 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "chrono"
+version = "0.4.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
+dependencies = [
+ "iana-time-zone",
+ "num-traits",
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "cipher"
 version = "0.4.4"
@@ -981,6 +1001,15 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486"
 
+[[package]]
+name = "cobs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
+dependencies = [
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "cocoa"
 version = "0.25.0"
@@ -1635,6 +1664,18 @@ dependencies = [
  "winreg",
 ]
 
+[[package]]
+name = "embedded-io"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
+
+[[package]]
+name = "embedded-io"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
+
 [[package]]
 name = "encoding_rs"
 version = "0.8.42"
@@ -2354,7 +2395,7 @@ dependencies = [
  "wayland-protocols-plasma",
  "windows 0.61.3",
  "windows-core 0.61.2",
- "windows-numerics",
+ "windows-numerics 0.2.0",
  "windows-registry 0.5.3",
  "x11-clipboard",
  "x11rb",
@@ -2693,6 +2734,7 @@ dependencies = [
 name = "horizon-launcher"
 version = "0.2.0"
 dependencies = [
+ "chrono",
  "clap",
  "dirs 5.0.1",
  "flate2",
@@ -2708,6 +2750,7 @@ dependencies = [
  "horizon-release-sign",
  "horizon-telemetry",
  "horizon-theme",
+ "horizon-world",
  "image",
  "keyring",
  "objc2-app-kit",
@@ -2720,6 +2763,7 @@ dependencies = [
  "sha1",
  "sha2 0.10.9",
  "tar",
+ "trash",
  "ureq",
  "winresource",
  "zip",
@@ -2801,6 +2845,21 @@ dependencies = [
 name = "horizon-theme"
 version = "0.1.0"
 
+[[package]]
+name = "horizon-world"
+version = "0.1.0"
+dependencies = [
+ "flate2",
+ "horizon-core",
+ "libm",
+ "lz4_flex",
+ "postcard",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+ "xxhash-rust",
+]
+
 [[package]]
 name = "http"
 version = "1.5.0"
@@ -2907,6 +2966,30 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "icu_collections"
 version = "2.3.0"
@@ -3425,6 +3508,12 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "lz4_flex"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecbdfe44b1bd960b68170b417450a628c43f7cf56bb3c5317e61cb230ee7f226"
+
 [[package]]
 name = "mac"
 version = "0.1.1"
@@ -4263,6 +4352,18 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "postcard"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
+dependencies = [
+ "cobs",
+ "embedded-io 0.4.0",
+ "embedded-io 0.6.1",
+ "serde",
+]
+
 [[package]]
 name = "potential_utf"
 version = "0.1.6"
@@ -6187,6 +6288,24 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "trash"
+version = "5.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be89b3fe156965d29ac4f8522f3a640c655affdd9f21cb4f36857f0c92c00317"
+dependencies = [
+ "chrono",
+ "libc",
+ "log",
+ "objc2",
+ "objc2-foundation",
+ "once_cell",
+ "percent-encoding",
+ "scopeguard",
+ "urlencoding",
+ "windows 0.62.2",
+]
+
 [[package]]
 name = "try-lock"
 version = "0.2.5"
@@ -6367,6 +6486,12 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
 [[package]]
 name = "usvg"
 version = "0.45.1"
@@ -6820,11 +6945,23 @@ version = "0.61.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
 dependencies = [
- "windows-collections",
+ "windows-collections 0.2.0",
  "windows-core 0.61.2",
- "windows-future",
+ "windows-future 0.2.1",
  "windows-link 0.1.3",
- "windows-numerics",
+ "windows-numerics 0.2.0",
+]
+
+[[package]]
+name = "windows"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"
+dependencies = [
+ "windows-collections 0.3.2",
+ "windows-core 0.62.2",
+ "windows-future 0.3.2",
+ "windows-numerics 0.3.1",
 ]
 
 [[package]]
@@ -6837,7 +6974,7 @@ dependencies = [
  "rayon",
  "thiserror 2.0.21",
  "windows 0.61.3",
- "windows-future",
+ "windows-future 0.2.1",
 ]
 
 [[package]]
@@ -6849,6 +6986,15 @@ dependencies = [
  "windows-core 0.61.2",
 ]
 
+[[package]]
+name = "windows-collections"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"
+dependencies = [
+ "windows-core 0.62.2",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.57.0"
@@ -6874,6 +7020,19 @@ dependencies = [
  "windows-strings 0.4.2",
 ]
 
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
+]
+
 [[package]]
 name = "windows-future"
 version = "0.2.1"
@@ -6882,7 +7041,18 @@ checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
 dependencies = [
  "windows-core 0.61.2",
  "windows-link 0.1.3",
- "windows-threading",
+ "windows-threading 0.1.0",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"
+dependencies = [
+ "windows-core 0.62.2",
+ "windows-link 0.2.1",
+ "windows-threading 0.2.1",
 ]
 
 [[package]]
@@ -6951,6 +7121,16 @@ dependencies = [
  "windows-link 0.1.3",
 ]
 
+[[package]]
+name = "windows-numerics"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"
+dependencies = [
+ "windows-core 0.62.2",
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows-registry"
 version = "0.4.0"
@@ -6991,6 +7171,15 @@ dependencies = [
  "windows-link 0.1.3",
 ]
 
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows-strings"
 version = "0.3.1"
@@ -7009,6 +7198,15 @@ dependencies = [
  "windows-link 0.1.3",
 ]
 
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -7111,6 +7309,15 @@ dependencies = [
  "windows-link 0.1.3",
 ]
 
+[[package]]
+name = "windows-threading"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.5"
@@ -7423,6 +7630,12 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec7a2a501ed189703dba8b08142f057e887dfc4b2cc4db2d343ac6376ba3e0b9"
 
+[[package]]
+name = "xxhash-rust"
+version = "0.8.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "550a2b930b62486a393c52d5c3b84bff264b28aa437ed64694d31e93b1757af7"
+
 [[package]]
 name = "y4m"
 version = "0.8.0"
diff --git a/launcher/Cargo.toml b/launcher/Cargo.toml
index a97f128b8..57179380b 100644
--- a/launcher/Cargo.toml
+++ b/launcher/Cargo.toml
@@ -37,6 +37,12 @@ horizon-mods = { path = "../crates/horizon-mods", features = ["index"] }
 horizon-release-sign = { path = "../crates/horizon-release-sign" }
 # Opt-in data collection: the consent, the outbox and its upload (docs/telemetry.md).
 horizon-telemetry = { path = "../crates/horizon-telemetry" }
+# level.dat and servers.dat (the worlds and server lists of instances)
+horizon-world = { path = "../crates/horizon-world" }
+# Deleting a world moves it to the system's trash
+trash = "5"
+# Backup names carry the local time, as vanilla's do
+chrono = { version = "0.4", default-features = false, features = ["clock"] }
 # The session file's random name.
 getrandom = "0.3"
 # Players' heads on the Servers page, from the default skins in the player's own game files (already
diff --git a/launcher/README.md b/launcher/README.md
index ea4ebc39c..6a8fe7086 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -81,6 +81,11 @@ The opening, then Play ([clip](docs/opening.webm)):
   Open folder. Each instance plays the launcher's version, which follows updates, unless the Play
   page's version picker keeps it on another installed one (to keep an old world on the version
   it was made with); picking the version marked "follows updates" lets it follow again.
+- **Worlds**: Home lists the selected instance's worlds (picture, mode, version, last played,
+  size). **Back up** zips one into the instance's `backups/` as the game's Make Backup does
+  (`<date>_<time>_<folder>.zip`); **Copy** puts "<name> (1)" beside it; **Delete** moves it to the
+  system's trash after a confirmation; **Open folder**. The same from the command line:
+  `horizon-launcher worlds [list|backup|copy|delete] [--instance <name>]`.
 - **Patch notes**: each release's notes, newest first, with a link to GitHub Sponsors. Quiet "Discord" and "Website" links sit in the footer.
 
 Data lives in the platform's data directory (`~/.local/share/horizon-launcher` on Linux,
@@ -181,6 +186,8 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
     horizon-launcher instance rename|icon|group <instance> <value>  icon: a block or item name, #rrggbb or none
     horizon-launcher instance select <instance>     make Play start it
     horizon-launcher instance version <instance> <tag|latest>   keep it on one installed version, or follow updates
+    horizon-launcher worlds [list] [--instance <name>]        an instance's worlds
+    horizon-launcher worlds backup|copy|delete <world> [--instance <name>]   delete moves it to the trash
     horizon-launcher modpack [list]                 the imported packs and their coverage
     horizon-launcher modpack import <pack>          a .mrpack, CurseForge zip or instance folder
     horizon-launcher modpack port <pack> [--from <dir>] [--version <tag>]   get the jars and carry them over
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 8addbd191..30ad3263f 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -184,6 +184,35 @@ enum InstanceCmd {
     Version { instance: String, version: String },
 }
 
+#[derive(Subcommand)]
+enum WorldsCmd {
+    /// The worlds: name, mode, version, last played and size (the default)
+    List {
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Zip a world into the instance's backups/ folder, as the game's Make Backup does
+    Backup {
+        /// Its folder or name
+        world: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Copy a world beside it, as "<name> (1)"
+    Copy {
+        world: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Move a world to the system's trash
+    Delete {
+        world: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+}
+
 #[derive(Subcommand)]
 enum ModsCmd {
     /// What the browser installed (the default)
@@ -378,6 +407,11 @@ enum Cmd {
         #[command(subcommand)]
         action: Option<InstanceCmd>,
     },
+    /// An instance's single-player worlds: list them, back one up, copy or delete it
+    Worlds {
+        #[command(subcommand)]
+        action: Option<WorldsCmd>,
+    },
     /// Modpacks: import a Java pack, see its coverage report, port what this computer can and
     /// play it as its own profile (docs/modpacks.md)
     Modpack {
@@ -827,6 +861,10 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
                 println!("Horizon is in the applications menu.");
             }
         }
+        Cmd::Worlds { action } => worlds(
+            action.unwrap_or(WorldsCmd::List { instance: None }),
+            as_json,
+        )?,
         Cmd::Instance { action } => instance(action.unwrap_or(InstanceCmd::List), as_json)?,
         Cmd::Modpack { action } => modpack(action.unwrap_or(ModpackCmd::List), as_json)?,
         Cmd::Mods { action } => mods(action.unwrap_or(ModsCmd::List), as_json)?,
@@ -1449,6 +1487,68 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
     Ok(())
 }
 
+fn worlds(action: WorldsCmd, as_json: bool) -> Result<(), String> {
+    use horizon_launcher::worlds::{self, World};
+    let home = |instance: Option<String>| -> Result<PathBuf, String> {
+        Ok(match instance {
+            Some(name) => instances::find(&name)?.home,
+            None => instances::selected().home,
+        })
+    };
+    let value = |w: &World| {
+        let millis = w
+            .last_played
+            .duration_since(std::time::UNIX_EPOCH)
+            .map_or(0, |d| d.as_millis() as u64);
+        serde_json::json!({
+            "folder": w.folder, "name": w.name, "mode": w.mode, "version": w.version,
+            "last_played_ms": millis, "size": w.size, "path": w.path, "icon": w.icon,
+        })
+    };
+    match action {
+        WorldsCmd::List { instance } => {
+            let home = home(instance)?;
+            let all = worlds::list(&home);
+            if as_json {
+                json(all.iter().map(value).collect());
+            } else if all.is_empty() {
+                println!("No worlds in {}", home.join("saves").display());
+            }
+            for w in all.iter().filter(|_| !as_json) {
+                let version = w.version.as_deref().unwrap_or("unknown version");
+                let mb = w.size as f64 / 1_000_000.0;
+                println!(
+                    "{} ({})\n    {}, {version}, {mb:.1} MB",
+                    w.name, w.folder, w.mode
+                );
+            }
+        }
+        WorldsCmd::Backup { world, instance } => {
+            let home = home(instance)?;
+            let zip = worlds::backup(&home, &worlds::find(&home, &world)?)?;
+            match as_json {
+                true => json(serde_json::json!({ "backup": zip })),
+                false => println!("{}", zip.display()),
+            }
+        }
+        WorldsCmd::Copy { world, instance } => {
+            let home = home(instance)?;
+            let copy = worlds::copy(&worlds::find(&home, &world)?)?;
+            match as_json {
+                true => json(value(&copy)),
+                false => println!("Copied to {} ({})", copy.name, copy.folder),
+            }
+        }
+        WorldsCmd::Delete { world, instance } => {
+            let home = home(instance)?;
+            let w = worlds::find(&home, &world)?;
+            worlds::delete(&w)?;
+            println!("{} is in the trash.", w.name);
+        }
+    }
+    Ok(())
+}
+
 fn modpack(action: ModpackCmd, as_json: bool) -> Result<(), String> {
     use horizon_launcher::browser::horizon;
     use horizon_launcher::modpacks::{self, Imported};
diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs
index 45763296a..9704f97c5 100644
--- a/launcher/src/cli_tools.rs
+++ b/launcher/src/cli_tools.rs
@@ -26,6 +26,7 @@ pub const DESTRUCTIVE: &[&str] = &[
     "servers forget",
     "account sign-out",
     "data delete",
+    "worlds delete",
 ];
 
 /// Commands that send something or reach other people: only when the player asks.
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index f1779c332..9b74253d4 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -17,3 +17,4 @@ pub mod signed;
 pub mod sources;
 pub mod tailscale;
 pub mod telemetry;
+pub mod worlds;
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index de87ceecc..fe3fb3f4d 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -25,6 +25,7 @@ mod scrollbar;
 mod servers_page;
 mod theme;
 mod titlebar;
+mod worlds_page;
 
 use gpui::{
     actions, div, ease_out_quint, prelude::*, px, relative, size, Animation, AnimationExt,
@@ -226,6 +227,8 @@ struct Launcher {
     mods: mods_page::Mods,
     /// The instances, for the sidebar and Play, and their dialog (`instances_page.rs`).
     instances: instances_page::Instances,
+    /// Home's Worlds section, of the selected instance (`worlds_page.rs`).
+    worlds: worlds_page::Worlds,
     /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar.
     offline_name: Option<String>,
     /// The player's servers, for the sidebar until the Servers page has read them.
@@ -383,6 +386,7 @@ impl Launcher {
             starting_pack: None,
             mods: mods_page::Mods::new(cx),
             instances: instances_page::Instances::default(),
+            worlds: worlds_page::Worlds::default(),
             offline_name: offline_name(),
             side_servers: horizon_launcher::servers::list(),
             art: art::Art::default(),
@@ -677,6 +681,8 @@ impl Launcher {
                         }
                         Job::Client => {
                             self.client = None;
+                            // The game saved: last played, sizes and pictures changed.
+                            self.worlds.stale();
                             // The run's own game folder: an instance's or a pack's keeps its reports.
                             let home = self.client_home.clone().unwrap_or_else(backend::game_home);
                             let report = self
@@ -2157,6 +2163,9 @@ impl Launcher {
             page = page.child(notice(e, &t));
         }
         page = page.child(rows);
+        if let Some(worlds) = self.worlds_section(cx) {
+            page = page.child(worlds);
+        }
         if let Some(e) = self.client_error.clone() {
             page = page.child(notice(e, &t));
         }
diff --git a/launcher/src/worlds.rs b/launcher/src/worlds.rs
new file mode 100644
index 000000000..fc5fff73c
--- /dev/null
+++ b/launcher/src/worlds.rs
@@ -0,0 +1,270 @@
+//! An instance's single-player worlds (`saves/` in its game folder): what each is, and backing
+//! up, copying and deleting them. Backups are made as vanilla's Make Backup makes them
+//! (`LevelStorageAccess.makeWorldBackup`): `backups/<yyyy-MM-dd_HH-mm-ss>_<folder>.zip` in the
+//! game folder, every file under `<folder>/` but the world's `session.lock`.
+use horizon_world::nbt::{self, Limits, Tag};
+use std::fs;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+/// The lock a running game holds on a world; vanilla's backups leave it out.
+const LOCK: &str = "session.lock";
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct World {
+    /// Its folder's name under `saves/`, the id commands take.
+    pub folder: String,
+    pub path: PathBuf,
+    /// `LevelName`, else the folder's name.
+    pub name: String,
+    /// Survival, Creative, Adventure, Spectator or Hardcore.
+    pub mode: &'static str,
+    /// `LastPlayed`, else when level.dat changed.
+    pub last_played: SystemTime,
+    /// The version that last saved it (`Version.Name`).
+    pub version: Option<String>,
+    /// Bytes on disk, every file in its folder.
+    pub size: u64,
+    /// `icon.png`, the picture the game took of it.
+    pub icon: Option<PathBuf>,
+}
+
+/// The worlds in a game folder's `saves/`, the last played first.
+pub fn list(home: &Path) -> Vec<World> {
+    let mut worlds: Vec<World> = fs::read_dir(home.join("saves"))
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter_map(|e| read(&e.path()))
+        .collect();
+    worlds.sort_by_key(|w| std::cmp::Reverse(w.last_played));
+    worlds
+}
+
+/// level.dat: gzip, as vanilla writes it, or plain.
+fn level_dat(path: &Path) -> Option<Tag> {
+    let bytes = fs::read(path).ok()?;
+    let mut raw = Vec::new();
+    let raw = match flate2::read::GzDecoder::new(&bytes[..])
+        .take(64 << 20)
+        .read_to_end(&mut raw)
+    {
+        Ok(_) => raw,
+        Err(_) => bytes,
+    };
+    Some(nbt::read_named(&raw, Limits::default()).ok()?.0.tag)
+}
+
+fn read(path: &Path) -> Option<World> {
+    let dat = path.join("level.dat");
+    let changed = fs::metadata(&dat).and_then(|m| m.modified()).ok()?;
+    let folder = path.file_name()?.to_string_lossy().into_owned();
+    let root = level_dat(&dat);
+    let data = root.as_ref().and_then(|r| r.get("Data"));
+    let field = |key: &str| data.and_then(|d| d.get(key));
+    let number = |tag: Option<&Tag>| match tag {
+        Some(Tag::Byte(v)) => i64::from(*v),
+        Some(Tag::Int(v)) => i64::from(*v),
+        Some(Tag::Long(v)) => *v,
+        _ => 0,
+    };
+    let text = |tag: Option<&Tag>| match tag {
+        Some(Tag::String(s)) => Some(s.to_string_lossy()),
+        _ => None,
+    };
+    // 26.3 keeps hardcore with the difficulty; older saves at the top of Data.
+    let hardcore = number(field("difficulty_settings").and_then(|d| d.get("hardcore"))) != 0
+        || number(field("hardcore")) != 0;
+    let mode = match (hardcore, number(field("GameType"))) {
+        (true, _) => "Hardcore",
+        (_, 1) => "Creative",
+        (_, 2) => "Adventure",
+        (_, 3) => "Spectator",
+        _ => "Survival",
+    };
+    let last_played = match number(field("LastPlayed")) {
+        millis if millis > 0 => UNIX_EPOCH + Duration::from_millis(millis as u64),
+        _ => changed,
+    };
+    let icon = path.join("icon.png");
+    Some(World {
+        name: text(field("LevelName"))
+            .filter(|n| !n.trim().is_empty())
+            .unwrap_or_else(|| folder.clone()),
+        folder,
+        path: path.to_path_buf(),
+        mode,
+        last_played,
+        version: text(field("Version").and_then(|v| v.get("Name"))),
+        size: size(path),
+        icon: icon.is_file().then_some(icon),
+    })
+}
+
+fn size(dir: &Path) -> u64 {
+    fs::read_dir(dir)
+        .into_iter()
+        .flatten()
+        .flatten()
+        .map(|e| match e.file_type() {
+            Ok(t) if t.is_dir() => size(&e.path()),
+            Ok(_) => e.metadata().map_or(0, |m| m.len()),
+            Err(_) => 0,
+        })
+        .sum()
+}
+
+/// The world in `home` a command names: its folder, or its name (any case).
+pub fn find(home: &Path, query: &str) -> Result<World, String> {
+    let all = list(home);
+    all.iter()
+        .find(|w| w.folder == query)
+        .or_else(|| all.iter().find(|w| w.name.eq_ignore_ascii_case(query)))
+        .cloned()
+        .ok_or_else(|| format!("No world {query} in {}", home.join("saves").display()))
+}
+
+/// `base`, else `base (1)`, `base (2)`... from the `first` count: the first name free in `dir`
+/// (vanilla's `FileUtil.findAvailableName`, after making the name safe for every file system).
+fn free_name(dir: &Path, base: &str, suffix: &str, first: u32) -> String {
+    let safe: String = base
+        .chars()
+        .map(|c| match c {
+            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
+            c if c.is_control() => '_',
+            c => c,
+        })
+        .collect();
+    let safe = safe.trim_matches(|c: char| c == '.' || c.is_whitespace());
+    let safe = if safe.is_empty() { "World" } else { safe };
+    (first..)
+        .map(|n| match n {
+            0 => format!("{safe}{suffix}"),
+            n => format!("{safe} ({n}){suffix}"),
+        })
+        .find(|name| !dir.join(name).exists())
+        .unwrap()
+}
+
+/// Zips the world into the game folder's `backups/`, as vanilla's Make Backup does. Returns the
+/// zip's path.
+pub fn backup(home: &Path, world: &World) -> Result<PathBuf, String> {
+    backup_at(home, world, chrono::Local::now())
+}
+
+fn backup_at(
+    home: &Path,
+    world: &World,
+    now: chrono::DateTime<chrono::Local>,
+) -> Result<PathBuf, String> {
+    let dir = home.join("backups");
+    fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let prefix = format!("{}_{}", now.format("%Y-%m-%d_%H-%M-%S"), world.folder);
+    let zip_path = dir.join(free_name(&dir, &prefix, ".zip", 0));
+    let made = (|| -> std::io::Result<()> {
+        let mut zip = zip::ZipWriter::new(std::io::BufWriter::new(fs::File::create(&zip_path)?));
+        let options = zip::write::SimpleFileOptions::default()
+            .compression_method(zip::CompressionMethod::Deflated)
+            .large_file(true);
+        let mut stack = vec![world.path.clone()];
+        while let Some(dir) = stack.pop() {
+            let mut entries: Vec<_> = fs::read_dir(&dir)?.collect::<Result<_, _>>()?;
+            entries.sort_by_key(|e| e.file_name());
+            for e in entries {
+                let path = e.path();
+                if e.file_type()?.is_dir() {
+                    stack.push(path);
+                    continue;
+                }
+                if path.file_name() == Some(LOCK.as_ref()) {
+                    continue;
+                }
+                let relative = path.strip_prefix(&world.path).unwrap_or(&path);
+                let mut entry = world.folder.clone();
+                for part in relative.components() {
+                    entry.push('/');
+                    entry.push_str(&part.as_os_str().to_string_lossy());
+                }
+                zip.start_file(entry, options)?;
+                std::io::copy(&mut fs::File::open(&path)?, &mut zip)?;
+            }
+        }
+        zip.finish()?.flush()
+    })();
+    made.map(|()| zip_path.clone()).map_err(|e| {
+        let _ = fs::remove_file(&zip_path);
+        format!("Could not back up {}: {e}", world.name)
+    })
+}
+
+/// Copies the world into a new folder of the same `saves/`, named "<name> (1)", "<name> (2)"...
+/// and gives the copy that name in its level.dat so the game's list tells them apart.
+pub fn copy(world: &World) -> Result<World, String> {
+    let saves = world.path.parent().ok_or("A world folder has a parent")?;
+    let folder = free_name(saves, &world.name, "", 1);
+    let to = saves.join(&folder);
+    let made = copy_dir(&world.path, &to).and_then(|()| rename_level(&to, &folder));
+    if let Err(e) = made {
+        let _ = fs::remove_dir_all(&to);
+        return Err(format!("Could not copy {}: {e}", world.name));
+    }
+    read(&to).ok_or_else(|| format!("{} has no level.dat", to.display()))
+}
+
+fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
+    fs::create_dir_all(to)?;
+    for e in fs::read_dir(from)? {
+        let e = e?;
+        let target = to.join(e.file_name());
+        if e.file_type()?.is_dir() {
+            copy_dir(&e.path(), &target)?;
+        } else if e.file_name() != LOCK {
+            fs::copy(e.path(), target)?;
+        }
+    }
+    Ok(())
+}
+
+/// Sets `Data.LevelName`; a level.dat that can't be read is left as it is.
+fn rename_level(world: &Path, name: &str) -> std::io::Result<()> {
+    let dat = world.join("level.dat");
+    let Some(mut root) = level_dat(&dat) else {
+        return Ok(());
+    };
+    let Some(Tag::Compound(data)) = root.get_mut("Data") else {
+        return Ok(());
+    };
+    data.insert("LevelName".into(), Tag::String(name.into()));
+    let bytes = nbt::write_named(
+        &nbt::NamedTag {
+            name: "".into(),
+            tag: root,
+        },
+        Limits::default(),
+    )
+    .map_err(std::io::Error::other)?;
+    let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+    gz.write_all(&bytes)?;
+    fs::write(dat, gz.finish()?)
+}
+
+/// Moves the world to the system's trash, where the player can still get it back.
+pub fn delete(world: &World) -> Result<(), String> {
+    #[allow(unused_mut)]
+    let mut trash = trash::TrashContext::default();
+    // The crate's default on macOS asks Finder through AppleScript, which needs the player to
+    // allow the launcher to control Finder first; the file manager call needs nothing.
+    #[cfg(target_os = "macos")]
+    trash::macos::TrashContextExtMacos::set_delete_method(
+        &mut trash,
+        trash::macos::DeleteMethod::NsFileManager,
+    );
+    trash
+        .delete(&world.path)
+        .map_err(|e| format!("Could not move {} to the trash: {e}", world.name))
+}
+
+#[cfg(test)]
+#[path = "worlds/tests.rs"]
+mod tests;
diff --git a/launcher/src/worlds/tests.rs b/launcher/src/worlds/tests.rs
new file mode 100644
index 000000000..b19de80b0
--- /dev/null
+++ b/launcher/src/worlds/tests.rs
@@ -0,0 +1,157 @@
+use super::*;
+use chrono::TimeZone;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-worlds-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+/// A world as the game saves it: a gzip level.dat with `data`'s fields under `Data`.
+fn world(home: &Path, folder: &str, data: Vec<(&str, Tag)>) -> PathBuf {
+    let dir = home.join("saves").join(folder);
+    fs::create_dir_all(dir.join("region")).unwrap();
+    let root = Tag::compound([("Data", Tag::compound(data))]);
+    let bytes = nbt::write_named(
+        &nbt::NamedTag {
+            name: "".into(),
+            tag: root,
+        },
+        Limits::default(),
+    )
+    .unwrap();
+    let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+    gz.write_all(&bytes).unwrap();
+    fs::write(dir.join("level.dat"), gz.finish().unwrap()).unwrap();
+    fs::write(dir.join("region/r.0.0.mca"), [7u8; 1000]).unwrap();
+    fs::write(dir.join(LOCK), "lock").unwrap();
+    dir
+}
+
+fn name(n: &str) -> Tag {
+    Tag::String(n.into())
+}
+
+#[test]
+fn lists_what_each_world_is() {
+    let home = scratch("list");
+    let survival = world(
+        &home,
+        "Survival",
+        vec![
+            ("LevelName", name("My survival")),
+            ("GameType", Tag::Int(0)),
+            ("LastPlayed", Tag::Long(1_700_000_000_000)),
+            ("Version", Tag::compound([("Name", name("26.3"))])),
+        ],
+    );
+    fs::write(survival.join("icon.png"), "png").unwrap();
+    world(
+        &home,
+        "Hard",
+        vec![
+            ("LevelName", name("Hard")),
+            ("GameType", Tag::Int(0)),
+            ("LastPlayed", Tag::Long(1_800_000_000_000)),
+            (
+                "difficulty_settings",
+                Tag::compound([("hardcore", Tag::Byte(1))]),
+            ),
+        ],
+    );
+    world(
+        &home,
+        "Old",
+        vec![
+            ("GameType", Tag::Int(1)),
+            ("hardcore", Tag::Byte(0)),
+            ("LastPlayed", Tag::Long(1_600_000_000_000)),
+        ],
+    );
+    fs::create_dir_all(home.join("saves/not a world")).unwrap();
+
+    let all = list(&home);
+    let names: Vec<&str> = all.iter().map(|w| w.name.as_str()).collect();
+    assert_eq!(names, ["Hard", "My survival", "Old"]);
+    assert_eq!(all[0].mode, "Hardcore");
+    assert_eq!(all[1].mode, "Survival");
+    assert_eq!(all[1].folder, "Survival");
+    assert_eq!(all[1].version.as_deref(), Some("26.3"));
+    assert_eq!(all[1].icon, Some(survival.join("icon.png")));
+    assert_eq!(
+        all[1].last_played,
+        UNIX_EPOCH + Duration::from_millis(1_700_000_000_000)
+    );
+    assert!(all[1].size >= 1000);
+    // No LevelName: the folder's name.
+    assert_eq!(all[2].mode, "Creative");
+    assert_eq!(find(&home, "my SURVIVAL").unwrap().folder, "Survival");
+    assert!(find(&home, "nope").is_err());
+    fs::remove_dir_all(&home).unwrap();
+}
+
+#[test]
+fn a_backup_is_named_and_laid_out_as_vanillas() {
+    let home = scratch("backup");
+    world(&home, "World", vec![("LevelName", name("World"))]);
+    let w = find(&home, "World").unwrap();
+    let at = chrono::Local
+        .with_ymd_and_hms(2026, 10, 27, 1, 2, 3)
+        .unwrap();
+    let first = backup_at(&home, &w, at).unwrap();
+    assert_eq!(first, home.join("backups/2026-10-27_01-02-03_World.zip"));
+    // The same second again: the next free name.
+    let second = backup_at(&home, &w, at).unwrap();
+    assert_eq!(
+        second,
+        home.join("backups/2026-10-27_01-02-03_World (1).zip")
+    );
+    let mut zip = zip::ZipArchive::new(fs::File::open(&first).unwrap()).unwrap();
+    let mut entries: Vec<String> = zip.file_names().map(str::to_string).collect();
+    entries.sort();
+    assert_eq!(entries, ["World/level.dat", "World/region/r.0.0.mca"]);
+    let mut region = Vec::new();
+    zip.by_name("World/region/r.0.0.mca")
+        .unwrap()
+        .read_to_end(&mut region)
+        .unwrap();
+    assert_eq!(region, [7u8; 1000]);
+    fs::remove_dir_all(&home).unwrap();
+}
+
+#[test]
+fn a_copy_gets_the_next_free_name_in_its_folder_and_level_dat() {
+    let home = scratch("copy");
+    world(
+        &home,
+        "Base",
+        vec![("LevelName", name("Base")), ("GameType", Tag::Int(1))],
+    );
+    let base = find(&home, "Base").unwrap();
+    let copy1 = copy(&base).unwrap();
+    assert_eq!(copy1.folder, "Base (1)");
+    assert_eq!(copy1.name, "Base (1)");
+    assert_eq!(copy1.mode, "Creative");
+    assert!(!copy1.path.join(LOCK).exists());
+    assert_eq!(
+        fs::read(copy1.path.join("region/r.0.0.mca")).unwrap(),
+        [7u8; 1000]
+    );
+    assert_eq!(copy(&base).unwrap().folder, "Base (2)");
+    // The original is untouched.
+    assert_eq!(find(&home, "Base").unwrap(), base);
+    // A name that can't be a folder name is made safe.
+    assert_eq!(free_name(&home, "a/b: c?", "", 0), "a_b_ c_");
+    // A world whose folder isn't its name: the copy still gets a new name.
+    world(&home, "f", vec![("LevelName", name("Named"))]);
+    let named = copy(&find(&home, "f").unwrap()).unwrap();
+    assert_eq!(
+        (named.folder.as_str(), named.name.as_str()),
+        ("Named (1)", "Named (1)")
+    );
+    fs::remove_dir_all(&home).unwrap();
+}
diff --git a/launcher/src/worlds_page.rs b/launcher/src/worlds_page.rs
new file mode 100644
index 000000000..e90b185d9
--- /dev/null
+++ b/launcher/src/worlds_page.rs
@@ -0,0 +1,298 @@
+//! The selected instance's worlds on Home (`horizon_launcher::worlds`): each with its picture,
+//! mode, version, when it was last played and its size, and Back up, Copy, Delete (to the
+//! trash, after a confirmation) and Open folder. Reading sizes and copying run in the background.
+use super::*;
+use horizon_launcher::worlds::{self, World};
+use std::path::{Path, PathBuf};
+
+#[derive(Default)]
+pub(super) struct Worlds {
+    /// The game folder the list is of, and the list as last read: kept on screen while it is
+    /// read again, so the page doesn't jump.
+    home: Option<PathBuf>,
+    list: Vec<World>,
+    fresh: bool,
+    reading: bool,
+    /// The world being backed up, copied or deleted now.
+    busy: Option<String>,
+    confirm_delete: Option<String>,
+    /// What the last action did (a backup's zip), or why it failed.
+    done: Option<Result<(String, Option<PathBuf>), String>>,
+}
+
+impl Worlds {
+    /// Read again on the next frame: the game may have saved, or an action changed the list.
+    pub(super) fn stale(&mut self) {
+        self.fresh = false;
+    }
+}
+
+/// "today", "yesterday", "3 days ago", else the date.
+fn ago(when: std::time::SystemTime) -> String {
+    let when: chrono::DateTime<chrono::Local> = when.into();
+    let days = (chrono::Local::now().date_naive() - when.date_naive()).num_days();
+    match days {
+        ..=0 => "today".into(),
+        1 => "yesterday".into(),
+        2..=13 => format!("{days} days ago"),
+        _ => when.format("%Y-%m-%d").to_string(),
+    }
+}
+
+enum Action {
+    Backup,
+    Copy,
+    Delete,
+}
+
+impl Launcher {
+    /// Reads the worlds of `home` in the background when the list is missing or of another
+    /// instance.
+    fn load_worlds(&mut self, home: PathBuf, cx: &mut Context<Self>) {
+        if self.worlds.home.as_ref() != Some(&home) {
+            self.worlds = Worlds {
+                home: Some(home.clone()),
+                ..Worlds::default()
+            };
+        }
+        if self.worlds.fresh || self.worlds.reading {
+            return;
+        }
+        self.worlds.reading = true;
+        let read = home.clone();
+        let task = cx
+            .background_executor()
+            .spawn(async move { worlds::list(&read) });
+        cx.spawn(async move |this, cx| {
+            let list = task.await;
+            let _ = this.update(cx, |this, cx| {
+                // Another instance may have been picked meanwhile.
+                if this.worlds.home.as_ref() == Some(&home) {
+                    this.worlds.list = list;
+                    this.worlds.fresh = true;
+                    this.worlds.reading = false;
+                }
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    fn world_action(&mut self, action: Action, world: World, cx: &mut Context<Self>) {
+        let Some(home) = self.worlds.home.clone() else {
+            return;
+        };
+        if self.worlds.busy.is_some() {
+            return;
+        }
+        self.worlds.busy = Some(world.folder.clone());
+        self.worlds.confirm_delete = None;
+        self.worlds.done = None;
+        let task = cx.background_executor().spawn(async move {
+            match action {
+                Action::Backup => worlds::backup(&home, &world)
+                    .map(|zip| (format!("{} backed up.", world.name), Some(zip))),
+                Action::Copy => {
+                    worlds::copy(&world).map(|c| (format!("Copied to {}.", c.name), None))
+                }
+                Action::Delete => worlds::delete(&world)
+                    .map(|()| (format!("{} moved to the trash.", world.name), None)),
+            }
+        });
+        cx.spawn(async move |this, cx| {
+            let done = task.await;
+            let _ = this.update(cx, |this, cx| {
+                this.worlds.busy = None;
+                this.worlds.done = Some(done);
+                this.worlds.stale();
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    /// Home's Worlds section, for the selected instance.
+    pub(super) fn worlds_section(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let home = self.selected_instance()?.home.clone();
+        self.load_worlds(home.clone(), cx);
+        let list = self.worlds.list.clone();
+        let mut section = div()
+            .flex()
+            .flex_col()
+            .gap(px(8.))
+            .child(section_title("Worlds", "globe", &t).mb(px(4.)));
+        match &self.worlds.done {
+            Some(Ok((message, zip))) => {
+                let mut line = div().flex().items_center().gap(px(12.)).child(
+                    text(theme::CAPTION)
+                        .text_color(t.muted)
+                        .child(message.clone()),
+                );
+                if let Some(zip) = zip.clone() {
+                    let dir = zip.parent().map(Path::to_path_buf).unwrap_or(zip);
+                    line = line.child(
+                        button("world-backups", "Open backups", Kind::Ghost, &t)
+                            .on_click(move |_, _, cx| cx.open_with_system(&dir)),
+                    );
+                }
+                section = section.child(line);
+            }
+            Some(Err(e)) => section = section.child(notice(e.clone(), &t)),
+            None => {}
+        }
+        if list.is_empty() {
+            let saves = home.join("saves");
+            return Some(
+                section.child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .justify_between()
+                        .child(
+                            text(theme::CAPTION)
+                                .text_color(t.muted)
+                                .child("No worlds yet: they appear here once you play one."),
+                        )
+                        .child(
+                            button("worlds-folder", "Open folder", Kind::Ghost, &t).on_click(
+                                move |_, _, cx| {
+                                    let _ = std::fs::create_dir_all(&saves);
+                                    cx.open_with_system(&saves);
+                                },
+                            ),
+                        ),
+                ),
+            );
+        }
+        for (i, w) in list.into_iter().enumerate() {
+            section = section.child(self.world_row(i, w, cx));
+        }
+        Some(section)
+    }
+
+    fn world_row(&mut self, i: usize, w: World, cx: &mut Context<Self>) -> Div {
+        let t = self.theme;
+        let busy = self.worlds.busy.is_some();
+        let this_busy = self.worlds.busy.as_ref() == Some(&w.folder);
+        let confirming = self.worlds.confirm_delete.as_ref() == Some(&w.folder);
+        let picture = match &w.icon {
+            Some(icon) => div()
+                .flex_none()
+                .size(px(48.))
+                .border_2()
+                .border_color(t.outline)
+                .child(gpui::img(icon.clone()).size(px(44.)))
+                .into_any_element(),
+            None => div()
+                .flex()
+                .flex_none()
+                .items_center()
+                .justify_center()
+                .size(px(48.))
+                .border_2()
+                .border_color(t.outline)
+                .bg(t.well)
+                .child(blocks::icon("image", 22., t.muted))
+                .into_any_element(),
+        };
+        let mut facts = vec![w.mode.to_string()];
+        facts.extend(w.version.clone());
+        facts.push(ago(w.last_played));
+        facts.push(megabytes(w.size));
+        let act = |id: &str, label: &'static str, kind: Kind| {
+            let b = button(SharedString::from(format!("{id}-{i}")), label, kind, &t);
+            if busy {
+                disabled(b)
+            } else {
+                b
+            }
+        };
+        let mut actions = div().flex().items_center().gap(px(6.));
+        if confirming {
+            let gone = w.clone();
+            actions = actions
+                .child(
+                    text(theme::CAPTION)
+                        .text_color(t.danger)
+                        .child("Move it to the trash?"),
+                )
+                .child(act("world-keep", "Keep", Kind::Ghost).on_click(cx.listener(
+                    |this, _: &ClickEvent, _, cx| {
+                        this.worlds.confirm_delete = None;
+                        cx.notify();
+                    },
+                )))
+                .child(
+                    act("world-trash", "Move to trash", Kind::Secondary).on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            this.world_action(Action::Delete, gone.clone(), cx);
+                            cx.notify();
+                        },
+                    )),
+                );
+        } else if this_busy {
+            actions = actions.child(text(theme::CAPTION).text_color(t.muted).child("Working…"));
+        } else {
+            let (backup, copy, folder) = (w.clone(), w.clone(), w.path.clone());
+            let delete = w.folder.clone();
+            actions = actions
+                .child(
+                    act("world-backup", "Back up", Kind::Ghost).on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            this.world_action(Action::Backup, backup.clone(), cx);
+                            cx.notify();
+                        },
+                    )),
+                )
+                .child(act("world-copy", "Copy", Kind::Ghost).on_click(cx.listener(
+                    move |this, _: &ClickEvent, _, cx| {
+                        this.world_action(Action::Copy, copy.clone(), cx);
+                        cx.notify();
+                    },
+                )))
+                .child(
+                    act("world-delete", "Delete", Kind::Ghost).on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            // Buttons look disabled while something runs, but still click.
+                            if this.worlds.busy.is_none() {
+                                this.worlds.confirm_delete = Some(delete.clone());
+                            }
+                            cx.notify();
+                        },
+                    )),
+                )
+                .child(
+                    act("world-folder", "Open folder", Kind::Ghost)
+                        .on_click(move |_, _, cx| cx.open_with_system(&folder)),
+                );
+        }
+        plate(&t)
+            .flex()
+            .items_center()
+            .gap(px(14.))
+            .px(px(14.))
+            .py(px(10.))
+            .child(picture)
+            .child(
+                div()
+                    .flex()
+                    .flex_col()
+                    .flex_1()
+                    .min_w_0()
+                    .child(
+                        blocks::pixel(15., FontWeight::MEDIUM)
+                            .text_color(t.ink)
+                            .truncate()
+                            .child(w.name.clone()),
+                    )
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .truncate()
+                            .child(facts.join(" · ")),
+                    ),
+            )
+            .child(actions)
+    }
+}

From d12dc5d1e185762fd939d545bcb1d6fab326a8e0 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:43:25 +0100
Subject: [PATCH 396/475] Game: vanilla's --quickPlaySingleplayer and
 --quickPlayMultiplayer

The launcher starts the game straight into a world or a server. Vanilla's
names for that (client Main, QuickPlay) now work too: --quickPlayMultiplayer
is --server; --quickPlaySingleplayer opens a world of saves/ only if it
exists, as QuickPlay.joinSingleplayerWorld does, and shows the title screen
otherwise (--world also creates one).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game.rs | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index db49087b2..2bfdc1d49 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -375,7 +375,7 @@ impl Options {
             match arg.as_str() {
                 "--help" | "-h" => {
                     println!(
-                        "Horizon — Minecraft Java Edition {} in Rust\n\n  --resources PATH        Prepared resources (horizon-prepare)\n  --render-distance N     Chunks, 2..64 (default 12)\n  --world NAME            World folder under saves/ (default \"New World\")\n  --seed N                World seed for new worlds (default 0)\n  --width N, --height N   Window size (default 1280 x 720)\n  --creative              Creative mode (default survival)\n  --test-terrain          Simple test terrain instead of vanilla generation\n  --frames N              Exit after N frames (testing)\n  --world-frames N        Exit after N frames drawn in the world (testing)\n  --smoke-report PATH     Write a JSON report on exit\n  --benchmark SCENARIO    Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n  --control               Accept horizon-ctl commands on a local socket\n  --control-socket PATH   Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n  --server HOST[:PORT]    Join a multiplayer server (offline mode) at start\n  --name NAME             Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n  --session-file PATH     Signed-in account from the launcher (read once, then deleted)\n  --dev-mod PATH          A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n  --in-frame              Run single player's world in the frame, not on its server thread\n  --pregen                Add Horizon's /pregen command (docs/pregeneration.md)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.",
+                        "Horizon — Minecraft Java Edition {} in Rust\n\n  --resources PATH        Prepared resources (horizon-prepare)\n  --render-distance N     Chunks, 2..64 (default 12)\n  --world NAME            World folder under saves/ (default \"New World\")\n  --seed N                World seed for new worlds (default 0)\n  --width N, --height N   Window size (default 1280 x 720)\n  --creative              Creative mode (default survival)\n  --test-terrain          Simple test terrain instead of vanilla generation\n  --frames N              Exit after N frames (testing)\n  --world-frames N        Exit after N frames drawn in the world (testing)\n  --smoke-report PATH     Write a JSON report on exit\n  --benchmark SCENARIO    Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n  --control               Accept horizon-ctl commands on a local socket\n  --control-socket PATH   Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n  --server HOST[:PORT]    Join a multiplayer server (offline mode) at start\n  --quickPlaySingleplayer WORLD  Open this world of saves/ at start, only if it exists (vanilla's)\n  --quickPlayMultiplayer HOST[:PORT]  The same as --server (vanilla's name)\n  --name NAME             Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n  --session-file PATH     Signed-in account from the launcher (read once, then deleted)\n  --dev-mod PATH          A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n  --in-frame              Run single player's world in the frame, not on its server thread\n  --pregen                Add Horizon's /pregen command (docs/pregeneration.md)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.",
                         horizon_core::VANILLA_VERSION
                     );
                     return Ok(None);
@@ -430,6 +430,16 @@ impl Options {
                         "--width" => o.window_size[0] = value.parse::<u32>()?.max(1),
                         "--height" => o.window_size[1] = value.parse::<u32>()?.max(1),
                         "--world" => o.world = Some(value),
+                        // Vanilla's quick play (Main, QuickPlay.joinSingleplayerWorld): only a
+                        // world that exists opens; else the title screen. --world also creates one.
+                        "--quickPlaySingleplayer" => {
+                            let folder = std::env::current_dir()?.join("saves").join(&value);
+                            if folder.join("level.dat").is_file() {
+                                o.world = Some(value);
+                            } else {
+                                eprintln!("Quick play: there is no world {value} in saves/");
+                            }
+                        }
                         "--dev-mod" => o.dev_mods.push(std::path::absolute(&value)?),
                         "--benchmark" => {
                             if horizon_client::benchmark::scenes(&value).is_none() {
@@ -440,7 +450,7 @@ impl Options {
                             }
                             o.benchmark = Some(value);
                         }
-                        "--server" => o.server = Some(value),
+                        "--server" | "--quickPlayMultiplayer" => o.server = Some(value),
                         "--name" => o.player_name = Some(value),
                         "--session-file" => session_file = Some(value),
                         "--control-socket" => o.control = Some(value.into()),

From e8891849a40a6a8176e78c52d6bafcc726ced7c4 Mon Sep 17 00:00:00 2001
From: socksprox <info@shadowfly.net>
Date: Tue, 27 Oct 2026 01:39:50 +0100
Subject: [PATCH 397/475] AGENTS.md: name posters by GitHub handle, never a
 real name

The "names its own person" rule was ambiguous about which identity an
agent should attribute a post to; handles are the public identity.

Co-Authored-By: Devin (SWE-2 High) <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 AGENTS.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/AGENTS.md b/AGENTS.md
index 4d2a258ec..be78da022 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -15,7 +15,8 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
 - **Mark what an agent posts.** A PR body starts with a line naming whose agent opened it and with what.
   Ludovic's agents write `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.`, and a
   contributor's agent names its own person and tool (issues: "Filed by", reviews: "Review by"). Every
-  comment starts with `🤖 Agent:`. Never write as Ludovic or as anyone else.
+  comment starts with `🤖 Agent:`. Name people by their GitHub handle (`gh api user --jq .login`), never a
+  real name. Never write as Ludovic or as anyone else.
 - **Attribution.** Commits end with a `Co-Authored-By:` line for the agent that wrote them, and PR bodies
   with that agent's own "Generated with" line. Ludovic's agents use
   `Co-Authored-By: Claude <model> <noreply@anthropic.com>` and

From 4b761abcb2d96e84e9362d290f805a0508cec51b Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:56:41 +0100
Subject: [PATCH 398/475] Launcher: play straight into a world or server, and
 the Multiplayer list

Each world on Home gets Play (the game starts with --world <folder>), and
Home lists the selected instance's servers from the game's own servers.dat:
Join starts the game with --server <address>, Add server and Remove change
the file. server_list reads and writes it as vanilla's ServerList does
(uncompressed NBT, a new file then servers.dat_old) and writes every entry
back with all its fields, the hidden Direct Connection ones too.

CLI: `multiplayer [list|add|remove] [--instance]`, `play --server`;
MCP: play takes `server`; `multiplayer remove` needs confirm.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md         |  34 ++++
 launcher/Cargo.lock               |   1 +
 launcher/Cargo.toml               |   1 +
 launcher/README.md                |   9 ++
 launcher/src/cli.rs               |  93 +++++++++++
 launcher/src/cli_tools.rs         |   1 +
 launcher/src/lib.rs               |   1 +
 launcher/src/main.rs              |  23 +++
 launcher/src/mcp.rs               |   7 +
 launcher/src/multiplayer_page.rs  | 251 ++++++++++++++++++++++++++++++
 launcher/src/server_list.rs       | 159 +++++++++++++++++++
 launcher/src/server_list/tests.rs | 143 +++++++++++++++++
 launcher/src/servers_page.rs      |   8 +-
 launcher/src/worlds_page.rs       |  15 +-
 14 files changed, 744 insertions(+), 2 deletions(-)
 create mode 100644 launcher/src/multiplayer_page.rs
 create mode 100644 launcher/src/server_list.rs
 create mode 100644 launcher/src/server_list/tests.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 5d46c10cd..66062de97 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -54,6 +54,7 @@ Start the client.
 - `--world`: Open or create this world (a folder under saves) at once
 - `--creative`: Creative mode for a new world
 - `--join`: Join a friend's world with its invite code
+- `--server`: Join this server at once: an address, or a server of the list by name or position
 - `--arg`: An extra argument for the game, passed through as-is (repeatable), for example --server-thread
 
 MCP: `play`, then the `game_*` tools.
@@ -373,6 +374,39 @@ Move a world to the system's trash.
 
 MCP: `worlds_delete`, needs `confirm: true`.
 
+## `horizon-launcher multiplayer list`
+
+The servers of the game's Multiplayer screen (the default).
+
+    horizon-launcher multiplayer list
+
+- `--instance`: The instance (default: the selected one)
+
+MCP: `multiplayer_list`.
+
+## `horizon-launcher multiplayer add`
+
+Add a server to the list.
+
+    horizon-launcher multiplayer add <ADDRESS>
+
+- `ADDRESS`: Its address, as in the game's Add Server (host or host:port)
+- `--name`: Its name in the list (default: Minecraft Server)
+- `--instance`
+
+MCP: `multiplayer_add`.
+
+## `horizon-launcher multiplayer remove`
+
+Remove a server from the list: its position from 1, name or address.
+
+    horizon-launcher multiplayer remove <SERVER>
+
+- `SERVER`
+- `--instance`
+
+MCP: `multiplayer_remove`, needs `confirm: true`.
+
 ## `horizon-launcher modpack list`
 
 The imported packs and their coverage (the default).
diff --git a/launcher/Cargo.lock b/launcher/Cargo.lock
index dbd21a37f..bace865b6 100644
--- a/launcher/Cargo.lock
+++ b/launcher/Cargo.lock
@@ -2734,6 +2734,7 @@ dependencies = [
 name = "horizon-launcher"
 version = "0.2.0"
 dependencies = [
+ "base64",
  "chrono",
  "clap",
  "dirs 5.0.1",
diff --git a/launcher/Cargo.toml b/launcher/Cargo.toml
index 57179380b..979a781d2 100644
--- a/launcher/Cargo.toml
+++ b/launcher/Cargo.toml
@@ -42,6 +42,7 @@ horizon-world = { path = "../crates/horizon-world" }
 # Deleting a world moves it to the system's trash
 trash = "5"
 # Backup names carry the local time, as vanilla's do
+base64 = "0.22"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 # The session file's random name.
 getrandom = "0.3"
diff --git a/launcher/README.md b/launcher/README.md
index 6a8fe7086..34b7c2317 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -86,6 +86,13 @@ The opening, then Play ([clip](docs/opening.webm)):
   (`<date>_<time>_<folder>.zip`); **Copy** puts "<name> (1)" beside it; **Delete** moves it to the
   system's trash after a confirmation; **Open folder**. The same from the command line:
   `horizon-launcher worlds [list|backup|copy|delete] [--instance <name>]`.
+  **Play** on a world starts the game straight into it.
+- **Multiplayer**: Home lists the selected instance's servers, the game's own Multiplayer list
+  (`servers.dat`, each with the picture the game last saw). **Join** starts the game straight into
+  one; **Add server** and **Remove** (after a confirmation) change the file the game reads,
+  keeping every field the launcher doesn't show and the servers joined with Direct Connection. The
+  same from the command line: `horizon-launcher multiplayer [list|add|remove] [--instance <name>]`
+  and `horizon-launcher play --server <address or name>`.
 - **Patch notes**: each release's notes, newest first, with a link to GitHub Sponsors. Quiet "Discord" and "Website" links sit in the footer.
 
 Data lives in the platform's data directory (`~/.local/share/horizon-launcher` on Linux,
@@ -188,6 +195,8 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
     horizon-launcher instance version <instance> <tag|latest>   keep it on one installed version, or follow updates
     horizon-launcher worlds [list] [--instance <name>]        an instance's worlds
     horizon-launcher worlds backup|copy|delete <world> [--instance <name>]   delete moves it to the trash
+    horizon-launcher multiplayer [list] [--instance <name>]   the servers in an instance's Multiplayer list
+    horizon-launcher multiplayer add <address> [--name <name>] | remove <server>
     horizon-launcher modpack [list]                 the imported packs and their coverage
     horizon-launcher modpack import <pack>          a .mrpack, CurseForge zip or instance folder
     horizon-launcher modpack port <pack> [--from <dir>] [--version <tag>]   get the jars and carry them over
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 30ad3263f..54208631f 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -4,6 +4,7 @@ use clap::{Parser, Subcommand};
 use horizon_launcher::account::{self, Accounts};
 use horizon_launcher::backend::{self, Release};
 use horizon_launcher::instances;
+use horizon_launcher::server_list;
 use std::io::{IsTerminal, Write};
 use std::path::PathBuf;
 use std::process::Command;
@@ -213,6 +214,32 @@ enum WorldsCmd {
     },
 }
 
+#[derive(Subcommand)]
+enum MultiplayerCmd {
+    /// The servers of the game's Multiplayer screen (the default)
+    List {
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Add a server to the list
+    Add {
+        /// Its address, as in the game's Add Server (host or host:port)
+        address: String,
+        /// Its name in the list (default: Minecraft Server)
+        #[arg(long)]
+        name: Option<String>,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Remove a server from the list: its position from 1, name or address
+    Remove {
+        server: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+}
+
 #[derive(Subcommand)]
 enum ModsCmd {
     /// What the browser installed (the default)
@@ -331,6 +358,9 @@ enum Cmd {
         /// Join a friend's world with its invite code
         #[arg(long)]
         join: Option<String>,
+        /// Join this server at once: an address, or a server of the list by name or position
+        #[arg(long, conflicts_with_all = ["world", "join"])]
+        server: Option<String>,
         /// An extra argument for the game, passed through as-is (repeatable), for example
         /// --server-thread
         #[arg(long = "arg", value_name = "ARG", allow_hyphen_values = true)]
@@ -412,6 +442,11 @@ enum Cmd {
         #[command(subcommand)]
         action: Option<WorldsCmd>,
     },
+    /// The servers in an instance's Multiplayer list (servers.dat): list, add, remove
+    Multiplayer {
+        #[command(subcommand)]
+        action: Option<MultiplayerCmd>,
+    },
     /// Modpacks: import a Java pack, see its coverage report, port what this computer can and
     /// play it as its own profile (docs/modpacks.md)
     Modpack {
@@ -681,6 +716,7 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
             world,
             creative,
             join,
+            server,
             arg,
         } => {
             let instance = match instance {
@@ -695,6 +731,11 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
             if let Some(world) = world {
                 cmd.arg("--world").arg(world);
             }
+            if let Some(server) = server {
+                let list = server_list::List::load(&instance.home);
+                let ip = server_list::find(&list, &server).map_or(server, |(_, s)| s.ip);
+                cmd.arg("--server").arg(ip);
+            }
             if creative {
                 cmd.arg("--creative");
             }
@@ -865,6 +906,10 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
             action.unwrap_or(WorldsCmd::List { instance: None }),
             as_json,
         )?,
+        Cmd::Multiplayer { action } => multiplayer(
+            action.unwrap_or(MultiplayerCmd::List { instance: None }),
+            as_json,
+        )?,
         Cmd::Instance { action } => instance(action.unwrap_or(InstanceCmd::List), as_json)?,
         Cmd::Modpack { action } => modpack(action.unwrap_or(ModpackCmd::List), as_json)?,
         Cmd::Mods { action } => mods(action.unwrap_or(ModsCmd::List), as_json)?,
@@ -1487,6 +1532,54 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
     Ok(())
 }
 
+fn multiplayer(action: MultiplayerCmd, as_json: bool) -> Result<(), String> {
+    let home = |instance: Option<String>| -> Result<PathBuf, String> {
+        Ok(match instance {
+            Some(name) => instances::find(&name)?.home,
+            None => instances::selected().home,
+        })
+    };
+    match action {
+        MultiplayerCmd::List { instance } => {
+            let home = home(instance)?;
+            let servers = server_list::List::load(&home).servers();
+            if as_json {
+                json(
+                    servers
+                        .iter()
+                        .map(|s| serde_json::json!({ "name": s.name, "address": s.ip, "icon": s.icon.is_some() }))
+                        .collect(),
+                );
+            } else if servers.is_empty() {
+                println!("No servers in {}", home.join("servers.dat").display());
+            }
+            for (i, s) in servers.iter().enumerate().filter(|_| !as_json) {
+                println!("{}. {} ({})", i + 1, s.name, s.ip);
+            }
+        }
+        MultiplayerCmd::Add {
+            address,
+            name,
+            instance,
+        } => {
+            let home = home(instance)?;
+            let mut list = server_list::List::load(&home);
+            list.add(name.as_deref().unwrap_or(""), &address)?;
+            list.save(&home)?;
+            println!("Added {}.", address.trim());
+        }
+        MultiplayerCmd::Remove { server, instance } => {
+            let home = home(instance)?;
+            let mut list = server_list::List::load(&home);
+            let (i, _) = server_list::find(&list, &server)?;
+            let gone = list.remove(i)?;
+            list.save(&home)?;
+            println!("Removed {} ({}).", gone.name, gone.ip);
+        }
+    }
+    Ok(())
+}
+
 fn worlds(action: WorldsCmd, as_json: bool) -> Result<(), String> {
     use horizon_launcher::worlds::{self, World};
     let home = |instance: Option<String>| -> Result<PathBuf, String> {
diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs
index 9704f97c5..c3932411c 100644
--- a/launcher/src/cli_tools.rs
+++ b/launcher/src/cli_tools.rs
@@ -27,6 +27,7 @@ pub const DESTRUCTIVE: &[&str] = &[
     "account sign-out",
     "data delete",
     "worlds delete",
+    "multiplayer remove",
 ];
 
 /// Commands that send something or reach other people: only when the player asks.
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index 9b74253d4..c00e46c46 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -12,6 +12,7 @@ pub mod modpacks;
 pub mod mojang;
 pub mod process;
 pub mod proxy;
+pub mod server_list;
 pub mod servers;
 pub mod signed;
 pub mod sources;
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index fe3fb3f4d..9fec24cf3 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -19,6 +19,7 @@ mod mcp;
 mod modpacks_page;
 mod mods_page;
 mod mods_project;
+mod multiplayer_page;
 mod partner;
 mod perf;
 mod scrollbar;
@@ -186,6 +187,8 @@ struct Launcher {
     friend_focused: bool,
     friend_focus: FocusHandle,
     joining: Option<String>,
+    /// Where the next start goes at once: `--world <folder>` or `--server <address>`.
+    quick_play: Option<(&'static str, String)>,
     /// Settings' Game arguments field: the line, whether it has focus, and its focus handle.
     args_input: String,
     args_focused: bool,
@@ -229,6 +232,7 @@ struct Launcher {
     instances: instances_page::Instances,
     /// Home's Worlds section, of the selected instance (`worlds_page.rs`).
     worlds: worlds_page::Worlds,
+    multiplayer: multiplayer_page::Multiplayer,
     /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar.
     offline_name: Option<String>,
     /// The player's servers, for the sidebar until the Servers page has read them.
@@ -364,6 +368,7 @@ impl Launcher {
             friend_focused: false,
             friend_focus: cx.focus_handle(),
             joining: None,
+            quick_play: None,
             collection: collection::Collection::load(),
             agents: agents_page::AgentsUi::default(),
             playing: None,
@@ -387,6 +392,7 @@ impl Launcher {
             mods: mods_page::Mods::new(cx),
             instances: instances_page::Instances::default(),
             worlds: worlds_page::Worlds::default(),
+            multiplayer: multiplayer_page::Multiplayer::default(),
             offline_name: offline_name(),
             side_servers: horizon_launcher::servers::list(),
             art: art::Art::default(),
@@ -561,6 +567,9 @@ impl Launcher {
                                 self.client_error = Some(e);
                             }
                         }
+                        if let Some((flag, value)) = self.quick_play.take() {
+                            cmd.arg(flag).arg(value);
+                        }
                         backend::append_game_args(&mut cmd);
                         self.client_home = cmd.get_current_dir().map(|d| d.to_path_buf());
                         match backend::spawn(Job::Client, cmd, self.tx.clone()) {
@@ -683,6 +692,7 @@ impl Launcher {
                             self.client = None;
                             // The game saved: last played, sizes and pictures changed.
                             self.worlds.stale();
+                            self.multiplayer.stale();
                             // The run's own game folder: an instance's or a pack's keeps its reports.
                             let home = self.client_home.clone().unwrap_or_else(backend::game_home);
                             let report = self
@@ -2166,6 +2176,9 @@ impl Launcher {
         if let Some(worlds) = self.worlds_section(cx) {
             page = page.child(worlds);
         }
+        if let Some(servers) = self.multiplayer_section(cx) {
+            page = page.child(servers);
+        }
         if let Some(e) = self.client_error.clone() {
             page = page.child(notice(e, &t));
         }
@@ -3063,6 +3076,16 @@ impl Launcher {
         )
     }
 
+    /// Plays the selected instance straight into a world (`--world`) or a server (`--server`):
+    /// flags every Horizon release takes.
+    pub(crate) fn quick_play(&mut self, flag: &'static str, value: String) {
+        self.quick_play = Some((flag, value));
+        self.play();
+        if self.starting_client.is_none() {
+            self.quick_play = None;
+        }
+    }
+
     fn join_friend(&mut self) {
         if horizon_friends::invite::parse(&self.friend_code).is_none() {
             return;
diff --git a/launcher/src/mcp.rs b/launcher/src/mcp.rs
index d03f3d567..962cd2925 100644
--- a/launcher/src/mcp.rs
+++ b/launcher/src/mcp.rs
@@ -34,6 +34,7 @@ fn session_tools() -> Value {
             "world": { "type": "string", "description": "Open or create this world (a folder under saves) at once." },
             "creative": { "type": "boolean", "description": "Creative mode for a new world." },
             "join": { "type": "string", "description": "Join a friend's world with its invite code. Only when the player asks." },
+            "server": { "type": "string", "description": "Join this server at once: an address, or a server of the instance's list (multiplayer_list) by name or position. Only when the player asks." },
             "offscreen": { "type": "boolean", "description": "Render without showing a window (game_screenshot still works)." },
             "arg": { "type": "array", "items": { "type": "string" }, "description": "Extra game arguments, passed through as-is (for example \"--server-thread\")." } } } },
         { "name": "server", "description": "Start a Horizon dedicated server. It runs until server_stop or the end of this MCP session. Requires agreeing to the Minecraft EULA. CLI: horizon-launcher server",
@@ -87,6 +88,12 @@ impl Session {
                 if let Some(code) = arg_str(args, "join") {
                     backend::join_friend(&mut cmd, code)?;
                 }
+                if let Some(server) = arg_str(args, "server") {
+                    let list = horizon_launcher::server_list::List::load(&instance.home);
+                    let ip = horizon_launcher::server_list::find(&list, server)
+                        .map_or_else(|_| server.to_string(), |(_, s)| s.ip);
+                    cmd.arg("--server").arg(ip);
+                }
                 if let Some(extra) = args.get("arg").and_then(Value::as_array) {
                     cmd.args(extra.iter().filter_map(Value::as_str));
                 }
diff --git a/launcher/src/multiplayer_page.rs b/launcher/src/multiplayer_page.rs
new file mode 100644
index 000000000..867a08ce9
--- /dev/null
+++ b/launcher/src/multiplayer_page.rs
@@ -0,0 +1,251 @@
+//! The selected instance's server list on Home (`horizon_launcher::server_list`, the game's own
+//! `servers.dat`): each server with the picture the game last saw, Join (the game starts straight
+//! into it), Remove after a confirmation, and a line to add one.
+use super::*;
+use gpui::{Image, ImageFormat};
+use horizon_launcher::server_list::{self, Server};
+use servers_page::Field;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+#[derive(Default)]
+pub(super) struct Multiplayer {
+    /// The game folder the list is of, and the list as last read with each picture decoded.
+    home: Option<PathBuf>,
+    list: Vec<(Server, Option<Arc<Image>>)>,
+    fresh: bool,
+    adding: bool,
+    confirm_remove: Option<usize>,
+    error: Option<String>,
+}
+
+impl Multiplayer {
+    /// Read again on the next frame: the game may have changed its list.
+    pub(super) fn stale(&mut self) {
+        self.fresh = false;
+    }
+}
+
+impl Launcher {
+    fn load_servers(&mut self, home: PathBuf) {
+        if self.multiplayer.home.as_ref() != Some(&home) {
+            self.multiplayer = Multiplayer {
+                home: Some(home.clone()),
+                ..Multiplayer::default()
+            };
+        }
+        if self.multiplayer.fresh {
+            return;
+        }
+        // A few servers and their 64×64 pictures: small enough to read while drawing.
+        self.multiplayer.list = server_list::List::load(&home)
+            .servers()
+            .into_iter()
+            .map(|s| {
+                let icon = s
+                    .icon
+                    .clone()
+                    .map(|png| Arc::new(Image::from_bytes(ImageFormat::Png, png)));
+                (s, icon)
+            })
+            .collect();
+        self.multiplayer.fresh = true;
+    }
+
+    fn edit_servers(&mut self, edit: impl FnOnce(&mut server_list::List) -> Result<(), String>) {
+        let Some(home) = self.multiplayer.home.clone() else {
+            return;
+        };
+        let mut list = server_list::List::load(&home);
+        self.multiplayer.error = edit(&mut list).and_then(|()| list.save(&home)).err();
+        self.multiplayer.confirm_remove = None;
+        self.multiplayer.stale();
+    }
+
+    /// Enter in the address field, or Add.
+    pub(super) fn add_server(&mut self) {
+        let name = self.servers.value(Field::ServerName).to_string();
+        let address = self.servers.value(Field::ServerAddress).to_string();
+        self.edit_servers(|list| list.add(&name, &address));
+        if self.multiplayer.error.is_none() {
+            self.servers.text(Field::ServerName).clear();
+            self.servers.text(Field::ServerAddress).clear();
+            self.multiplayer.adding = false;
+        }
+    }
+
+    /// Home's Multiplayer section, for the selected instance.
+    pub(super) fn multiplayer_section(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let home = self.selected_instance()?.home.clone();
+        self.load_servers(home);
+        let header = div()
+            .flex()
+            .items_center()
+            .justify_between()
+            .mb(px(4.))
+            .child(section_title("Multiplayer", "server", &t))
+            .child(
+                button("server-add", "Add server", Kind::Ghost, &t).on_click(cx.listener(
+                    |this, _: &ClickEvent, _, cx| {
+                        this.multiplayer.adding = !this.multiplayer.adding;
+                        this.multiplayer.error = None;
+                        if this.multiplayer.adding {
+                            this.servers.focus_soon = Some(Field::ServerAddress);
+                        }
+                        cx.notify();
+                    },
+                )),
+            );
+        let mut section = div().flex().flex_col().gap(px(8.)).child(header);
+        if let Some(e) = self.multiplayer.error.clone() {
+            section = section.child(notice(e, &t));
+        }
+        if self.multiplayer.adding {
+            section = section.child(
+                plate(&t)
+                    .flex()
+                    .items_center()
+                    .gap(px(8.))
+                    .px(px(14.))
+                    .py(px(10.))
+                    .child(self.field(Field::ServerName, "Minecraft Server", 220., cx))
+                    .child(self.field(Field::ServerAddress, "play.example.com", 300., cx))
+                    .child(button("server-save", "Add", Kind::Secondary, &t).on_click(
+                        cx.listener(|this, _: &ClickEvent, _, cx| {
+                            this.add_server();
+                            cx.notify();
+                        }),
+                    )),
+            );
+        }
+        let list = self.multiplayer.list.clone();
+        if list.is_empty() && !self.multiplayer.adding {
+            section = section.child(
+                text(theme::CAPTION)
+                    .text_color(t.muted)
+                    .child("No servers yet: add one here or in the game's Multiplayer screen."),
+            );
+        }
+        for (i, (server, icon)) in list.into_iter().enumerate() {
+            section = section.child(self.server_row(i, server, icon, cx));
+        }
+        Some(section)
+    }
+
+    fn server_row(
+        &mut self,
+        i: usize,
+        server: Server,
+        icon: Option<Arc<Image>>,
+        cx: &mut Context<Self>,
+    ) -> Div {
+        let t = self.theme;
+        let picture = div()
+            .flex()
+            .flex_none()
+            .items_center()
+            .justify_center()
+            .size(px(48.))
+            .border_2()
+            .border_color(t.outline)
+            .bg(t.well);
+        let picture = match icon {
+            Some(image) => picture.child(gpui::img(image).size(px(44.))),
+            None => picture.child(blocks::icon("server", 22., t.muted)),
+        };
+        let mut actions = div().flex().items_center().gap(px(6.));
+        if self.multiplayer.confirm_remove == Some(i) {
+            actions = actions
+                .child(
+                    text(theme::CAPTION)
+                        .text_color(t.danger)
+                        .child("Remove it from the list?"),
+                )
+                .child(
+                    button(
+                        SharedString::from(format!("server-keep-{i}")),
+                        "Keep",
+                        Kind::Ghost,
+                        &t,
+                    )
+                    .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                        this.multiplayer.confirm_remove = None;
+                        cx.notify();
+                    })),
+                )
+                .child(
+                    button(
+                        SharedString::from(format!("server-remove-{i}")),
+                        "Remove",
+                        Kind::Secondary,
+                        &t,
+                    )
+                    .on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            this.edit_servers(|list| list.remove(i).map(|_| ()));
+                            cx.notify();
+                        },
+                    )),
+                );
+        } else {
+            let ip = server.ip.clone();
+            let busy = self.client.is_some() || self.starting_client.is_some();
+            let join = button(
+                SharedString::from(format!("server-join-{i}")),
+                "Join",
+                Kind::Secondary,
+                &t,
+            );
+            let join = if busy { disabled(join) } else { join };
+            actions = actions
+                .child(
+                    join.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        this.quick_play("--server", ip.clone());
+                        cx.notify();
+                    })),
+                )
+                .child(
+                    button(
+                        SharedString::from(format!("server-delete-{i}")),
+                        "Remove",
+                        Kind::Ghost,
+                        &t,
+                    )
+                    .on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            this.multiplayer.confirm_remove = Some(i);
+                            cx.notify();
+                        },
+                    )),
+                );
+        }
+        plate(&t)
+            .flex()
+            .items_center()
+            .gap(px(14.))
+            .px(px(14.))
+            .py(px(10.))
+            .child(picture)
+            .child(
+                div()
+                    .flex()
+                    .flex_col()
+                    .flex_1()
+                    .min_w_0()
+                    .child(
+                        blocks::pixel(15., FontWeight::MEDIUM)
+                            .text_color(t.ink)
+                            .truncate()
+                            .child(server.name.clone()),
+                    )
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .truncate()
+                            .child(server.ip.clone()),
+                    ),
+            )
+            .child(actions)
+    }
+}
diff --git a/launcher/src/server_list.rs b/launcher/src/server_list.rs
new file mode 100644
index 000000000..896877df4
--- /dev/null
+++ b/launcher/src/server_list.rs
@@ -0,0 +1,159 @@
+//! The player's server list, `servers.dat` in an instance's game folder: the game's Multiplayer
+//! screen reads and writes the same file. Its format is vanilla's (`ServerList.load`/`save`,
+//! `ServerData.read`/`write`): uncompressed NBT, `servers` a list of compounds with `name`, `ip`,
+//! an optional `icon` (a PNG in base64), `acceptTextures`, `acceptedCodeOfConduct` and `hidden`.
+//! The launcher only adds and removes entries: every other field of every entry is written back
+//! as it was read.
+use base64::Engine;
+use horizon_world::nbt::{self, Compound, JavaString, Limits, NamedTag, Tag};
+use std::fs;
+use std::path::Path;
+
+const FILE: &str = "servers.dat";
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Server {
+    pub name: String,
+    pub ip: String,
+    /// The server's picture, as the game last saw it (PNG).
+    pub icon: Option<Vec<u8>>,
+}
+
+/// The entries as they are in the file, the hidden ones (servers joined with Direct
+/// Connection) too.
+pub struct List {
+    entries: Vec<Compound>,
+}
+
+fn key(k: &str) -> JavaString {
+    JavaString::from(k)
+}
+
+fn text(entry: &Compound, k: &str) -> String {
+    match entry.get(&key(k)) {
+        Some(Tag::String(s)) => s.to_string_lossy(),
+        _ => String::new(),
+    }
+}
+
+fn hidden(entry: &Compound) -> bool {
+    matches!(entry.get(&key("hidden")), Some(Tag::Byte(b)) if *b != 0)
+}
+
+impl List {
+    /// The list in `home`; empty when there is none or it can't be read, as the game does.
+    pub fn load(home: &Path) -> List {
+        let entries = fs::read(home.join(FILE))
+            .ok()
+            .and_then(|bytes| nbt::read_named(&bytes, Limits::default()).ok())
+            .and_then(|(root, _)| match root.tag.get("servers") {
+                Some(Tag::List(list)) => Some(
+                    list.iter()
+                        .filter_map(|t| match t {
+                            Tag::Compound(c) => Some(c.clone()),
+                            _ => None,
+                        })
+                        .collect(),
+                ),
+                _ => None,
+            })
+            .unwrap_or_default();
+        List { entries }
+    }
+
+    /// The servers the Multiplayer screen shows, in its order.
+    pub fn servers(&self) -> Vec<Server> {
+        self.entries
+            .iter()
+            .filter(|e| !hidden(e))
+            .map(|e| Server {
+                name: text(e, "name"),
+                ip: text(e, "ip"),
+                icon: Some(text(e, "icon"))
+                    .filter(|s| !s.is_empty())
+                    .and_then(|s| base64::engine::general_purpose::STANDARD.decode(s).ok()),
+            })
+            .collect()
+    }
+
+    /// Adds a server at the end of the shown ones, as the game's Add Server does.
+    pub fn add(&mut self, name: &str, ip: &str) -> Result<(), String> {
+        let (name, ip) = (name.trim(), ip.trim());
+        if ip.is_empty() {
+            return Err("A server needs an address.".into());
+        }
+        let name = if name.is_empty() {
+            "Minecraft Server"
+        } else {
+            name
+        };
+        let at = self
+            .entries
+            .iter()
+            .rposition(|e| !hidden(e))
+            .map_or(0, |i| i + 1);
+        let entry: Compound = [
+            (key("name"), Tag::String(name.into())),
+            (key("ip"), Tag::String(ip.into())),
+            (key("hidden"), Tag::Byte(0)),
+        ]
+        .into_iter()
+        .collect();
+        self.entries.insert(at, entry);
+        Ok(())
+    }
+
+    /// Removes the `index`th shown server.
+    pub fn remove(&mut self, index: usize) -> Result<Server, String> {
+        let server = self
+            .servers()
+            .into_iter()
+            .nth(index)
+            .ok_or_else(|| format!("There is no server {}.", index + 1))?;
+        let at = (0..self.entries.len())
+            .filter(|&i| !hidden(&self.entries[i]))
+            .nth(index)
+            .unwrap();
+        self.entries.remove(at);
+        Ok(server)
+    }
+
+    /// Writes the list as the game does: a new file first, the old one kept as `servers.dat_old`.
+    pub fn save(&self, home: &Path) -> Result<(), String> {
+        let root = NamedTag {
+            name: "".into(),
+            tag: Tag::compound([(
+                "servers",
+                Tag::List(self.entries.iter().cloned().map(Tag::Compound).collect()),
+            )]),
+        };
+        let bytes = nbt::write_named(&root, Limits::default()).map_err(|e| e.to_string())?;
+        let (new, current) = (home.join("servers.dat_new"), home.join(FILE));
+        let written = fs::create_dir_all(home)
+            .and_then(|()| fs::write(&new, bytes))
+            .and_then(|()| match current.exists() {
+                true => fs::copy(&current, home.join("servers.dat_old")).map(|_| ()),
+                false => Ok(()),
+            })
+            .and_then(|()| fs::rename(&new, &current));
+        written.map_err(|e| format!("Could not save the server list: {e}"))
+    }
+}
+
+/// The shown server a command names: its position from 1, its name (any case) or its address.
+pub fn find(list: &List, query: &str) -> Result<(usize, Server), String> {
+    let servers = list.servers();
+    let q = query.trim();
+    q.parse::<usize>()
+        .ok()
+        .filter(|n| (1..=servers.len()).contains(n))
+        .map(|n| n - 1)
+        .or_else(|| servers.iter().position(|s| s.name.eq_ignore_ascii_case(q)))
+        .or_else(|| servers.iter().position(|s| s.ip.eq_ignore_ascii_case(q)))
+        .map(|i| (i, servers[i].clone()))
+        .ok_or_else(|| format!("No server {q} in the list"))
+}
+
+#[cfg(test)]
+#[path = "server_list/tests.rs"]
+mod tests;
diff --git a/launcher/src/server_list/tests.rs b/launcher/src/server_list/tests.rs
new file mode 100644
index 000000000..4bdfb57d6
--- /dev/null
+++ b/launcher/src/server_list/tests.rs
@@ -0,0 +1,143 @@
+use super::*;
+use std::path::PathBuf;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-servers-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+fn s(v: &str) -> Tag {
+    Tag::String(v.into())
+}
+
+/// A servers.dat as the game writes it: one shown server with a picture and the fields the
+/// launcher doesn't use, then one joined through Direct Connection.
+fn vanilla_file(home: &Path) -> Vec<u8> {
+    let png = [0x89, b'P', b'N', b'G', 1, 2, 3];
+    let icon = base64::engine::general_purpose::STANDARD.encode(png);
+    let root = NamedTag {
+        name: "".into(),
+        tag: Tag::compound([(
+            "servers",
+            Tag::List(vec![
+                Tag::compound([
+                    ("name", s("Friends")),
+                    ("ip", s("friends.example:25570")),
+                    ("icon", s(&icon)),
+                    ("acceptTextures", Tag::Byte(1)),
+                    ("acceptedCodeOfConduct", Tag::Int(-12345)),
+                    ("hidden", Tag::Byte(0)),
+                ]),
+                Tag::compound([
+                    ("name", s("Minecraft Server")),
+                    ("ip", s("direct.example")),
+                    ("hidden", Tag::Byte(1)),
+                ]),
+            ]),
+        )]),
+    };
+    let bytes = nbt::write_named(&root, Limits::default()).unwrap();
+    fs::write(home.join(FILE), &bytes).unwrap();
+    bytes
+}
+
+fn entries(home: &Path) -> Vec<Tag> {
+    let bytes = fs::read(home.join(FILE)).unwrap();
+    match nbt::read_named(&bytes, Limits::default())
+        .unwrap()
+        .0
+        .tag
+        .get("servers")
+    {
+        Some(Tag::List(list)) => list.clone(),
+        other => panic!("no servers list: {other:?}"),
+    }
+}
+
+#[test]
+fn reads_the_shown_servers_with_their_pictures() {
+    let home = scratch("reads");
+    vanilla_file(home.as_path());
+    let list = List::load(home.as_path());
+    assert_eq!(
+        list.servers(),
+        vec![Server {
+            name: "Friends".into(),
+            ip: "friends.example:25570".into(),
+            icon: Some(vec![0x89, b'P', b'N', b'G', 1, 2, 3]),
+        }]
+    );
+    // No file, or one that isn't NBT: an empty list, as in the game.
+    assert!(List::load(&home.as_path().join("none"))
+        .servers()
+        .is_empty());
+    fs::write(home.as_path().join(FILE), b"not nbt").unwrap();
+    assert!(List::load(home.as_path()).servers().is_empty());
+}
+
+#[test]
+fn adding_and_removing_keeps_every_other_field_and_the_hidden_servers() {
+    let home = scratch("keeps");
+    let original = vanilla_file(home.as_path());
+    let before = entries(home.as_path());
+
+    let mut list = List::load(home.as_path());
+    list.add("  Hub ", " hub.example ").unwrap();
+    assert!(list.add("x", "  ").is_err());
+    list.save(home.as_path()).unwrap();
+    // The game's own backup of what was there.
+    assert_eq!(
+        fs::read(home.as_path().join("servers.dat_old")).unwrap(),
+        original
+    );
+    assert!(!home.as_path().join("servers.dat_new").exists());
+
+    let after = entries(home.as_path());
+    assert_eq!(after.len(), 3);
+    assert_eq!(
+        after[0], before[0],
+        "the first server is written back untouched"
+    );
+    assert_eq!(
+        after[1],
+        Tag::compound([
+            ("name", s("Hub")),
+            ("ip", s("hub.example")),
+            ("hidden", Tag::Byte(0)),
+        ]),
+        "a new server goes after the shown ones, before the hidden ones"
+    );
+    assert_eq!(after[2], before[1], "the hidden server stays");
+
+    let mut list = List::load(home.as_path());
+    let (i, found) = find(&list, "friends").unwrap();
+    assert_eq!((i, found.ip.as_str()), (0, "friends.example:25570"));
+    assert_eq!(find(&list, "2").unwrap().1.name, "Hub");
+    assert_eq!(find(&list, "HUB.example").unwrap().0, 1);
+    assert!(find(&list, "3").is_err(), "the hidden one can't be named");
+    assert_eq!(list.remove(0).unwrap().name, "Friends");
+    assert!(list.remove(5).is_err());
+    list.save(home.as_path()).unwrap();
+    assert_eq!(
+        entries(home.as_path()),
+        vec![after[1].clone(), before[1].clone()]
+    );
+}
+
+#[test]
+fn a_server_without_a_name_gets_the_games_default() {
+    let home = scratch("default");
+    let mut list = List::load(home.as_path());
+    list.add("", "play.example").unwrap();
+    list.save(home.as_path()).unwrap();
+    assert!(!home.as_path().join("servers.dat_old").exists());
+    assert_eq!(
+        List::load(home.as_path()).servers()[0].name,
+        "Minecraft Server"
+    );
+}
diff --git a/launcher/src/servers_page.rs b/launcher/src/servers_page.rs
index 0237f34f9..ce4906a6a 100644
--- a/launcher/src/servers_page.rs
+++ b/launcher/src/servers_page.rs
@@ -35,10 +35,13 @@ pub(super) enum Field {
     /// The instance dialog's (`instances_page.rs`).
     InstanceName,
     InstanceGroup,
+    /// Home's Multiplayer section's (`multiplayer_page.rs`).
+    ServerName,
+    ServerAddress,
 }
 
 impl Field {
-    const ALL: [Field; 11] = [
+    const ALL: [Field; 13] = [
         Field::Name,
         Field::Seed,
         Field::Players,
@@ -50,6 +53,8 @@ impl Field {
         Field::Email,
         Field::InstanceName,
         Field::InstanceGroup,
+        Field::ServerName,
+        Field::ServerAddress,
     ];
 }
 
@@ -1027,6 +1032,7 @@ impl Launcher {
             Field::Token => self.save_token(),
             Field::Email => self.invite_friend(),
             Field::InstanceName | Field::InstanceGroup => {}
+            Field::ServerName | Field::ServerAddress => self.add_server(),
         }
     }
 
diff --git a/launcher/src/worlds_page.rs b/launcher/src/worlds_page.rs
index e90b185d9..3cba13443 100644
--- a/launcher/src/worlds_page.rs
+++ b/launcher/src/worlds_page.rs
@@ -235,8 +235,21 @@ impl Launcher {
             actions = actions.child(text(theme::CAPTION).text_color(t.muted).child("Working…"));
         } else {
             let (backup, copy, folder) = (w.clone(), w.clone(), w.path.clone());
-            let delete = w.folder.clone();
+            let (delete, play) = (w.folder.clone(), w.folder.clone());
+            let running = self.client.is_some() || self.starting_client.is_some();
+            let play_button = act("world-play", "Play", Kind::Secondary);
+            let play_button = if running {
+                disabled(play_button)
+            } else {
+                play_button
+            };
             actions = actions
+                .child(
+                    play_button.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        this.quick_play("--world", play.clone());
+                        cx.notify();
+                    })),
+                )
                 .child(
                     act("world-backup", "Back up", Kind::Ghost).on_click(cx.listener(
                         move |this, _: &ClickEvent, _, cx| {

From ea0cc65aea9a682810358fb888a03a8d784fdd55 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:02:15 +0100
Subject: [PATCH 399/475] Launcher: play time per instance
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Every run of the game started from the window or `horizon-launcher play`
adds its length to its instance's play time in instances.json (by id, so a
renamed instance keeps it), with when it ended. Home's Instance row shows
"3 h 06 min in total · last played today"; `instance list` shows it too,
and its JSON gives played_secs and last_played_ms.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 launcher/README.md              |  8 +++---
 launcher/src/cli.rs             | 16 ++++++++---
 launcher/src/instances.rs       | 47 +++++++++++++++++++++++++++++++++
 launcher/src/instances/tests.rs | 34 ++++++++++++++++++++++++
 launcher/src/instances_page.rs  | 26 +++++++++++++++++-
 launcher/src/main.rs            | 29 +++++++++++++++++---
 launcher/src/worlds_page.rs     |  2 +-
 7 files changed, 150 insertions(+), 12 deletions(-)

diff --git a/launcher/README.md b/launcher/README.md
index 34b7c2317..c06ffb9d4 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -78,9 +78,11 @@ The opening, then Play ([clip](docs/opening.webm)):
   data folder, so renaming moves nothing. Every instance follows the launcher's data collection
   answer and No AI. In the window, **+** beside Instances makes one, the sidebar lists them by
   group (click one to play it), and Home's Instance row has Edit (name, group, icon), Copy and
-  Open folder. Each instance plays the launcher's version, which follows updates, unless the Play
-  page's version picker keeps it on another installed one (to keep an old world on the version
-  it was made with); picking the version marked "follows updates" lets it follow again.
+  Open folder. The Instance row shows its play time and when it was last played: every run started
+  from the window or `horizon-launcher play` adds to it (`instance list` shows it too). Each
+  instance plays the launcher's version, which follows updates, unless the Play page's version
+  picker keeps it on another installed one (to keep an old world on the version it was made
+  with); picking the version marked "follows updates" lets it follow again.
 - **Worlds**: Home lists the selected instance's worlds (picture, mode, version, last played,
   size). **Back up** zips one into the instance's `backups/` as the game's Make Backup does
   (`<date>_<time>_<folder>.zip`); **Copy** puts "<name> (1)" beside it; **Delete** moves it to the
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 54208631f..b6d736569 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -740,7 +740,12 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
                 cmd.arg("--creative");
             }
             cmd.args(arg);
-            attached(cmd)?
+            let started = std::time::Instant::now();
+            let played = attached(cmd);
+            if let Err(e) = instances::record_play(&instance.id, started.elapsed()) {
+                eprintln!("Play time not saved: {e}");
+            }
+            played?
         }
         Cmd::Server {
             dir,
@@ -1470,7 +1475,8 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
         serde_json::json!({
             "id": i.id, "name": i.name, "kind": format!("{:?}", i.kind).to_lowercase(),
             "home": i.home, "icon": i.icon, "group": i.group, "selected": selected,
-            "version": i.version,
+            "version": i.version, "played_secs": i.played.as_secs(),
+            "last_played_ms": i.last_played.and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok()).map(|d| d.as_millis() as u64),
         })
     };
     let line = |i: &instances::Instance, selected: bool| {
@@ -1485,8 +1491,12 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
             .as_ref()
             .map(|v| format!("  {v}"))
             .unwrap_or_default();
+        let played = match i.last_played {
+            Some(_) => format!("  {} played", instances::play_time(i.played)),
+            None => String::new(),
+        };
         println!(
-            "{mark} {} ({}){pinned}{group}\n    {}",
+            "{mark} {} ({}){pinned}{group}{played}\n    {}",
             i.name,
             i.id,
             i.home.display()
diff --git a/launcher/src/instances.rs b/launcher/src/instances.rs
index 4945ba813..34d9bb408 100644
--- a/launcher/src/instances.rs
+++ b/launcher/src/instances.rs
@@ -14,6 +14,7 @@ use std::collections::BTreeMap;
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 /// The default instance's id: the game's home itself.
 pub const DEFAULT: &str = "horizon";
@@ -90,6 +91,16 @@ pub struct Meta {
     /// launcher's own version, which follows updates.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub version: Option<String>,
+    /// Seconds played in it, every run started by the launcher (the window or `play`) added up.
+    #[serde(default, skip_serializing_if = "is_zero")]
+    pub played_secs: u64,
+    /// When its last run ended, in seconds since 1970.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_played: Option<u64>,
+}
+
+fn is_zero(n: &u64) -> bool {
+    *n == 0
 }
 
 /// `instances.json`: each instance's choices, by id.
@@ -127,6 +138,8 @@ pub struct Instance {
     pub group: Option<String>,
     /// Its pinned Horizon version, if any (`Meta::version`).
     pub version: Option<String>,
+    pub played: Duration,
+    pub last_played: Option<SystemTime>,
 }
 
 impl Instance {
@@ -196,6 +209,10 @@ fn list_in(game_home: &Path, data: &Path) -> Vec<Instance> {
                 icon: meta.icon,
                 group: meta.group,
                 version: meta.version,
+                played: Duration::from_secs(meta.played_secs),
+                last_played: meta
+                    .last_played
+                    .map(|s| UNIX_EPOCH + Duration::from_secs(s)),
                 id,
                 kind,
                 work,
@@ -397,6 +414,36 @@ fn edit_in(
     find_in(&list_in(game_home, data), &instance.id)
 }
 
+/// Adds a finished run of the game to the instance's play time (by id: a renamed instance keeps
+/// it).
+pub fn record_play(id: &str, played: Duration) -> Result<(), String> {
+    record_play_in(&backend::data_dir(), id, played, SystemTime::now())
+}
+
+fn record_play_in(
+    data: &Path,
+    id: &str,
+    played: Duration,
+    ended: SystemTime,
+) -> Result<(), String> {
+    let mut store = Store::load(data);
+    let meta = store.instances.entry(id.to_string()).or_default();
+    meta.played_secs = meta.played_secs.saturating_add(played.as_secs());
+    meta.last_played = ended.duration_since(UNIX_EPOCH).ok().map(|d| d.as_secs());
+    store.save(data)
+}
+
+/// "12 min", "3 h 05 min", "140 h": the play time as players read it.
+pub fn play_time(played: Duration) -> String {
+    let minutes = played.as_secs() / 60;
+    match (minutes / 60, minutes % 60) {
+        (0, 0) => "under a minute".into(),
+        (0, m) => format!("{m} min"),
+        (h, m) if h < 100 => format!("{h} h {m:02} min"),
+        (h, _) => format!("{h} h"),
+    }
+}
+
 /// Turns the game's command into this instance: its own game folder, and a pack's mods. The
 /// player's answers that hold everywhere follow it in: data collection and No AI as the
 /// launcher has them, and options.txt and the offline name when it has none yet.
diff --git a/launcher/src/instances/tests.rs b/launcher/src/instances/tests.rs
index f1c94f5b8..22f8f2b00 100644
--- a/launcher/src/instances/tests.rs
+++ b/launcher/src/instances/tests.rs
@@ -224,3 +224,37 @@ fn an_instance_keeps_its_own_version_until_it_follows_updates_again() {
     assert_eq!(follows.version, None);
     fs::remove_dir_all(&root).unwrap();
 }
+
+#[test]
+fn play_time_adds_up_per_instance_and_survives_a_rename() {
+    let root = scratch("play-time");
+    let (home, data) = (root.join("home"), root.join("data"));
+    fs::create_dir_all(home.join(OWN).join("skyblock")).unwrap();
+    let ended = UNIX_EPOCH + Duration::from_secs(1_800_000_000);
+    record_play_in(&data, "skyblock", Duration::from_secs(25 * 60 + 10), ended).unwrap();
+    edit_in(&home, &data, "skyblock", |m| m.name = Some("Sky".into())).unwrap();
+    let later = ended + Duration::from_secs(3600);
+    record_play_in(&data, "skyblock", Duration::from_secs(40 * 60), later).unwrap();
+    let all = list_in(&home, &data);
+    let sky = find_in(&all, "Sky").unwrap();
+    assert_eq!(sky.played, Duration::from_secs(65 * 60 + 10));
+    assert_eq!(sky.last_played, Some(later));
+    let default = find_in(&all, DEFAULT).unwrap();
+    assert_eq!(
+        (default.played, default.last_played),
+        (Duration::ZERO, None)
+    );
+    // Never played: nothing written for it.
+    let text = fs::read_to_string(data.join(FILE)).unwrap();
+    assert!(!text.contains("horizon"), "{text}");
+    fs::remove_dir_all(&root).unwrap();
+}
+
+#[test]
+fn play_time_reads_as_minutes_then_hours() {
+    let t = |s| play_time(Duration::from_secs(s));
+    assert_eq!(t(59), "under a minute");
+    assert_eq!(t(12 * 60 + 59), "12 min");
+    assert_eq!(t(3 * 3600 + 5 * 60), "3 h 05 min");
+    assert_eq!(t(140 * 3600 + 7 * 60), "140 h");
+}
diff --git a/launcher/src/instances_page.rs b/launcher/src/instances_page.rs
index a414ca227..6a4cd5ad0 100644
--- a/launcher/src/instances_page.rs
+++ b/launcher/src/instances_page.rs
@@ -584,13 +584,37 @@ impl Launcher {
         Some(index_row(
             n,
             "Instance",
-            Some(div().child(instance.name.clone()).into_any_element()),
+            Some(
+                div()
+                    .flex()
+                    .items_baseline()
+                    .gap(px(10.))
+                    .child(instance.name.clone())
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .child(played_line(&instance)),
+                    )
+                    .into_any_element(),
+            ),
             Some(actions.into_any_element()),
             &t,
         ))
     }
 }
 
+/// "3 h 05 min in total · last played today", or "Not played yet".
+fn played_line(instance: &Instance) -> String {
+    match instance.last_played {
+        Some(when) => format!(
+            "{} in total · last played {}",
+            instances::play_time(instance.played),
+            worlds_page::ago(when)
+        ),
+        None => "Not played yet".into(),
+    }
+}
+
 /// The first letter or digit of a name, for an icon without a picture.
 fn initial(name: &str) -> String {
     name.chars()
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 9fec24cf3..8841addb2 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -189,6 +189,8 @@ struct Launcher {
     joining: Option<String>,
     /// Where the next start goes at once: `--world <folder>` or `--server <address>`.
     quick_play: Option<(&'static str, String)>,
+    /// The instance the running game plays and when it started: its play time grows on exit.
+    client_run: Option<(String, Instant)>,
     /// Settings' Game arguments field: the line, whether it has focus, and its focus handle.
     args_input: String,
     args_focused: bool,
@@ -369,6 +371,7 @@ impl Launcher {
             friend_focus: cx.focus_handle(),
             joining: None,
             quick_play: None,
+            client_run: None,
             collection: collection::Collection::load(),
             agents: agents_page::AgentsUi::default(),
             playing: None,
@@ -552,11 +555,20 @@ impl Launcher {
                         }
                         self.accounts = Accounts::load();
                         // A pack's Play button plays that pack; Play plays the selected instance.
-                        let profile = match self.starting_pack.take() {
+                        let (profile, run) = match self.starting_pack.take() {
                             Some(work) => {
-                                horizon_launcher::modpacks::apply_profile(&mut cmd, &work)
+                                let id = instances::list()
+                                    .into_iter()
+                                    .find(|i| i.work == work)
+                                    .map(|i| i.id);
+                                let applied =
+                                    horizon_launcher::modpacks::apply_profile(&mut cmd, &work);
+                                (applied, id)
+                            }
+                            None => {
+                                let instance = instances::selected();
+                                (instances::apply(&mut cmd, &instance), Some(instance.id))
                             }
-                            None => instances::apply(&mut cmd, &instances::selected()),
                         };
                         if let Err(e) = profile {
                             self.client_error = Some(e);
@@ -573,7 +585,10 @@ impl Launcher {
                         backend::append_game_args(&mut cmd);
                         self.client_home = cmd.get_current_dir().map(|d| d.to_path_buf());
                         match backend::spawn(Job::Client, cmd, self.tx.clone()) {
-                            Ok(r) => self.client = Some(r),
+                            Ok(r) => {
+                                self.client = Some(r);
+                                self.client_run = run.map(|id| (id, Instant::now()));
+                            }
                             Err(e) => self.client_error = Some(e),
                         }
                     }
@@ -693,6 +708,12 @@ impl Launcher {
                             // The game saved: last played, sizes and pictures changed.
                             self.worlds.stale();
                             self.multiplayer.stale();
+                            if let Some((id, started)) = self.client_run.take() {
+                                if let Err(e) = instances::record_play(&id, started.elapsed()) {
+                                    eprintln!("Play time not saved: {e}");
+                                }
+                                self.reload_instances();
+                            }
                             // The run's own game folder: an instance's or a pack's keeps its reports.
                             let home = self.client_home.clone().unwrap_or_else(backend::game_home);
                             let report = self
diff --git a/launcher/src/worlds_page.rs b/launcher/src/worlds_page.rs
index 3cba13443..5b7d4f9ee 100644
--- a/launcher/src/worlds_page.rs
+++ b/launcher/src/worlds_page.rs
@@ -28,7 +28,7 @@ impl Worlds {
 }
 
 /// "today", "yesterday", "3 days ago", else the date.
-fn ago(when: std::time::SystemTime) -> String {
+pub(super) fn ago(when: std::time::SystemTime) -> String {
     let when: chrono::DateTime<chrono::Local> = when.into();
     let days = (chrono::Local::now().date_naive() - when.date_naive()).num_days();
     match days {

From 0d5ed8122ed97b85d49c065a85e478239ceeb2c7 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:09:39 +0100
Subject: [PATCH 400/475] Launcher: screenshots gallery per instance

Home shows the selected instance's newest screenshots (what F2 saves in its
screenshots/ folder), all of them on request, and opens one over the window
with Newer/Older (and the arrow keys), Copy (the picture to the clipboard),
Open, Show in folder and Delete (to the trash, after a confirmation).

CLI: `screenshots [list|delete] [--instance]`; `screenshots delete` needs
confirm over MCP. worlds::to_trash is shared by worlds and screenshots.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md        |  21 ++
 launcher/README.md               |   7 +
 launcher/src/cli.rs              |  70 +++++++
 launcher/src/cli_tools.rs        |   1 +
 launcher/src/lib.rs              |   1 +
 launcher/src/main.rs             |  15 ++
 launcher/src/screenshots.rs      | 103 ++++++++++
 launcher/src/screenshots_page.rs | 322 +++++++++++++++++++++++++++++++
 launcher/src/worlds.rs           |   9 +-
 9 files changed, 546 insertions(+), 3 deletions(-)
 create mode 100644 launcher/src/screenshots.rs
 create mode 100644 launcher/src/screenshots_page.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 66062de97..e15df1631 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -374,6 +374,27 @@ Move a world to the system's trash.
 
 MCP: `worlds_delete`, needs `confirm: true`.
 
+## `horizon-launcher screenshots list`
+
+The screenshots, the newest first, with their files (the default).
+
+    horizon-launcher screenshots list
+
+- `--instance`: The instance (default: the selected one)
+
+MCP: `screenshots_list`.
+
+## `horizon-launcher screenshots delete`
+
+Move a screenshot to the system's trash.
+
+    horizon-launcher screenshots delete <SCREENSHOT>
+
+- `SCREENSHOT`: Its file name, with or without .png
+- `--instance`
+
+MCP: `screenshots_delete`, needs `confirm: true`.
+
 ## `horizon-launcher multiplayer list`
 
 The servers of the game's Multiplayer screen (the default).
diff --git a/launcher/README.md b/launcher/README.md
index c06ffb9d4..aeeb4f288 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -89,6 +89,11 @@ The opening, then Play ([clip](docs/opening.webm)):
   system's trash after a confirmation; **Open folder**. The same from the command line:
   `horizon-launcher worlds [list|backup|copy|delete] [--instance <name>]`.
   **Play** on a world starts the game straight into it.
+- **Screenshots**: Home shows the selected instance's newest screenshots (what F2 saves in its
+  `screenshots/` folder) and all of them on request. Clicking one opens it over the window (← and →
+  step through) with **Copy** (the picture, to the clipboard), **Open**, **Show in folder** and
+  **Delete** (to the trash, after a confirmation). From the command line:
+  `horizon-launcher screenshots [list|delete] [--instance <name>]`.
 - **Multiplayer**: Home lists the selected instance's servers, the game's own Multiplayer list
   (`servers.dat`, each with the picture the game last saw). **Join** starts the game straight into
   one; **Add server** and **Remove** (after a confirmation) change the file the game reads,
@@ -197,6 +202,8 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
     horizon-launcher instance version <instance> <tag|latest>   keep it on one installed version, or follow updates
     horizon-launcher worlds [list] [--instance <name>]        an instance's worlds
     horizon-launcher worlds backup|copy|delete <world> [--instance <name>]   delete moves it to the trash
+    horizon-launcher screenshots [list] [--instance <name>]   an instance's screenshots, the newest first
+    horizon-launcher screenshots delete <name> [--instance <name>]   moves it to the trash
     horizon-launcher multiplayer [list] [--instance <name>]   the servers in an instance's Multiplayer list
     horizon-launcher multiplayer add <address> [--name <name>] | remove <server>
     horizon-launcher modpack [list]                 the imported packs and their coverage
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index b6d736569..44ae586c9 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -214,6 +214,23 @@ enum WorldsCmd {
     },
 }
 
+#[derive(Subcommand)]
+enum ScreenshotsCmd {
+    /// The screenshots, the newest first, with their files (the default)
+    List {
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Move a screenshot to the system's trash
+    Delete {
+        /// Its file name, with or without .png
+        screenshot: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+}
+
 #[derive(Subcommand)]
 enum MultiplayerCmd {
     /// The servers of the game's Multiplayer screen (the default)
@@ -442,6 +459,11 @@ enum Cmd {
         #[command(subcommand)]
         action: Option<WorldsCmd>,
     },
+    /// The screenshots F2 took in an instance: list, delete
+    Screenshots {
+        #[command(subcommand)]
+        action: Option<ScreenshotsCmd>,
+    },
     /// The servers in an instance's Multiplayer list (servers.dat): list, add, remove
     Multiplayer {
         #[command(subcommand)]
@@ -911,6 +933,10 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
             action.unwrap_or(WorldsCmd::List { instance: None }),
             as_json,
         )?,
+        Cmd::Screenshots { action } => screenshots(
+            action.unwrap_or(ScreenshotsCmd::List { instance: None }),
+            as_json,
+        )?,
         Cmd::Multiplayer { action } => multiplayer(
             action.unwrap_or(MultiplayerCmd::List { instance: None }),
             as_json,
@@ -1542,6 +1568,50 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
     Ok(())
 }
 
+fn screenshots(action: ScreenshotsCmd, as_json: bool) -> Result<(), String> {
+    use horizon_launcher::screenshots;
+    let home = |instance: Option<String>| -> Result<PathBuf, String> {
+        Ok(match instance {
+            Some(name) => instances::find(&name)?.home,
+            None => instances::selected().home,
+        })
+    };
+    match action {
+        ScreenshotsCmd::List { instance } => {
+            let home = home(instance)?;
+            let shots = screenshots::list(&home);
+            if as_json {
+                json(
+                    shots
+                        .iter()
+                        .map(|s| {
+                            let millis = s
+                                .taken
+                                .duration_since(std::time::UNIX_EPOCH)
+                                .map_or(0, |d| d.as_millis() as u64);
+                            serde_json::json!({ "name": s.name, "path": s.path, "taken_ms": millis, "size": s.size })
+                        })
+                        .collect(),
+                );
+            } else if shots.is_empty() {
+                println!("No screenshots in {}", screenshots::folder(&home).display());
+            }
+            for s in shots.iter().filter(|_| !as_json) {
+                println!("{}", s.path.display());
+            }
+        }
+        ScreenshotsCmd::Delete {
+            screenshot,
+            instance,
+        } => {
+            let shot = screenshots::find(&home(instance)?, &screenshot)?;
+            screenshots::delete(&shot)?;
+            println!("{} is in the trash.", shot.name);
+        }
+    }
+    Ok(())
+}
+
 fn multiplayer(action: MultiplayerCmd, as_json: bool) -> Result<(), String> {
     let home = |instance: Option<String>| -> Result<PathBuf, String> {
         Ok(match instance {
diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs
index c3932411c..cad9b95b6 100644
--- a/launcher/src/cli_tools.rs
+++ b/launcher/src/cli_tools.rs
@@ -28,6 +28,7 @@ pub const DESTRUCTIVE: &[&str] = &[
     "data delete",
     "worlds delete",
     "multiplayer remove",
+    "screenshots delete",
 ];
 
 /// Commands that send something or reach other people: only when the player asks.
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index c00e46c46..2528239b7 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -12,6 +12,7 @@ pub mod modpacks;
 pub mod mojang;
 pub mod process;
 pub mod proxy;
+pub mod screenshots;
 pub mod server_list;
 pub mod servers;
 pub mod signed;
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 8841addb2..67ef0ac39 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -22,6 +22,7 @@ mod mods_project;
 mod multiplayer_page;
 mod partner;
 mod perf;
+mod screenshots_page;
 mod scrollbar;
 mod servers_page;
 mod theme;
@@ -235,6 +236,7 @@ struct Launcher {
     /// Home's Worlds section, of the selected instance (`worlds_page.rs`).
     worlds: worlds_page::Worlds,
     multiplayer: multiplayer_page::Multiplayer,
+    screenshots: screenshots_page::Screenshots,
     /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar.
     offline_name: Option<String>,
     /// The player's servers, for the sidebar until the Servers page has read them.
@@ -396,6 +398,7 @@ impl Launcher {
             instances: instances_page::Instances::default(),
             worlds: worlds_page::Worlds::default(),
             multiplayer: multiplayer_page::Multiplayer::default(),
+            screenshots: screenshots_page::Screenshots::default(),
             offline_name: offline_name(),
             side_servers: horizon_launcher::servers::list(),
             art: art::Art::default(),
@@ -708,6 +711,7 @@ impl Launcher {
                             // The game saved: last played, sizes and pictures changed.
                             self.worlds.stale();
                             self.multiplayer.stale();
+                            self.screenshots.stale();
                             if let Some((id, started)) = self.client_run.take() {
                                 if let Err(e) = instances::record_play(&id, started.elapsed()) {
                                     eprintln!("Play time not saved: {e}");
@@ -2200,6 +2204,9 @@ impl Launcher {
         if let Some(servers) = self.multiplayer_section(cx) {
             page = page.child(servers);
         }
+        if let Some(shots) = self.screenshots_section(cx) {
+            page = page.child(shots);
+        }
         if let Some(e) = self.client_error.clone() {
             page = page.child(notice(e, &t));
         }
@@ -3547,6 +3554,9 @@ impl Render for Launcher {
                     }
                     "escape" if this.servers_escape() => {}
                     "escape" if this.instance_escape() => {}
+                    "escape" if this.screenshot_escape() => {}
+                    "left" if this.screenshot_step(false) => {}
+                    "right" if this.screenshot_step(true) => {}
                     _ => return,
                 }
                 cx.stop_propagation();
@@ -3610,6 +3620,11 @@ impl Render for Launcher {
         if let Some(dialog) = self.instance_dialog(cx) {
             root = root.child(dialog);
         }
+        if self.page == Page::Play {
+            if let Some(viewer) = self.screenshot_viewer(cx) {
+                root = root.child(viewer);
+            }
+        }
         if self.asking_consent() {
             root = root.child(self.consent_screen(cx));
         }
diff --git a/launcher/src/screenshots.rs b/launcher/src/screenshots.rs
new file mode 100644
index 000000000..79e534df6
--- /dev/null
+++ b/launcher/src/screenshots.rs
@@ -0,0 +1,103 @@
+//! An instance's screenshots: the pictures F2 saves into `screenshots/` in its game folder
+//! (vanilla's `Screenshot.grab`, named `<yyyy-MM-dd_HH.mm.ss>.png`).
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::time::SystemTime;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Shot {
+    pub path: PathBuf,
+    /// Its file name, the id commands take.
+    pub name: String,
+    /// When the file was written.
+    pub taken: SystemTime,
+    pub size: u64,
+}
+
+/// The folder F2 saves into for the game folder `home`.
+pub fn folder(home: &Path) -> PathBuf {
+    home.join("screenshots")
+}
+
+/// The pictures in `home`'s screenshots folder, the newest first.
+pub fn list(home: &Path) -> Vec<Shot> {
+    let mut shots: Vec<Shot> = fs::read_dir(folder(home))
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter_map(|e| {
+            let path = e.path();
+            let picture = path
+                .extension()
+                .and_then(|x| x.to_str())
+                .is_some_and(|x| ["png", "jpg", "jpeg"].contains(&x.to_ascii_lowercase().as_str()));
+            let meta = e.metadata().ok().filter(|m| m.is_file() && picture)?;
+            Some(Shot {
+                name: e.file_name().to_string_lossy().into_owned(),
+                taken: meta.modified().unwrap_or(SystemTime::UNIX_EPOCH),
+                size: meta.len(),
+                path,
+            })
+        })
+        .collect();
+    // Same second: the game names the next ones `_2`, `_3`..., which sort after the first.
+    shots.sort_by(|a, b| b.taken.cmp(&a.taken).then_with(|| b.name.cmp(&a.name)));
+    shots
+}
+
+/// The screenshot a command names: its file name, with or without the extension.
+pub fn find(home: &Path, query: &str) -> Result<Shot, String> {
+    list(home)
+        .into_iter()
+        .find(|s| s.name == query || Path::new(&s.name).file_stem().is_some_and(|n| n == query))
+        .ok_or_else(|| format!("No screenshot {query} in {}", folder(home).display()))
+}
+
+/// Moves the screenshot to the system's trash.
+pub fn delete(shot: &Shot) -> Result<(), String> {
+    crate::worlds::to_trash(&shot.path)
+        .map_err(|e| format!("Could not move {} to the trash: {e}", shot.name))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+
+    #[test]
+    fn lists_pictures_newest_first() {
+        let home =
+            std::env::temp_dir().join(format!("horizon-launcher-shots-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&home);
+        let dir = folder(&home);
+        fs::create_dir_all(dir.join("not-a-picture.png")).unwrap();
+        let base = SystemTime::UNIX_EPOCH + Duration::from_secs(1_800_000_000);
+        for (name, age) in [
+            ("2026-10-25_20.00.01.png", 60),
+            ("2026-10-27_09.15.42.png", 0),
+            ("2026-10-27_09.15.42_2.png", 0),
+            ("notes.txt", 0),
+            ("Edited.JPG", 30),
+        ] {
+            let path = dir.join(name);
+            fs::write(&path, b"x").unwrap();
+            let file = fs::File::options().write(true).open(&path).unwrap();
+            file.set_modified(base - Duration::from_secs(age)).unwrap();
+        }
+        let names: Vec<_> = list(&home).into_iter().map(|s| s.name).collect();
+        assert_eq!(
+            names,
+            [
+                "2026-10-27_09.15.42_2.png",
+                "2026-10-27_09.15.42.png",
+                "Edited.JPG",
+                "2026-10-25_20.00.01.png"
+            ]
+        );
+        assert_eq!(find(&home, "2026-10-25_20.00.01").unwrap().size, 1);
+        assert_eq!(find(&home, "Edited.JPG").unwrap().name, "Edited.JPG");
+        assert!(find(&home, "notes.txt").is_err());
+        assert!(list(&home.join("none")).is_empty());
+        fs::remove_dir_all(&home).unwrap();
+    }
+}
diff --git a/launcher/src/screenshots_page.rs b/launcher/src/screenshots_page.rs
new file mode 100644
index 000000000..ce8d75227
--- /dev/null
+++ b/launcher/src/screenshots_page.rs
@@ -0,0 +1,322 @@
+//! The selected instance's screenshots on Home (`horizon_launcher::screenshots`): the newest as
+//! thumbnails, all of them on request, and a viewer (← and → step through) with Copy, Open,
+//! Show in folder and Delete (to the trash, after a confirmation).
+use super::*;
+use gpui::{ClipboardItem, Image, ImageFormat};
+use horizon_launcher::screenshots::{self, Shot};
+use std::path::PathBuf;
+
+/// Thumbnails shown before "Show all".
+const FIRST: usize = 8;
+const THUMB_W: f32 = 196.;
+const THUMB_H: f32 = THUMB_W * 9. / 16.;
+
+#[derive(Default)]
+pub(super) struct Screenshots {
+    home: Option<PathBuf>,
+    list: Vec<Shot>,
+    fresh: bool,
+    all: bool,
+    /// The picture open in the viewer, by its place in `list`.
+    viewing: Option<usize>,
+    confirm_delete: bool,
+    /// What the last action did, or why it failed.
+    note: Option<Result<String, String>>,
+}
+
+impl Screenshots {
+    /// Read again on the next frame: the game may have taken new ones.
+    pub(super) fn stale(&mut self) {
+        self.fresh = false;
+    }
+}
+
+impl Launcher {
+    fn load_screenshots(&mut self, home: PathBuf) {
+        if self.screenshots.home.as_ref() != Some(&home) {
+            self.screenshots = Screenshots {
+                home: Some(home.clone()),
+                ..Screenshots::default()
+            };
+        }
+        if !self.screenshots.fresh {
+            // One directory listing: cheap enough while drawing.
+            self.screenshots.list = screenshots::list(&home);
+            self.screenshots.fresh = true;
+            let last = self.screenshots.list.len().checked_sub(1);
+            self.screenshots.viewing = self
+                .screenshots
+                .viewing
+                .and_then(|i| last.map(|l| i.min(l)));
+        }
+    }
+
+    /// Escape closes the viewer. Whether it did.
+    pub(super) fn screenshot_escape(&mut self) -> bool {
+        let open = self.screenshots.viewing.take().is_some();
+        self.screenshots.confirm_delete = false;
+        open
+    }
+
+    /// ← and → in the viewer: the newer and the older picture. Whether it moved.
+    pub(super) fn screenshot_step(&mut self, older: bool) -> bool {
+        let Some(i) = self.screenshots.viewing else {
+            return false;
+        };
+        let next = match older {
+            true => (i + 1 < self.screenshots.list.len()).then_some(i + 1),
+            false => i.checked_sub(1),
+        };
+        if let Some(n) = next {
+            self.screenshots.viewing = Some(n);
+            self.screenshots.confirm_delete = false;
+            self.screenshots.note = None;
+        }
+        true
+    }
+
+    fn copy_screenshot(&mut self, shot: &Shot, cx: &mut Context<Self>) {
+        let format = match shot.path.extension().and_then(|x| x.to_str()) {
+            Some(x) if x.eq_ignore_ascii_case("png") => ImageFormat::Png,
+            _ => ImageFormat::Jpeg,
+        };
+        self.screenshots.note = Some(match std::fs::read(&shot.path) {
+            Ok(bytes) => {
+                cx.write_to_clipboard(ClipboardItem::new_image(&Image::from_bytes(format, bytes)));
+                Ok("Copied to the clipboard.".into())
+            }
+            Err(e) => Err(format!("Could not read {}: {e}", shot.name)),
+        });
+    }
+
+    fn delete_screenshot(&mut self, shot: &Shot) {
+        self.screenshots.confirm_delete = false;
+        self.screenshots.note =
+            Some(screenshots::delete(shot).map(|()| format!("{} moved to the trash.", shot.name)));
+        self.screenshots.stale();
+    }
+
+    /// Home's Screenshots section, for the selected instance; None while it has none.
+    pub(super) fn screenshots_section(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let home = self.selected_instance()?.home.clone();
+        self.load_screenshots(home.clone());
+        let list = self.screenshots.list.clone();
+        if list.is_empty() {
+            return None;
+        }
+        let shown = if self.screenshots.all {
+            list.len()
+        } else {
+            FIRST
+        };
+        let folder = screenshots::folder(&home);
+        let mut buttons = div().flex().items_center().gap(px(6.));
+        if list.len() > FIRST {
+            let label = match self.screenshots.all {
+                true => "Show fewer".to_string(),
+                false => format!("Show all {}", list.len()),
+            };
+            buttons = buttons.child(button("screenshots-all", label, Kind::Ghost, &t).on_click(
+                cx.listener(|this, _: &ClickEvent, _, cx| {
+                    this.screenshots.all = !this.screenshots.all;
+                    cx.notify();
+                }),
+            ));
+        }
+        buttons = buttons.child(
+            button("screenshots-folder", "Open folder", Kind::Ghost, &t)
+                .on_click(move |_, _, cx| cx.open_with_system(&folder)),
+        );
+        let header = div()
+            .flex()
+            .items_center()
+            .justify_between()
+            .mb(px(4.))
+            .child(section_title("Screenshots", "image", &t))
+            .child(buttons);
+        let grid = div().flex().flex_wrap().gap(px(10.)).children(
+            list.into_iter().take(shown).enumerate().map(|(i, shot)| {
+                div()
+                    .id(SharedString::from(format!("screenshot-{i}")))
+                    .flex_none()
+                    .w(px(THUMB_W))
+                    .h(px(THUMB_H))
+                    .border_2()
+                    .border_color(t.outline)
+                    .bg(t.well)
+                    .cursor_pointer()
+                    .hover(|s| s.border_color(t.accent))
+                    .child(
+                        gpui::img(shot.path.clone())
+                            .size_full()
+                            .object_fit(gpui::ObjectFit::Cover),
+                    )
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        this.screenshots.viewing = Some(i);
+                        this.screenshots.confirm_delete = false;
+                        this.screenshots.note = None;
+                        cx.notify();
+                    }))
+            }),
+        );
+        let mut section = div().flex().flex_col().gap(px(8.)).child(header);
+        if self.screenshots.viewing.is_none() {
+            if let Some(Err(e)) = &self.screenshots.note {
+                section = section.child(notice(e.clone(), &t));
+            }
+        }
+        Some(section.child(grid))
+    }
+
+    /// The viewer over the whole window, while a picture is open.
+    pub(super) fn screenshot_viewer(&mut self, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
+        let t = self.theme;
+        let i = self.screenshots.viewing?;
+        let shot = self.screenshots.list.get(i)?.clone();
+        let count = self.screenshots.list.len();
+        let taken: chrono::DateTime<chrono::Local> = shot.taken.into();
+        let step = |id: &'static str, label: &'static str, older: bool, can: bool| {
+            let b = button(id, label, Kind::Ghost, &t);
+            if can {
+                b.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                    this.screenshot_step(older);
+                    cx.notify();
+                }))
+            } else {
+                disabled(b)
+            }
+        };
+        let mut actions = div().flex().items_center().gap(px(6.));
+        if self.screenshots.confirm_delete {
+            let gone = shot.clone();
+            actions =
+                actions
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.danger)
+                            .child("Move it to the trash?"),
+                    )
+                    .child(button("screenshot-keep", "Keep", Kind::Ghost, &t).on_click(
+                        cx.listener(|this, _: &ClickEvent, _, cx| {
+                            this.screenshots.confirm_delete = false;
+                            cx.notify();
+                        }),
+                    ))
+                    .child(
+                        button("screenshot-trash", "Move to trash", Kind::Secondary, &t).on_click(
+                            cx.listener(move |this, _: &ClickEvent, _, cx| {
+                                this.delete_screenshot(&gone);
+                                cx.notify();
+                            }),
+                        ),
+                    );
+        } else {
+            let (copy, open, show) = (shot.clone(), shot.path.clone(), shot.path.clone());
+            actions =
+                actions
+                    .child(button("screenshot-copy", "Copy", Kind::Ghost, &t).on_click(
+                        cx.listener(move |this, _: &ClickEvent, _, cx| {
+                            this.copy_screenshot(&copy, cx);
+                            cx.notify();
+                        }),
+                    ))
+                    .child(
+                        button("screenshot-open", "Open", Kind::Ghost, &t)
+                            .on_click(move |_, _, cx| cx.open_with_system(&open)),
+                    )
+                    .child(
+                        button("screenshot-show", "Show in folder", Kind::Ghost, &t)
+                            .on_click(move |_, _, cx| cx.reveal_path(&show)),
+                    )
+                    .child(
+                        button("screenshot-delete", "Delete", Kind::Ghost, &t).on_click(
+                            cx.listener(|this, _: &ClickEvent, _, cx| {
+                                this.screenshots.confirm_delete = true;
+                                cx.notify();
+                            }),
+                        ),
+                    );
+        }
+        let note = match &self.screenshots.note {
+            Some(Ok(m)) => Some(text(theme::CAPTION).text_color(t.muted).child(m.clone())),
+            Some(Err(e)) => Some(text(theme::CAPTION).text_color(t.danger).child(e.clone())),
+            None => None,
+        };
+        let top = div()
+            .flex()
+            .items_center()
+            .gap(px(12.))
+            .child(
+                div()
+                    .flex()
+                    .flex_col()
+                    .flex_1()
+                    .min_w_0()
+                    .child(
+                        blocks::pixel(17., FontWeight::MEDIUM)
+                            .text_color(t.ink)
+                            .child(taken.format("%Y-%m-%d %H:%M:%S").to_string()),
+                    )
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .truncate()
+                            .child(format!("{} · {} of {count}", shot.name, i + 1)),
+                    ),
+            )
+            .child(step("screenshot-newer", "← Newer", false, i > 0))
+            .child(step("screenshot-older", "Older →", true, i + 1 < count))
+            .child(
+                button("screenshot-close", "Close", Kind::Secondary, &t).on_click(cx.listener(
+                    |this, _: &ClickEvent, _, cx| {
+                        this.screenshot_escape();
+                        cx.notify();
+                    },
+                )),
+            );
+        let bottom = div()
+            .flex()
+            .items_center()
+            .justify_between()
+            .gap(px(12.))
+            .child(div().children(note))
+            .child(actions);
+        Some(
+            div()
+                .id("screenshot-viewer")
+                .absolute()
+                .top_0()
+                .left_0()
+                .size_full()
+                .flex()
+                .flex_col()
+                .gap(px(14.))
+                .px(px(32.))
+                .py(px(24.))
+                .bg(t.page.opacity(0.96))
+                .on_scroll_wheel(|_, _, cx| cx.stop_propagation())
+                .occlude()
+                .child(top)
+                .child(
+                    // The picture fills what the bars leave, whatever its own size.
+                    div()
+                        .relative()
+                        .flex_1()
+                        .min_h_0()
+                        .border_2()
+                        .border_color(t.outline)
+                        .bg(t.well)
+                        .child(
+                            gpui::img(shot.path.clone())
+                                .absolute()
+                                .top_0()
+                                .left_0()
+                                .size_full()
+                                .object_fit(gpui::ObjectFit::Contain),
+                        ),
+                )
+                .child(bottom),
+        )
+    }
+}
diff --git a/launcher/src/worlds.rs b/launcher/src/worlds.rs
index fc5fff73c..68cbebd1a 100644
--- a/launcher/src/worlds.rs
+++ b/launcher/src/worlds.rs
@@ -251,6 +251,11 @@ fn rename_level(world: &Path, name: &str) -> std::io::Result<()> {
 
 /// Moves the world to the system's trash, where the player can still get it back.
 pub fn delete(world: &World) -> Result<(), String> {
+    to_trash(&world.path).map_err(|e| format!("Could not move {} to the trash: {e}", world.name))
+}
+
+/// Moves a file or folder to the system's trash.
+pub(crate) fn to_trash(path: &Path) -> Result<(), trash::Error> {
     #[allow(unused_mut)]
     let mut trash = trash::TrashContext::default();
     // The crate's default on macOS asks Finder through AppleScript, which needs the player to
@@ -260,9 +265,7 @@ pub fn delete(world: &World) -> Result<(), String> {
         &mut trash,
         trash::macos::DeleteMethod::NsFileManager,
     );
-    trash
-        .delete(&world.path)
-        .map_err(|e| format!("Could not move {} to the trash: {e}", world.name))
+    trash.delete(path)
 }
 
 #[cfg(test)]

From 42ef865c344b8c7553313f285fbd880915ba8d68 Mon Sep 17 00:00:00 2001
From: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:11:05 +0100
Subject: [PATCH 401/475] Give shulkers vanilla placement, push and look rules

A shulker used to check only that its cell was air and the support
block had a full collision box. canStayAt now mirrors vanilla: a moving
piston in the shell's own cell does not force a teleport, the support's
face toward the shell must be sturdy, and the fully opened shell's box
must be clear of blocks and entities. teleportSomewhere likewise checks
the target cell with noCollision and refuses faces tagged
minecraft:shulker_does_not_teleport_to, emits level event 2016 (whose
particles now render), and forces a position sync.

The shell easing toward its peek now pushes collidable entities out of
the swept box (onPeekAmountChange / MoverType.SHULKER) through a new
MobEvent::Shift, so standing on a shulker lifts you instead of wedging
you inside the lid.

ShulkerLookControl is ported too: the head yaw is computed in the
attach face's plane (new LookKind::Shulker and look_yaw) instead of the
generic world-yaw, and hurtByTarget now ignores damage from other
shulkers as toIgnoreDamage does.

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 crates/horizon-client/src/game.rs             |   5 +
 crates/horizon-client/src/game/creatures.rs   |  15 ++
 .../src/game/level_particles.rs               |   6 +
 crates/horizon-client/src/mobs.rs             |   6 +
 crates/horizon-client/src/mobs/control.rs     |  17 ++
 crates/horizon-client/src/mobs/shulker.rs     | 252 +++++++++++++++---
 6 files changed, 264 insertions(+), 37 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index db49087b2..bb24b81b1 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -2921,6 +2921,11 @@ impl Game<'_> {
                     pos,
                     data,
                 } => self.dragon_egg_particles([pos.x, pos.y, pos.z], data),
+                LevelEvent::LevelEvent {
+                    id: 2016,
+                    pos,
+                    data,
+                } => self.shulker_teleport_particles([pos.x, pos.y, pos.z], data),
                 LevelEvent::LevelEvent {
                     id: 2017,
                     pos,
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index e895cb7f7..6226dbf80 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -944,6 +944,21 @@ impl Game<'_> {
                         }
                     }
                 }
+                MobEvent::Shift { target, delta } => {
+                    let d = Vec3::new(delta[0], delta[1], delta[2]);
+                    match target {
+                        Who::Player => {
+                            if let Some(p) = self.player.as_mut() {
+                                p.position = p.position.add_vector(d);
+                            }
+                        }
+                        Who::Mob(id) => {
+                            if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
+                                m.position = m.position.add_vector(d);
+                            }
+                        }
+                    }
+                }
                 MobEvent::Wololo { mob } => {
                     if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) {
                         // DyeColor.RED.
diff --git a/crates/horizon-client/src/game/level_particles.rs b/crates/horizon-client/src/game/level_particles.rs
index f12aedc5b..165faa4b6 100644
--- a/crates/horizon-client/src/game/level_particles.rs
+++ b/crates/horizon-client/src/game/level_particles.rs
@@ -12,6 +12,12 @@ impl Game<'_> {
         self.particles
             .block_teleportation(pos, data, [16, 8, 16], self.settings.particles);
     }
+    /// Event 2016: `Shulker.teleportSomewhere`'s particles between the
+    /// shell's old and new cells.
+    pub(super) fn shulker_teleport_particles(&mut self, pos: [i32; 3], data: i32) {
+        self.particles
+            .block_teleportation(pos, data, [8, 8, 8], self.settings.particles);
+    }
     /// Event 2017: `TeleportRandomlyConsumeEffect`'s directional particles.
     pub(super) fn consume_teleport_particles(&mut self, pos: [i32; 3], data: i32) {
         self.particles
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 0d7fb4b54..62a9974c0 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -972,6 +972,12 @@ pub enum MobEvent {
         target: Who,
         velocity: [f64; 3],
     },
+    /// `Entity.move(MoverType.SHULKER, delta)`: shift a target's position
+    /// (an opening shulker lifts what stands on its shell).
+    Shift {
+        target: Who,
+        delta: [f64; 3],
+    },
     /// `EvokerWololoSpellGoal`: a blue sheep turns red.
     Wololo {
         mob: u32,
diff --git a/crates/horizon-client/src/mobs/control.rs b/crates/horizon-client/src/mobs/control.rs
index 3df557362..a111ff5d4 100644
--- a/crates/horizon-client/src/mobs/control.rs
+++ b/crates/horizon-client/src/mobs/control.rs
@@ -90,6 +90,9 @@ pub enum LookKind {
     Fixed,
     /// `HappyGhast.HappyGhastLookControl`.
     HappyGhast,
+    /// `Shulker.ShulkerLookControl`: the yaw turns in the attach face's
+    /// plane and the head is never clamped to the body.
+    Shulker,
 }
 #[derive(Clone, Debug, Default)]
 pub struct LookControl {
@@ -345,6 +348,20 @@ impl Mob {
                     self.body_yaw += 4.0;
                 }
             }
+            LookKind::Shulker => {
+                // ShulkerLookControl: resetXRotOnTick, getXRotD 0, and the
+                // yaw worked out in the attach face's plane (getYRotD).
+                self.head_pitch = 0.0;
+                if look.cooldown > 0 {
+                    self.ai.look.cooldown -= 1;
+                    if let Some(y) = super::shulker::look_yaw(self, look.wanted) {
+                        self.head_yaw = rotate_towards(self.head_yaw, y, look.y_max_rot_speed);
+                    }
+                } else {
+                    self.head_yaw = rotate_towards(self.head_yaw, self.body_yaw, 10.0);
+                }
+                // clampHeadRotationToBody does nothing for a shulker.
+            }
             LookKind::Default | LookKind::Fixed => {
                 if look.kind == LookKind::Default {
                     self.head_pitch = 0.0;
diff --git a/crates/horizon-client/src/mobs/shulker.rs b/crates/horizon-client/src/mobs/shulker.rs
index 6f0edc2d7..d5bdb6888 100644
--- a/crates/horizon-client/src/mobs/shulker.rs
+++ b/crates/horizon-client/src/mobs/shulker.rs
@@ -5,6 +5,7 @@
 use super::{
     Damage, DamageKind, Mob, MobEvent, MobWorld, Species, Who,
     anim::{Poses, State},
+    control::LookKind,
     goals::{
         Cx, Goal, HurtByTarget, LOOK, LookAtPlayer, MOVE, NearestTarget, RandomLookAround,
         goal_clone, reduced,
@@ -37,7 +38,13 @@ pub fn register(m: &mut Mob) {
     g.add(4, ShulkerAttack { attack_time: 0 });
     g.add(7, Peek { time: 0 });
     g.add(8, RandomLookAround::default());
-    m.ai.targets.add(1, HurtByTarget::new().alert());
+    // `ShulkerLookControl`: the head turns in the attach face's plane.
+    m.ai.look.kind = LookKind::Shulker;
+    // `HurtByTargetGoal(this, Shulker.class).setAlertOthers()`: damage from
+    // another shulker draws no retaliation (`toIgnoreDamage`), but a hurt
+    // shulker alerts every targetless shulker around.
+    m.ai.targets
+        .add(1, HurtByTarget::new().alert().ignoring(&[Species::Shulker]));
     // ShulkerNearestAttackGoal: the search box is only 4 deep along the
     // attach axis.
     m.ai.targets.add(
@@ -57,6 +64,10 @@ pub fn register(m: &mut Mob) {
 fn face_step(face: u8) -> [i32; 3] {
     STEPS[face.min(5) as usize]
 }
+/// `Direction.getOpposite` for a 3D data value.
+fn opposite(face: u8) -> u8 {
+    face.min(5) ^ 1
+}
 fn block_pos(m: &Mob) -> [i32; 3] {
     [
         m.position.x.floor() as i32,
@@ -64,19 +75,85 @@ fn block_pos(m: &Mob) -> [i32; 3] {
         m.position.z.floor() as i32,
     ]
 }
-/// `Shulker.canStayAt`: an empty spot against a sturdy face.
-fn can_stay_at(w: &MobWorld, p: [i32; 3], face: u8) -> bool {
-    if !w.facts.is_air(w.world.block(p[0], p[1], p[2])) {
+/// `Shulker.getProgressDeltaAabb` at scale 1: the shell's box from `pos`
+/// (the bottom centre), grown `from`..`to` along `direction`.
+fn progress_aabb(direction: u8, from: f64, to: f64, pos: Vec3) -> Aabb {
+    let s = face_step(direction).map(f64::from);
+    let (max, min) = (from.max(to), from.min(to));
+    Aabb::new(Vec3::new(-0.5, 0.0, -0.5), Vec3::new(0.5, 1.0, 0.5))
+        .expand_towards(Vec3::new(s[0] * max, s[1] * max, s[2] * max))
+        .contract(Vec3::new(
+            -s[0] * (1.0 + min),
+            -s[1] * (1.0 + min),
+            -s[2] * (1.0 + min),
+        ))
+        .move_by(pos)
+}
+/// `Level.noCollision(entity, aabb)`: no block collision under the empty
+/// context, and no entity `m` can be collided with overlaps (other mobs,
+/// and the player when they are not a spectator).
+fn no_collision(m: &Mob, w: &MobWorld, bounds: Aabb) -> bool {
+    let mut scene = crate::collisions::SceneCollisions {
+        world: w.world,
+        binding: w.collision,
+        subject: None,
+    };
+    if !crate::collisions::no_collision_empty(&mut scene, bounds) {
         return false;
     }
+    let grown = bounds.inflate(Vec3::new(1.0e-7, 1.0e-7, 1.0e-7));
+    if let Some(p) = &w.player
+        && p.alive
+        && !p.spectator
+        && p.bounds.intersects(grown)
+    {
+        return false;
+    }
+    !w.others_near(grown)
+        .any(|s| s.id != m.id && s.alive && s.bounds.intersects(grown))
+}
+/// `Shulker.canStayAt`: an empty spot against a sturdy face, with room
+/// for the fully opened shell (`canStayAt`).
+fn can_stay_at(m: &Mob, w: &MobWorld, p: [i32; 3], face: u8) -> bool {
+    // isPositionBlocked: anything but air blocks, except a moving piston
+    // being driven through the shulker's own cell.
+    if !w.facts.is_air(w.world.block(p[0], p[1], p[2]))
+        && (p != block_pos(m) || w.block_name(p[0], p[1], p[2]) != "minecraft:moving_piston")
+    {
+        return false;
+    }
+    // loadedAndEntityCanStandOnFace: the supporting block's face toward
+    // the shell is sturdy.
     let s = face_step(face);
-    let n = w.world.block(p[0] + s[0], p[1] + s[1], p[2] + s[2]);
-    w.facts.get(n).full_collision
+    let support = w.world.block(p[0] + s[0], p[1] + s[1], p[2] + s[2]);
+    let open = opposite(face);
+    if w.facts.get(support).sturdy_full & (1 << open) == 0 {
+        return false;
+    }
+    // The fully opened shell's box, shrunk by the skin vanilla uses.
+    let opened = progress_aabb(
+        open,
+        -1.0,
+        1.0,
+        Vec3::new(
+            f64::from(p[0]) + 0.5,
+            f64::from(p[1]),
+            f64::from(p[2]) + 0.5,
+        ),
+    )
+    .deflate(Vec3::new(1.0e-6, 1.0e-6, 1.0e-6));
+    no_collision(m, w, opened)
 }
 /// `findAttachableSurface`: the first face (down, up, north, south, west,
 /// east) to cling to.
-fn attachable(w: &MobWorld, p: [i32; 3]) -> Option<u8> {
-    (0..6).find(|&f| can_stay_at(w, p, f))
+fn attachable(m: &Mob, w: &MobWorld, p: [i32; 3]) -> Option<u8> {
+    (0..6).find(|&f| can_stay_at(m, w, p, f))
+}
+/// `BlockUtil.packDifferenceInPosition` within 8 blocks of `pos`.
+fn pack_diff(pos: [i32; 3], to: [i32; 3]) -> i32 {
+    ((to[0] - pos[0] + 8) & 0xFF) << 16
+        | ((to[1] - pos[1] + 8) & 0xFF) << 8
+        | (to[2] - pos[2] + 8) & 0xFF
 }
 /// `Shulker.teleportSomewhere`: up to five tries within 8 blocks.
 fn teleport(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) -> bool {
@@ -87,12 +164,31 @@ fn teleport(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) -> bool {
     for _ in 0..5 {
         let r = |m: &mut Mob| m.random.next_int_bound(17).unwrap_or(8) - 8;
         let t = [old[0] + r(m), old[1] + r(m), old[2] + r(m)];
-        if t[1] <= crate::chunk::MIN_Y || !w.facts.is_air(w.world.block(t[0], t[1], t[2])) {
+        let unit = Aabb::new(
+            Vec3::new(f64::from(t[0]), f64::from(t[1]), f64::from(t[2])),
+            Vec3::new(
+                f64::from(t[0]) + 1.0,
+                f64::from(t[1]) + 1.0,
+                f64::from(t[2]) + 1.0,
+            ),
+        );
+        if t[1] <= crate::chunk::MIN_Y
+            || !w.facts.is_air(w.world.block(t[0], t[1], t[2]))
+            || !no_collision(m, w, unit.deflate(Vec3::new(1.0e-6, 1.0e-6, 1.0e-6)))
+        {
             continue;
         }
-        let Some(face) = attachable(w, t) else {
+        let Some(face) = attachable(m, w, t) else {
             continue;
         };
+        // `#minecraft:shulker_does_not_teleport_to` (bedrock) is never clung to.
+        let s = face_step(face);
+        if w.has_tag(
+            "minecraft:shulker_does_not_teleport_to",
+            w.block_name(t[0] + s[0], t[1] + s[1], t[2] + s[2]),
+        ) {
+            continue;
+        }
         m.extra.variant3 = face;
         events.push(MobEvent::Sound(
             "entity.shulker.teleport",
@@ -106,6 +202,14 @@ fn teleport(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) -> bool {
             f64::from(t[2]) + 0.5,
         );
         m.previous = m.position;
+        // Level.levelEvent(2016, oldPos, packedDiff): the teleport's
+        // particles at both ends, seen by the players around.
+        events.push(MobEvent::LevelEvent {
+            id: 2016,
+            pos: old,
+            data: pack_diff(old, t),
+        });
+        m.needs_sync = true;
         m.extra.counter = 0;
         m.ai.target = None;
         return true;
@@ -127,31 +231,102 @@ fn set_peek(m: &mut Mob, amount: i32, events: &mut Vec<MobEvent>) {
     ));
     m.extra.counter = amount;
 }
-/// `Shulker.tick` additions: keep a face (or teleport), ease the peek,
-/// stay still and square on its block.
+/// `Shulker.updatePeekAmount`/`updatePeekAmountO`: the eased peek.
+fn ease_peek(m: &mut Mob) -> (f32, f32) {
+    let old = m.anim.v[PEEK];
+    let target = m.extra.counter as f32 * 0.01;
+    let new = if old > target {
+        (old - 0.05).clamp(target, 1.0)
+    } else {
+        (old + 0.05).clamp(0.0, target)
+    };
+    m.anim.v[PEEK] = new;
+    (old, new)
+}
+/// `Shulker.tick` additions: keep a face (or teleport), ease the peek
+/// (pushing whatever it opens into), stay still and square on its block.
 pub fn tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     m.velocity = Vec3::ZERO;
     m.body_yaw = 0.0;
     m.yaw = 0.0;
     m.head_pitch = 0.0;
     let p = block_pos(m);
-    if !can_stay_at(w, p, m.extra.variant3) {
-        match attachable(w, p) {
+    if !can_stay_at(m, w, p, m.extra.variant3) {
+        match attachable(m, w, p) {
             Some(f) => m.extra.variant3 = f,
             None => {
                 teleport(m, w, events);
             }
         }
     }
-    let a = &mut m.anim;
-    let target = m.extra.counter as f32 * 0.01;
-    let cur = a.v[PEEK];
-    if cur > target {
-        a.v[PEEK] = (cur - 0.05).clamp(target, 1.0);
-    } else if cur < target {
-        a.v[PEEK] = (cur + 0.05).clamp(0.0, target);
+    let (old, new) = ease_peek(m);
+    if new != old {
+        on_peek_change(m, w, old, new, events);
     }
 }
+/// `Shulker.getPhysicalPeek`: the lid's lift for a peek amount.
+fn physical_peek(amount: f32) -> f64 {
+    f64::from(0.5 - ((0.5 + amount) * PI).msin() * 0.5)
+}
+/// `Shulker.onPeekAmountChange`: an opening shell pushes out of its way
+/// every entity that can be collided with (except other shulkers).
+fn on_peek_change(m: &Mob, w: &MobWorld, old: f32, new: f32, events: &mut Vec<MobEvent>) {
+    let dir = opposite(m.extra.variant3);
+    let s = face_step(dir).map(f64::from);
+    let (old_p, new_p) = (physical_peek(old), physical_peek(new));
+    let push = new_p - old_p;
+    if push <= 0.0 {
+        return;
+    }
+    let delta = [push * s[0], push * s[1], push * s[2]];
+    let area = progress_aabb(dir, old_p, new_p, m.position);
+    if let Some(p) = &w.player
+        && p.alive
+        && !p.spectator
+        && p.bounds.intersects(area)
+    {
+        events.push(MobEvent::Shift {
+            target: Who::Player,
+            delta,
+        });
+    }
+    for seen in w.others_near(area) {
+        if seen.id == m.id
+            || !seen.alive
+            || seen.species == Species::Shulker
+            || !seen.bounds.intersects(area)
+        {
+            continue;
+        }
+        events.push(MobEvent::Shift {
+            target: Who::Mob(seen.id),
+            delta,
+        });
+    }
+}
+/// `ShulkerLookControl.getYRotD`: the look yaw in the open direction's
+/// plane (`None`: the target is on the head's own axis).
+pub fn look_yaw(m: &Mob, at: [f64; 3]) -> Option<f32> {
+    let open = opposite(m.extra.variant3);
+    // `attachFace.getRotation().transform(FORWARD)`: the model's forward
+    // rotated as the renderer does (`rotations` uses the same quats).
+    let forward = face_quat(m.extra.variant3) * glam::Vec3::Z;
+    let s = face_step(open).map(|v| v as f32);
+    let right = glam::Vec3::from_array(s).cross(forward);
+    let out = glam::Vec3::new(
+        (at[0] - m.position.x) as f32,
+        (at[1] - m.eye_y()) as f32,
+        (at[2] - m.position.z) as f32,
+    );
+    let (delta_right, delta_forward) = (right.dot(out), forward.dot(out));
+    if delta_right.abs() <= 1.0e-5 && delta_forward.abs() <= 1.0e-5 {
+        return None;
+    }
+    Some(horizon_core::geometry::trig::atan2_degrees(
+        f64::from(-delta_right),
+        f64::from(delta_forward),
+    ))
+}
 /// `Shulker.hurtServer` before the damage: arrows bounce off a closed shell.
 pub fn accepts(m: &Mob, source: &Damage) -> bool {
     !(m.extra.counter == 0 && source.kind == DamageKind::Arrow)
@@ -319,7 +494,7 @@ impl Goal for Peek {
     fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
         m.ai.target.is_none()
             && m.random.next_int_bound(reduced(40)).unwrap_or(1) == 0
-            && can_stay_at(cx.w, block_pos(m), m.extra.variant3)
+            && can_stay_at(m, cx.w, block_pos(m), m.extra.variant3)
     }
     fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool {
         m.ai.target.is_none() && self.time > 0
@@ -362,24 +537,27 @@ pub fn texture(m: &Mob) -> String {
         None => "entity/shulker/shulker".into(),
     }
 }
+/// `attachFace.getOpposite().getRotation()` by attach face: the open
+/// direction's rotation (`Direction.getRotation` of `face ^ 1`).
+fn face_quat(face: u8) -> glam::Quat {
+    match face.min(5) {
+        // Attached below: upright.
+        0 => glam::Quat::IDENTITY,
+        1 => glam::Quat::from_rotation_x(PI),
+        2 => glam::Quat::from_rotation_x(PI / 2.0),
+        3 => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, PI),
+        4 => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, -PI / 2.0),
+        _ => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, PI / 2.0),
+    }
+}
 /// `ShulkerRenderer.setupRotations`: turned onto its attach face around the
 /// block's centre (after a half turn of the body).
 pub fn rotations(m: &Mob) -> glam::Mat4 {
-    {
-        let q = match m.extra.variant3 {
-            // Attached below: upright.
-            0 => glam::Quat::IDENTITY,
-            1 => glam::Quat::from_rotation_x(PI),
-            2 => glam::Quat::from_rotation_x(PI / 2.0),
-            3 => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, PI),
-            4 => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, -PI / 2.0),
-            _ => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, PI / 2.0),
-        };
-        glam::Mat4::from_rotation_y(PI)
-            * glam::Mat4::from_translation(glam::Vec3::new(0.0, 0.5, 0.0))
-            * glam::Mat4::from_quat(q)
-            * glam::Mat4::from_translation(glam::Vec3::new(0.0, -0.5, 0.0))
-    }
+    let q = face_quat(m.extra.variant3);
+    glam::Mat4::from_rotation_y(PI)
+        * glam::Mat4::from_translation(glam::Vec3::new(0.0, 0.5, 0.0))
+        * glam::Mat4::from_quat(q)
+        * glam::Mat4::from_translation(glam::Vec3::new(0.0, -0.5, 0.0))
 }
 /// `ShulkerModel.setupAnim`: the lid rises and twists with the peek, the
 /// head turns.

From c352c80c9645bd333f630a28dceda2e9035117fc Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:11:32 +0100
Subject: [PATCH 402/475] Books: save a plain page as a string, as
 ComponentSerialization does

Pages kept as components for their click events wrote a plain text page as
{text:"p"}; vanilla's codec writes a component with no style or siblings
as its string (the hotbar harness).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/item_data.rs | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/item_data.rs b/crates/horizon-client/src/item_data.rs
index 856eb2af3..68cb6e299 100644
--- a/crates/horizon-client/src/item_data.rs
+++ b/crates/horizon-client/src/item_data.rs
@@ -296,6 +296,21 @@ fn read_levels(t: Option<&Tag>) -> Levels {
 }
 /// A text component as stored by vanilla: a plain string or `{"text": ...}`.
 /// A `Filterable<String/Component>`: the value itself or `{raw: value}`.
+/// `ComponentSerialization.CODEC`'s short form: a plain text component with
+/// no style and no siblings is written as its string.
+fn plain_component(t: &Tag) -> Tag {
+    if let Tag::Compound(c) = t
+        && let Some(text @ Tag::String(_)) = c.get(&"text".into())
+        && c.iter().all(|(k, v)| {
+            k.to_string_lossy() == "text"
+                || (k.to_string_lossy() == "type"
+                    && matches!(v, Tag::String(s) if s.to_string_lossy() == "text"))
+        })
+    {
+        return text.clone();
+    }
+    t.clone()
+}
 fn filterable_text(t: &Tag) -> Option<String> {
     match t.get("raw") {
         Some(raw) => read_text(raw),
@@ -716,7 +731,7 @@ pub fn decode_components(components: Option<&Tag>) -> (u32, Option<Box<StackData
                 page_tags: match b.get("pages") {
                     Some(Tag::List(pages)) => pages
                         .iter()
-                        .map(|p| p.get("raw").unwrap_or(p).clone())
+                        .map(|p| plain_component(p.get("raw").unwrap_or(p)))
                         .collect(),
                     _ => Vec::new(),
                 },

From ddaa514f3aa4f15a889c8955e3563812defea08e Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:26:42 +0100
Subject: [PATCH 403/475] Launcher: resource and shader packs per instance
 (library and CLI)

packs.rs lists an instance's resource packs (resourcepacks/, a .zip or a
folder with pack.mcmeta) and shader packs (shaderpacks/: Horizon's own and
the shaders/ format, as the game's Shader Packs page lists them), and turns
them on or off the game's own way: resourcePacks in options.txt (a pack
turned on goes on top) and pickedShaderPack in horizon-graphics.txt (one at
a time); every other line of both files stays. add() copies a dropped file
into the right folder under a free name; remove() turns it off and moves it
to the trash.

CLI: `packs [list|add|on|off|remove] [--kind] [--instance]`; `packs remove`
needs confirm over MCP.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md   |  58 +++++++
 launcher/Cargo.lock         |   1 +
 launcher/Cargo.toml         |   1 +
 launcher/src/cli.rs         | 155 +++++++++++++++++
 launcher/src/cli_tools.rs   |   1 +
 launcher/src/lib.rs         |   1 +
 launcher/src/packs.rs       | 338 ++++++++++++++++++++++++++++++++++++
 launcher/src/packs/tests.rs | 174 +++++++++++++++++++
 8 files changed, 729 insertions(+)
 create mode 100644 launcher/src/packs.rs
 create mode 100644 launcher/src/packs/tests.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index e15df1631..db3c6a03a 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -374,6 +374,64 @@ Move a world to the system's trash.
 
 MCP: `worlds_delete`, needs `confirm: true`.
 
+## `horizon-launcher packs list`
+
+The resource and shader packs, and which are on (the default).
+
+    horizon-launcher packs list
+
+- `--kind` (resource, shader): Only this kind
+- `--instance`: The instance (default: the selected one)
+
+MCP: `packs_list`.
+
+## `horizon-launcher packs add`
+
+Copy a pack file in: a resource pack .zip, a shader pack .zip or a .hshader.
+
+    horizon-launcher packs add <FILE>
+
+- `FILE`
+- `--instance`
+
+MCP: `packs_add`.
+
+## `horizon-launcher packs on`
+
+Turn a pack on (a resource pack goes on top; a shader pack replaces the one that was on).
+
+    horizon-launcher packs on <PACK>
+
+- `PACK`: Its file name or title
+- `--kind` (resource, shader)
+- `--instance`
+
+MCP: `packs_on`.
+
+## `horizon-launcher packs off`
+
+Turn a pack off.
+
+    horizon-launcher packs off <PACK>
+
+- `PACK`
+- `--kind` (resource, shader)
+- `--instance`
+
+MCP: `packs_off`.
+
+## `horizon-launcher packs remove`
+
+Turn a pack off and move it to the system's trash.
+
+    horizon-launcher packs remove <PACK>
+
+- `PACK`
+- `--kind` (resource, shader)
+- `--instance`
+
+MCP: `packs_remove`, needs `confirm: true`.
+
 ## `horizon-launcher screenshots list`
 
 The screenshots, the newest first, with their files (the default).
diff --git a/launcher/Cargo.lock b/launcher/Cargo.lock
index bace865b6..422c2ace9 100644
--- a/launcher/Cargo.lock
+++ b/launcher/Cargo.lock
@@ -2764,6 +2764,7 @@ dependencies = [
  "sha1",
  "sha2 0.10.9",
  "tar",
+ "toml 1.1.8+spec-1.1.0",
  "trash",
  "ureq",
  "winresource",
diff --git a/launcher/Cargo.toml b/launcher/Cargo.toml
index 979a781d2..356e8ae2e 100644
--- a/launcher/Cargo.toml
+++ b/launcher/Cargo.toml
@@ -19,6 +19,7 @@ sha2 = "0.10"
 pulldown-cmark = { version = "0.12", default-features = false }
 flate2 = "1"
 tar = { version = "0.4", default-features = false }
+toml = "1.1"
 zip = { version = "2", default-features = false, features = ["deflate"] }
 dirs = "5"
 self-replace = "1"
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 44ae586c9..4b462e9fd 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -214,6 +214,65 @@ enum WorldsCmd {
     },
 }
 
+#[derive(Clone, Copy, clap::ValueEnum)]
+enum PackKindArg {
+    Resource,
+    Shader,
+}
+
+impl From<PackKindArg> for horizon_launcher::packs::Kind {
+    fn from(k: PackKindArg) -> Self {
+        match k {
+            PackKindArg::Resource => Self::Resource,
+            PackKindArg::Shader => Self::Shader,
+        }
+    }
+}
+
+#[derive(Subcommand)]
+enum PacksCmd {
+    /// The resource and shader packs, and which are on (the default)
+    List {
+        /// Only this kind
+        #[arg(long, value_enum)]
+        kind: Option<PackKindArg>,
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Copy a pack file in: a resource pack .zip, a shader pack .zip or a .hshader
+    Add {
+        file: PathBuf,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Turn a pack on (a resource pack goes on top; a shader pack replaces the one that was on)
+    On {
+        /// Its file name or title
+        pack: String,
+        #[arg(long, value_enum, default_value_t = PackKindArg::Resource)]
+        kind: PackKindArg,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Turn a pack off
+    Off {
+        pack: String,
+        #[arg(long, value_enum, default_value_t = PackKindArg::Resource)]
+        kind: PackKindArg,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Turn a pack off and move it to the system's trash
+    Remove {
+        pack: String,
+        #[arg(long, value_enum, default_value_t = PackKindArg::Resource)]
+        kind: PackKindArg,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+}
+
 #[derive(Subcommand)]
 enum ScreenshotsCmd {
     /// The screenshots, the newest first, with their files (the default)
@@ -459,6 +518,11 @@ enum Cmd {
         #[command(subcommand)]
         action: Option<WorldsCmd>,
     },
+    /// An instance's resource and shader packs: list, add, turn on or off, remove
+    Packs {
+        #[command(subcommand)]
+        action: Option<PacksCmd>,
+    },
     /// The screenshots F2 took in an instance: list, delete
     Screenshots {
         #[command(subcommand)]
@@ -933,6 +997,13 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
             action.unwrap_or(WorldsCmd::List { instance: None }),
             as_json,
         )?,
+        Cmd::Packs { action } => game_packs(
+            action.unwrap_or(PacksCmd::List {
+                kind: None,
+                instance: None,
+            }),
+            as_json,
+        )?,
         Cmd::Screenshots { action } => screenshots(
             action.unwrap_or(ScreenshotsCmd::List { instance: None }),
             as_json,
@@ -1568,6 +1639,90 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
     Ok(())
 }
 
+fn game_packs(action: PacksCmd, as_json: bool) -> Result<(), String> {
+    use horizon_launcher::packs::{self, Kind};
+    let home = |instance: Option<String>| -> Result<PathBuf, String> {
+        Ok(match instance {
+            Some(name) => instances::find(&name)?.home,
+            None => instances::selected().home,
+        })
+    };
+    let value = |p: &packs::Pack| {
+        serde_json::json!({
+            "kind": format!("{:?}", p.kind).to_lowercase(), "file": p.file, "title": p.title,
+            "description": p.description, "enabled": p.enabled, "path": p.path,
+        })
+    };
+    match action {
+        PacksCmd::List { kind, instance } => {
+            let home = home(instance)?;
+            let kinds = match kind {
+                Some(k) => vec![Kind::from(k)],
+                None => vec![Kind::Resource, Kind::Shader],
+            };
+            let all: Vec<packs::Pack> = kinds.iter().flat_map(|k| packs::list(&home, *k)).collect();
+            if as_json {
+                json(all.iter().map(value).collect());
+            }
+            for k in kinds.iter().filter(|_| !as_json) {
+                println!("{}:", k.folder());
+                let these: Vec<_> = all.iter().filter(|p| p.kind == *k).collect();
+                if these.is_empty() {
+                    println!("    none");
+                }
+                for p in these {
+                    let on = if p.enabled { "on " } else { "off" };
+                    match p.title == p.file {
+                        true => println!("  {on} {}", p.file),
+                        false => println!("  {on} {} ({})", p.title, p.file),
+                    }
+                }
+            }
+        }
+        PacksCmd::Add { file, instance } => {
+            let pack = packs::add(&home(instance)?, &file)?;
+            match as_json {
+                true => json(value(&pack)),
+                false => println!("Added {} to {} (off).", pack.file, pack.kind.folder()),
+            }
+        }
+        PacksCmd::On {
+            pack,
+            kind,
+            instance,
+        } => set_pack(&home(instance)?, kind.into(), &pack, true)?,
+        PacksCmd::Off {
+            pack,
+            kind,
+            instance,
+        } => set_pack(&home(instance)?, kind.into(), &pack, false)?,
+        PacksCmd::Remove {
+            pack,
+            kind,
+            instance,
+        } => {
+            let home = home(instance)?;
+            let p = packs::find(&home, kind.into(), &pack)?;
+            packs::remove(&home, &p)?;
+            println!("{} is in the trash.", p.file);
+        }
+    }
+    Ok(())
+}
+
+fn set_pack(
+    home: &std::path::Path,
+    kind: horizon_launcher::packs::Kind,
+    query: &str,
+    on: bool,
+) -> Result<(), String> {
+    use horizon_launcher::packs;
+    let pack = packs::find(home, kind, query)?;
+    packs::set_enabled(home, &pack, on)?;
+    println!("{} is {}.", pack.title, if on { "on" } else { "off" });
+    Ok(())
+}
+
 fn screenshots(action: ScreenshotsCmd, as_json: bool) -> Result<(), String> {
     use horizon_launcher::screenshots;
     let home = |instance: Option<String>| -> Result<PathBuf, String> {
diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs
index cad9b95b6..c19f191a2 100644
--- a/launcher/src/cli_tools.rs
+++ b/launcher/src/cli_tools.rs
@@ -29,6 +29,7 @@ pub const DESTRUCTIVE: &[&str] = &[
     "worlds delete",
     "multiplayer remove",
     "screenshots delete",
+    "packs remove",
 ];
 
 /// Commands that send something or reach other people: only when the player asks.
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index 2528239b7..9fafb80f8 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -10,6 +10,7 @@ pub mod heads;
 pub mod instances;
 pub mod modpacks;
 pub mod mojang;
+pub mod packs;
 pub mod process;
 pub mod proxy;
 pub mod screenshots;
diff --git a/launcher/src/packs.rs b/launcher/src/packs.rs
new file mode 100644
index 000000000..260d7f21a
--- /dev/null
+++ b/launcher/src/packs.rs
@@ -0,0 +1,338 @@
+//! An instance's resource packs and shader packs, as the game finds and picks them.
+//!
+//! - Resource packs: `resourcepacks/` in the game folder, each a `.zip` or a folder with a
+//!   `pack.mcmeta`. The ones turned on are `options.txt`'s `resourcePacks` list (vanilla's
+//!   format, `"file/<name>"`, the bottom first), so the game's Resource Packs screen shows the
+//!   same choice. A pack turned on here goes on top, as the screen puts a newly picked one.
+//! - Shader packs: `shaderpacks/`, Horizon's own (a folder with `horizon-shaders.toml`, or a
+//!   `.hshader`) and those in the `shaders/` format (a `.zip`, or a folder with `shaders/`), as
+//!   the game's Shader Packs page lists them (`shader_pack_list`). One at most is on:
+//!   `pickedShaderPack` in `horizon-graphics.txt`.
+//!
+//! Every other line of both files is written back as it was.
+use std::fs;
+use std::io::Read;
+use std::path::{Path, PathBuf};
+
+const OPTIONS: &str = "options.txt";
+const GRAPHICS: &str = "horizon-graphics.txt";
+const SHADER_MANIFEST: &str = "horizon-shaders.toml";
+const SHADER_PACKAGE: &str = "hshader";
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Kind {
+    Resource,
+    Shader,
+}
+
+impl Kind {
+    pub fn folder(self) -> &'static str {
+        match self {
+            Kind::Resource => "resourcepacks",
+            Kind::Shader => "shaderpacks",
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Pack {
+    pub kind: Kind,
+    /// Its file or folder name in the pack folder: the id commands take.
+    pub file: String,
+    pub path: PathBuf,
+    /// A Horizon shader pack's own name, else the file's.
+    pub title: String,
+    /// `pack.mcmeta`'s description as plain text; a shader pack's format.
+    pub description: String,
+    /// `pack.png`, a resource pack's picture.
+    pub icon: Option<Vec<u8>>,
+    pub enabled: bool,
+}
+
+/// The packs of `kind` in the game folder `home`, by name: turning one on or off leaves it where
+/// it is.
+pub fn list(home: &Path, kind: Kind) -> Vec<Pack> {
+    let on = enabled(home, kind);
+    let mut packs: Vec<Pack> = fs::read_dir(home.join(kind.folder()))
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter_map(|e| read(&e.path(), kind, &on))
+        .collect();
+    packs.sort_by_key(|p| p.title.to_lowercase());
+    packs
+}
+
+/// The file names turned on, bottom first.
+fn enabled(home: &Path, kind: Kind) -> Vec<String> {
+    match kind {
+        Kind::Resource => option_list(&fs::read_to_string(home.join(OPTIONS)).unwrap_or_default())
+            .into_iter()
+            .filter_map(|id| id.strip_prefix("file/").map(str::to_string))
+            .collect(),
+        Kind::Shader => line_value(
+            &fs::read_to_string(home.join(GRAPHICS)).unwrap_or_default(),
+            "pickedShaderPack",
+        )
+        .filter(|v| !v.is_empty())
+        .into_iter()
+        .collect(),
+    }
+}
+
+fn read(path: &Path, kind: Kind, on: &[String]) -> Option<Pack> {
+    let file = path.file_name()?.to_str()?.to_string();
+    if file.starts_with('.') {
+        return None;
+    }
+    let ext =
+        |x: &str| path.is_file() && path.extension().is_some_and(|e| e.eq_ignore_ascii_case(x));
+    let (title, description, icon) = match kind {
+        Kind::Resource => {
+            let meta = entry(path, "pack.mcmeta")?;
+            let meta: serde_json::Value = serde_json::from_slice(&meta).ok()?;
+            (
+                file.clone(),
+                plain(&meta["pack"]["description"]),
+                entry(path, "pack.png"),
+            )
+        }
+        Kind::Shader if path.join(SHADER_MANIFEST).is_file() || ext(SHADER_PACKAGE) => {
+            let name = entry(path, SHADER_MANIFEST)
+                .and_then(|t| toml::from_slice::<toml::Table>(&t).ok())
+                .and_then(|t| t.get("name")?.as_str().map(str::to_string));
+            (
+                name.unwrap_or_else(|| file.clone()),
+                "Horizon shader pack".into(),
+                None,
+            )
+        }
+        Kind::Shader if ext("zip") || path.join("shaders").is_dir() => {
+            (file.clone(), "shaders/ format".into(), None)
+        }
+        Kind::Shader => return None,
+    };
+    Some(Pack {
+        kind,
+        enabled: on.contains(&file),
+        path: path.to_path_buf(),
+        file,
+        title,
+        description,
+        icon,
+    })
+}
+
+/// A file at the root of a pack folder or zip, at most 4 MB.
+fn entry(path: &Path, name: &str) -> Option<Vec<u8>> {
+    let mut out = Vec::new();
+    if path.is_dir() {
+        fs::File::open(path.join(name))
+            .ok()?
+            .take(4 << 20)
+            .read_to_end(&mut out)
+            .ok()?;
+    } else {
+        let mut zip = zip::ZipArchive::new(fs::File::open(path).ok()?).ok()?;
+        let entry = zip.by_name(name).ok()?;
+        entry.take(4 << 20).read_to_end(&mut out).ok()?;
+    }
+    Some(out)
+}
+
+/// A text component as plain text: its strings, without `§` formatting codes.
+fn plain(component: &serde_json::Value) -> String {
+    fn walk(v: &serde_json::Value, out: &mut String) {
+        match v {
+            serde_json::Value::String(s) => out.push_str(s),
+            serde_json::Value::Array(a) => a.iter().for_each(|v| walk(v, out)),
+            serde_json::Value::Object(o) => {
+                if let Some(t) = o.get("text").or_else(|| o.get("translate")) {
+                    walk(t, out);
+                }
+                if let Some(extra) = o.get("extra") {
+                    walk(extra, out);
+                }
+            }
+            _ => {}
+        }
+    }
+    let mut raw = String::new();
+    walk(component, &mut raw);
+    let mut out = String::new();
+    let mut chars = raw.chars();
+    while let Some(c) = chars.next() {
+        match c {
+            '§' => {
+                chars.next();
+            }
+            '\n' => out.push(' '),
+            c => out.push(c),
+        }
+    }
+    out.trim().to_string()
+}
+
+/// `key:value` in a `key:value` per line file.
+fn line_value(text: &str, key: &str) -> Option<String> {
+    text.lines()
+        .find_map(|l| l.strip_prefix(key)?.strip_prefix(':'))
+        .map(str::to_string)
+}
+
+/// `resourcePacks:["vanilla","file/x.zip"]` in options.txt.
+fn option_list(options: &str) -> Vec<String> {
+    line_value(options, "resourcePacks")
+        .and_then(|v| serde_json::from_str(&v).ok())
+        .unwrap_or_default()
+}
+
+/// Sets `key:value` in the file, or adds the line; every other line stays.
+fn set_line(path: &Path, key: &str, value: &str) -> Result<(), String> {
+    let text = fs::read_to_string(path).unwrap_or_default();
+    let mut found = false;
+    let mut out: Vec<String> = text
+        .lines()
+        .map(
+            |l| match l.strip_prefix(key).and_then(|r| r.strip_prefix(':')) {
+                Some(_) if !found => {
+                    found = true;
+                    format!("{key}:{value}")
+                }
+                _ => l.to_string(),
+            },
+        )
+        .collect();
+    if !found {
+        out.push(format!("{key}:{value}"));
+    }
+    let mut text = out.join("\n");
+    text.push('\n');
+    if let Some(dir) = path.parent() {
+        fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    }
+    fs::write(path, text).map_err(|e| format!("{}: {e}", path.display()))
+}
+
+/// Turns a pack on or off. A resource pack turned on goes on top; a shader pack turned on
+/// replaces the one that was.
+pub fn set_enabled(home: &Path, pack: &Pack, on: bool) -> Result<(), String> {
+    match pack.kind {
+        Kind::Resource => {
+            let options = home.join(OPTIONS);
+            let text = fs::read_to_string(&options).unwrap_or_default();
+            let id = format!("file/{}", pack.file);
+            let mut list = option_list(&text);
+            list.retain(|i| *i != id);
+            if list.is_empty() {
+                list.push("vanilla".into());
+            }
+            if on {
+                list.push(id.clone());
+            } else {
+                // The game's "use it anyway" answer goes with it.
+                let mut incompatible: Vec<String> = line_value(&text, "incompatibleResourcePacks")
+                    .and_then(|v| serde_json::from_str(&v).ok())
+                    .unwrap_or_default();
+                if incompatible.contains(&id) {
+                    incompatible.retain(|i| *i != id);
+                    let value = serde_json::to_string(&incompatible).unwrap();
+                    set_line(&options, "incompatibleResourcePacks", &value)?;
+                }
+            }
+            set_line(
+                &options,
+                "resourcePacks",
+                &serde_json::to_string(&list).unwrap(),
+            )
+        }
+        Kind::Shader => {
+            let value = if on { pack.file.as_str() } else { "" };
+            set_line(&home.join(GRAPHICS), "pickedShaderPack", value)
+        }
+    }
+}
+
+/// The pack a command names: its file name, or its title (any case).
+pub fn find(home: &Path, kind: Kind, query: &str) -> Result<Pack, String> {
+    let all = list(home, kind);
+    all.iter()
+        .find(|p| p.file == query)
+        .or_else(|| all.iter().find(|p| p.title.eq_ignore_ascii_case(query)))
+        .cloned()
+        .ok_or_else(|| format!("No pack {query} in {}", home.join(kind.folder()).display()))
+}
+
+/// What a dropped or picked file is: a resource pack (a zip with `pack.mcmeta`), a Horizon
+/// shader pack (`.hshader`), or a shader pack in the `shaders/` format (a zip with `shaders/`).
+pub fn kind_of(file: &Path) -> Result<Kind, String> {
+    let name = file
+        .file_name()
+        .map(|n| n.to_string_lossy().into_owned())
+        .unwrap_or_default();
+    let ext = file
+        .extension()
+        .map(|e| e.to_string_lossy().to_ascii_lowercase());
+    match ext.as_deref() {
+        Some(SHADER_PACKAGE) => return Ok(Kind::Shader),
+        Some("zip") => {}
+        _ => {
+            return Err(format!(
+                "{name} is not a pack: packs are .zip or .hshader files."
+            ))
+        }
+    }
+    let zip = fs::File::open(file)
+        .ok()
+        .and_then(|f| zip::ZipArchive::new(f).ok())
+        .ok_or_else(|| format!("{name} is not a zip file that can be read."))?;
+    if zip.index_for_name("pack.mcmeta").is_some() {
+        Ok(Kind::Resource)
+    } else if zip.file_names().any(|n| n.starts_with("shaders/")) {
+        Ok(Kind::Shader)
+    } else {
+        Err(format!(
+            "{name} has neither a pack.mcmeta (a resource pack) nor a shaders folder (a shader pack)."
+        ))
+    }
+}
+
+/// Copies a pack file into the right folder of `home`, under a name not taken yet. Returns it,
+/// turned off.
+pub fn add(home: &Path, file: &Path) -> Result<Pack, String> {
+    let kind = kind_of(file)?;
+    let dir = home.join(kind.folder());
+    fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let name = file.file_name().ok_or("A pack file has a name")?;
+    let stem = Path::new(name)
+        .file_stem()
+        .unwrap_or(name)
+        .to_string_lossy();
+    let ext = Path::new(name)
+        .extension()
+        .map(|e| format!(".{}", e.to_string_lossy()))
+        .unwrap_or_default();
+    let target = (1..)
+        .map(|n| match n {
+            1 => dir.join(name),
+            n => dir.join(format!("{stem} ({n}){ext}")),
+        })
+        .find(|p| !p.exists())
+        .unwrap();
+    fs::copy(file, &target).map_err(|e| format!("Could not copy {}: {e}", file.display()))?;
+    read(&target, kind, &[])
+        .ok_or_else(|| format!("{} is not a pack the game reads", target.display()))
+}
+
+/// Turns the pack off and moves it to the system's trash.
+pub fn remove(home: &Path, pack: &Pack) -> Result<(), String> {
+    if pack.enabled {
+        set_enabled(home, pack, false)?;
+    }
+    crate::worlds::to_trash(&pack.path)
+        .map_err(|e| format!("Could not move {} to the trash: {e}", pack.file))
+}
+
+#[cfg(test)]
+#[path = "packs/tests.rs"]
+mod tests;
diff --git a/launcher/src/packs/tests.rs b/launcher/src/packs/tests.rs
new file mode 100644
index 000000000..05a2c6b94
--- /dev/null
+++ b/launcher/src/packs/tests.rs
@@ -0,0 +1,174 @@
+use super::*;
+use std::io::Write;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-packs-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+fn zip_file(path: &Path, files: &[(&str, &[u8])]) {
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    let mut zip = zip::ZipWriter::new(fs::File::create(path).unwrap());
+    for (name, bytes) in files {
+        zip.start_file(*name, zip::write::SimpleFileOptions::default())
+            .unwrap();
+        zip.write_all(bytes).unwrap();
+    }
+    zip.finish().unwrap();
+}
+
+const META: &[u8] = "{\"pack\":{\"pack_format\":69,\"description\":[\"\",{\"text\":\"Smooth \u{a7}aglass\"},\"\\nand more\"]}}"
+    .as_bytes();
+
+/// A game folder with three resource packs (one on), and shader packs of both kinds.
+fn home(name: &str) -> PathBuf {
+    let home = scratch(name);
+    let rp = home.join("resourcepacks");
+    zip_file(
+        &rp.join("Glass.zip"),
+        &[("pack.mcmeta", META), ("pack.png", b"png")],
+    );
+    zip_file(&rp.join("Broken.zip"), &[("readme.txt", b"no meta")]);
+    fs::create_dir_all(rp.join("Folder Pack")).unwrap();
+    fs::write(
+        rp.join("Folder Pack/pack.mcmeta"),
+        br#"{"pack":{"description":"Mine"}}"#,
+    )
+    .unwrap();
+    zip_file(&rp.join("Zed.zip"), &[("pack.mcmeta", META)]);
+    let sp = home.join("shaderpacks");
+    fs::create_dir_all(sp.join("warm")).unwrap();
+    fs::write(
+        sp.join("warm/horizon-shaders.toml"),
+        "schema = 1\nid = \"warm\"\nname = \"Warm Light\"\n",
+    )
+    .unwrap();
+    zip_file(&sp.join("Classic.zip"), &[("shaders/final.fsh", b"")]);
+    fs::write(sp.join("notes.txt"), b"").unwrap();
+    fs::write(
+        home.join("options.txt"),
+        "version:4786\nresourcePacks:[\"vanilla\",\"file/Zed.zip\"]\nincompatibleResourcePacks:[\"file/Zed.zip\"]\nlang:fr_ch\n",
+    )
+    .unwrap();
+    fs::write(
+        home.join("horizon-graphics.txt"),
+        "preset:custom\npickedShaderPack:\nfxaa:true\n",
+    )
+    .unwrap();
+    home
+}
+
+#[test]
+fn lists_what_the_game_reads_and_which_are_on() {
+    let home = home("list");
+    let rp = list(&home, Kind::Resource);
+    let names: Vec<(&str, bool)> = rp.iter().map(|p| (p.file.as_str(), p.enabled)).collect();
+    assert_eq!(
+        names,
+        [
+            ("Folder Pack", false),
+            ("Glass.zip", false),
+            ("Zed.zip", true)
+        ],
+        "by name; the pack without pack.mcmeta is left out, as the game does"
+    );
+    let glass = &rp[1];
+    assert_eq!(glass.description, "Smooth glass and more");
+    assert_eq!(glass.icon.as_deref(), Some(&b"png"[..]));
+    let sp = list(&home, Kind::Shader);
+    let names: Vec<&str> = sp.iter().map(|p| p.title.as_str()).collect();
+    assert_eq!(names, ["Classic.zip", "Warm Light"]);
+    assert!(list(&home.join("none"), Kind::Shader).is_empty());
+    fs::remove_dir_all(&home).unwrap();
+}
+
+#[test]
+fn turning_packs_on_and_off_writes_the_games_own_lines() {
+    let home = home("toggle");
+    let glass = find(&home, Kind::Resource, "Glass.zip").unwrap();
+    set_enabled(&home, &glass, true).unwrap();
+    let folder = find(&home, Kind::Resource, "folder pack").unwrap();
+    set_enabled(&home, &folder, true).unwrap();
+    assert!(
+        fs::read_to_string(home.join("options.txt")).unwrap().contains(
+            "resourcePacks:[\"vanilla\",\"file/Zed.zip\",\"file/Glass.zip\",\"file/Folder Pack\"]\n"
+        ),
+        "the newest on top"
+    );
+    let zed = find(&home, Kind::Resource, "Zed.zip").unwrap();
+    set_enabled(&home, &zed, false).unwrap();
+    assert_eq!(
+        fs::read_to_string(home.join("options.txt")).unwrap(),
+        "version:4786\nresourcePacks:[\"vanilla\",\"file/Glass.zip\",\"file/Folder Pack\"]\nincompatibleResourcePacks:[]\nlang:fr_ch\n"
+    );
+
+    let warm = find(&home, Kind::Shader, "Warm Light").unwrap();
+    set_enabled(&home, &warm, true).unwrap();
+    let classic = find(&home, Kind::Shader, "Classic.zip").unwrap();
+    set_enabled(&home, &classic, true).unwrap();
+    assert_eq!(
+        fs::read_to_string(home.join("horizon-graphics.txt")).unwrap(),
+        "preset:custom\npickedShaderPack:Classic.zip\nfxaa:true\n",
+        "one shader pack at a time"
+    );
+    set_enabled(
+        &home,
+        &find(&home, Kind::Shader, "Classic.zip").unwrap(),
+        false,
+    )
+    .unwrap();
+    assert!(list(&home, Kind::Shader).iter().all(|p| !p.enabled));
+
+    // A fresh instance has neither file yet.
+    let fresh = scratch("fresh");
+    fs::create_dir_all(fresh.join("resourcepacks")).unwrap();
+    fs::copy(
+        home.join("resourcepacks/Zed.zip"),
+        fresh.join("resourcepacks/Zed.zip"),
+    )
+    .unwrap();
+    set_enabled(
+        &fresh,
+        &find(&fresh, Kind::Resource, "Zed.zip").unwrap(),
+        true,
+    )
+    .unwrap();
+    assert_eq!(
+        fs::read_to_string(fresh.join("options.txt")).unwrap(),
+        "resourcePacks:[\"vanilla\",\"file/Zed.zip\"]\n"
+    );
+    fs::remove_dir_all(&home).unwrap();
+    fs::remove_dir_all(&fresh).unwrap();
+}
+
+#[test]
+fn a_dropped_file_goes_to_its_folder_under_a_free_name() {
+    let home = home("add");
+    let drops = scratch("drops");
+    zip_file(&drops.join("Zed.zip"), &[("pack.mcmeta", META)]);
+    zip_file(&drops.join("Shiny.zip"), &[("shaders/composite.fsh", b"")]);
+    fs::write(drops.join("glow.hshader"), b"PK").unwrap();
+    zip_file(&drops.join("random.zip"), &[("a.txt", b"")]);
+    fs::write(drops.join("picture.png"), b"").unwrap();
+
+    let added = add(&home, &drops.join("Zed.zip")).unwrap();
+    assert_eq!(
+        (added.kind, added.file.as_str(), added.enabled),
+        (Kind::Resource, "Zed (2).zip", false)
+    );
+    assert_eq!(
+        add(&home, &drops.join("Shiny.zip")).unwrap().kind,
+        Kind::Shader
+    );
+    assert!(home.join("shaderpacks/Shiny.zip").is_file());
+    assert_eq!(kind_of(&drops.join("glow.hshader")).unwrap(), Kind::Shader);
+    assert!(add(&home, &drops.join("random.zip")).is_err());
+    assert!(add(&home, &drops.join("picture.png")).is_err());
+    fs::remove_dir_all(&home).unwrap();
+    fs::remove_dir_all(&drops).unwrap();
+}

From e5c3d7cff7e5db03ccf11daacf7570e3365ae47b Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:26:42 +0100
Subject: [PATCH 404/475] Launcher: Packs section on Home, with drag and drop
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Home lists the selected instance's resource and shader packs with a switch
each (disabled while the game runs: it rewrites options.txt itself), Remove
after a confirmation, and Add pack… or a .zip/.hshader dropped on the
section. switch() now takes any id.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 launcher/README.md         |   9 ++
 launcher/src/main.rs       |  12 +-
 launcher/src/packs_page.rs | 306 +++++++++++++++++++++++++++++++++++++
 3 files changed, 325 insertions(+), 2 deletions(-)
 create mode 100644 launcher/src/packs_page.rs

diff --git a/launcher/README.md b/launcher/README.md
index aeeb4f288..e1a9150d0 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -89,6 +89,13 @@ The opening, then Play ([clip](docs/opening.webm)):
   system's trash after a confirmation; **Open folder**. The same from the command line:
   `horizon-launcher worlds [list|backup|copy|delete] [--instance <name>]`.
   **Play** on a world starts the game straight into it.
+- **Packs**: Home lists the selected instance's resource packs and shader packs, each with a switch.
+  The choice is the game's own: `resourcePacks` in options.txt (a pack turned on goes on top, as
+  the game's Resource Packs screen does) and `pickedShaderPack` in `horizon-graphics.txt` (one shader
+  pack at a time). **Add pack…** or a `.zip` / `.hshader` dropped on the section copies it into the
+  right folder; **Remove** turns it off and moves it to the trash after a confirmation. From the
+  command line: `horizon-launcher packs [list|add|on|off|remove] [--kind resource|shader]
+  [--instance <name>]`.
 - **Screenshots**: Home shows the selected instance's newest screenshots (what F2 saves in its
   `screenshots/` folder) and all of them on request. Clicking one opens it over the window (← and →
   step through) with **Copy** (the picture, to the clipboard), **Open**, **Show in folder** and
@@ -202,6 +209,8 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
     horizon-launcher instance version <instance> <tag|latest>   keep it on one installed version, or follow updates
     horizon-launcher worlds [list] [--instance <name>]        an instance's worlds
     horizon-launcher worlds backup|copy|delete <world> [--instance <name>]   delete moves it to the trash
+    horizon-launcher packs [list] [--kind resource|shader] [--instance <name>]   resource and shader packs, on or off
+    horizon-launcher packs add <file> | on|off|remove <pack> [--kind shader]
     horizon-launcher screenshots [list] [--instance <name>]   an instance's screenshots, the newest first
     horizon-launcher screenshots delete <name> [--instance <name>]   moves it to the trash
     horizon-launcher multiplayer [list] [--instance <name>]   the servers in an instance's Multiplayer list
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 67ef0ac39..0542d7504 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -20,6 +20,7 @@ mod modpacks_page;
 mod mods_page;
 mod mods_project;
 mod multiplayer_page;
+mod packs_page;
 mod partner;
 mod perf;
 mod screenshots_page;
@@ -237,6 +238,7 @@ struct Launcher {
     worlds: worlds_page::Worlds,
     multiplayer: multiplayer_page::Multiplayer,
     screenshots: screenshots_page::Screenshots,
+    game_packs: packs_page::Packs,
     /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar.
     offline_name: Option<String>,
     /// The player's servers, for the sidebar until the Servers page has read them.
@@ -399,6 +401,7 @@ impl Launcher {
             worlds: worlds_page::Worlds::default(),
             multiplayer: multiplayer_page::Multiplayer::default(),
             screenshots: screenshots_page::Screenshots::default(),
+            game_packs: packs_page::Packs::default(),
             offline_name: offline_name(),
             side_servers: horizon_launcher::servers::list(),
             art: art::Art::default(),
@@ -712,6 +715,7 @@ impl Launcher {
                             self.worlds.stale();
                             self.multiplayer.stale();
                             self.screenshots.stale();
+                            self.game_packs.stale();
                             if let Some((id, started)) = self.client_run.take() {
                                 if let Err(e) = instances::record_play(&id, started.elapsed()) {
                                     eprintln!("Play time not saved: {e}");
@@ -1189,10 +1193,11 @@ fn button(
 }
 
 /// An on/off switch: a square knob sliding in a sunk track that turns violet when on.
-fn switch(id: &'static str, on: bool, t: &Theme) -> Stateful<Div> {
+fn switch(id: impl Into<SharedString>, on: bool, t: &Theme) -> Stateful<Div> {
     let t = *t;
+    let id: SharedString = id.into();
     let knob = if on { t.on_face } else { t.muted };
-    keyboard(div().id(id), &t)
+    keyboard(div().id(id.clone()), &t)
         .relative()
         .flex_none()
         .w(px(44.))
@@ -2204,6 +2209,9 @@ impl Launcher {
         if let Some(servers) = self.multiplayer_section(cx) {
             page = page.child(servers);
         }
+        if let Some(packs) = self.packs_section(cx) {
+            page = page.child(packs);
+        }
         if let Some(shots) = self.screenshots_section(cx) {
             page = page.child(shots);
         }
diff --git a/launcher/src/packs_page.rs b/launcher/src/packs_page.rs
new file mode 100644
index 000000000..b497afa44
--- /dev/null
+++ b/launcher/src/packs_page.rs
@@ -0,0 +1,306 @@
+//! The selected instance's resource packs and shader packs on Home (`horizon_launcher::packs`):
+//! each turned on or off with one click, Remove (to the trash, after a confirmation), and
+//! Add (a file picker) or a .zip or .hshader dropped anywhere on the section.
+use super::*;
+use gpui::{ExternalPaths, Image, ImageFormat};
+use horizon_launcher::packs::{self, Kind as PackKind, Pack};
+use std::path::PathBuf;
+use std::sync::Arc;
+
+#[derive(Default)]
+pub(super) struct Packs {
+    home: Option<PathBuf>,
+    resource: Vec<(Pack, Option<Arc<Image>>)>,
+    shader: Vec<Pack>,
+    fresh: bool,
+    /// The pack waiting for its removal to be confirmed: its kind and file.
+    confirm_remove: Option<(PackKind, String)>,
+    /// What the last action did, or why it failed.
+    note: Option<Result<String, String>>,
+}
+
+impl Packs {
+    pub(super) fn stale(&mut self) {
+        self.fresh = false;
+    }
+}
+
+impl Launcher {
+    fn load_packs_list(&mut self, home: PathBuf) {
+        if self.game_packs.home.as_ref() != Some(&home) {
+            self.game_packs = Packs {
+                home: Some(home.clone()),
+                ..Packs::default()
+            };
+        }
+        if self.game_packs.fresh {
+            return;
+        }
+        // A few small reads per pack (pack.mcmeta, pack.png): fine while drawing.
+        self.game_packs.resource = packs::list(&home, PackKind::Resource)
+            .into_iter()
+            .map(|p| {
+                let icon = p
+                    .icon
+                    .clone()
+                    .map(|png| Arc::new(Image::from_bytes(ImageFormat::Png, png)));
+                (p, icon)
+            })
+            .collect();
+        self.game_packs.shader = packs::list(&home, PackKind::Shader);
+        self.game_packs.fresh = true;
+    }
+
+    fn pack_action(&mut self, act: impl FnOnce(&std::path::Path) -> Result<String, String>) {
+        let Some(home) = self.game_packs.home.clone() else {
+            return;
+        };
+        self.game_packs.note = Some(act(&home));
+        self.game_packs.confirm_remove = None;
+        self.game_packs.stale();
+    }
+
+    /// Copies dropped or picked files into the instance's pack folders.
+    fn add_packs(&mut self, files: Vec<PathBuf>) {
+        self.pack_action(|home| {
+            let mut added = Vec::new();
+            for file in &files {
+                added.push(packs::add(home, file)?.title);
+            }
+            Ok(format!("Added {}: turn it on below.", added.join(", ")))
+        });
+    }
+
+    fn choose_packs(&mut self, cx: &mut Context<Self>) {
+        let paths = cx.prompt_for_paths(PathPromptOptions {
+            files: true,
+            directories: false,
+            multiple: true,
+            prompt: Some("Add".into()),
+        });
+        cx.spawn(async move |this, cx| {
+            if let Ok(Ok(Some(paths))) = paths.await {
+                let _ = this.update(cx, |this, cx| {
+                    this.add_packs(paths);
+                    cx.notify();
+                });
+            }
+        })
+        .detach();
+    }
+
+    /// Home's Packs section, for the selected instance.
+    pub(super) fn packs_section(&mut self, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
+        let t = self.theme;
+        let home = self.selected_instance()?.home.clone();
+        self.load_packs_list(home.clone());
+        let header =
+            div()
+                .flex()
+                .items_center()
+                .justify_between()
+                .mb(px(4.))
+                .child(section_title("Packs", "package", &t))
+                .child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .gap(px(6.))
+                        .child(button("packs-add", "Add pack…", Kind::Ghost, &t).on_click(
+                            cx.listener(|this, _: &ClickEvent, _, cx| {
+                                this.choose_packs(cx);
+                                cx.notify();
+                            }),
+                        ))
+                        .child(
+                            button("packs-folder", "Open folder", Kind::Ghost, &t).on_click(
+                                move |_, _, cx| {
+                                    let dir = home.join(PackKind::Resource.folder());
+                                    let _ = std::fs::create_dir_all(&dir);
+                                    cx.open_with_system(&dir);
+                                },
+                            ),
+                        ),
+                );
+        let mut section = div()
+            .id("packs")
+            .flex()
+            .flex_col()
+            .gap(px(8.))
+            // The drop outline sits just outside the rows, which line up with the other sections.
+            .p(px(2.))
+            .mx(px(-4.))
+            .border_2()
+            .border_color(gpui::transparent_black())
+            .drag_over::<ExternalPaths>(move |s, _, _, _| s.border_color(t.accent).bg(t.well))
+            .on_drop(cx.listener(|this, paths: &ExternalPaths, _, cx| {
+                this.add_packs(paths.paths().to_vec());
+                cx.notify();
+            }))
+            .child(header);
+        match &self.game_packs.note {
+            Some(Ok(m)) => {
+                section = section.child(text(theme::CAPTION).text_color(t.muted).child(m.clone()))
+            }
+            Some(Err(e)) => section = section.child(notice(e.clone(), &t)),
+            None => {}
+        }
+        if self.client.is_some() {
+            section = section.child(text(theme::CAPTION).text_color(t.muted).child(
+                "The game is running: change packs in its own menus, or here once it is closed.",
+            ));
+        }
+        let resource = self.game_packs.resource.clone();
+        section = section.child(caps("Resource packs").text_color(t.muted).mt(px(4.)));
+        if resource.is_empty() {
+            section = section.child(
+                text(theme::CAPTION)
+                    .text_color(t.muted)
+                    .child("None yet: drop a .zip here, or find some on the Mods page."),
+            );
+        }
+        for (i, (pack, icon)) in resource.into_iter().enumerate() {
+            section = section.child(self.pack_row(i, pack, icon, cx));
+        }
+        let shader = self.game_packs.shader.clone();
+        section = section.child(caps("Shader packs").text_color(t.muted).mt(px(8.)));
+        if shader.is_empty() {
+            section = section.child(
+                text(theme::CAPTION)
+                    .text_color(t.muted)
+                    .child("None yet: drop a .hshader or a shader pack .zip here."),
+            );
+        }
+        for (i, pack) in shader.into_iter().enumerate() {
+            section = section.child(self.pack_row(i, pack, None, cx));
+        }
+        Some(section)
+    }
+
+    fn pack_row(
+        &mut self,
+        i: usize,
+        pack: Pack,
+        icon: Option<Arc<Image>>,
+        cx: &mut Context<Self>,
+    ) -> Div {
+        let t = self.theme;
+        let id = |what: &str| {
+            SharedString::from(format!("pack-{what}-{:?}-{i}", pack.kind).to_lowercase())
+        };
+        let picture = div()
+            .flex()
+            .flex_none()
+            .items_center()
+            .justify_center()
+            .size(px(40.))
+            .border_2()
+            .border_color(t.outline)
+            .bg(t.well);
+        let picture = match icon {
+            Some(image) => picture.child(gpui::img(image).size(px(36.))),
+            None => picture.child(blocks::icon(
+                if pack.kind == PackKind::Shader {
+                    "zap"
+                } else {
+                    "package"
+                },
+                18.,
+                t.muted,
+            )),
+        };
+        let running = self.client.is_some();
+        let mut actions = div().flex().items_center().gap(px(6.));
+        let key = (pack.kind, pack.file.clone());
+        if self.game_packs.confirm_remove.as_ref() == Some(&key) {
+            let gone = pack.clone();
+            actions = actions
+                .child(
+                    text(theme::CAPTION)
+                        .text_color(t.danger)
+                        .child("Move it to the trash?"),
+                )
+                .child(
+                    button(id("keep"), "Keep", Kind::Ghost, &t).on_click(cx.listener(
+                        |this, _: &ClickEvent, _, cx| {
+                            this.game_packs.confirm_remove = None;
+                            cx.notify();
+                        },
+                    )),
+                )
+                .child(
+                    button(id("trash"), "Move to trash", Kind::Secondary, &t).on_click(
+                        cx.listener(move |this, _: &ClickEvent, _, cx| {
+                            let gone = gone.clone();
+                            this.pack_action(move |home| {
+                                packs::remove(home, &gone)
+                                    .map(|()| format!("{} moved to the trash.", gone.title))
+                            });
+                            cx.notify();
+                        }),
+                    ),
+                );
+        } else {
+            let toggle = switch(id("toggle"), pack.enabled, &t);
+            let flip = pack.clone();
+            let toggle = if running {
+                disabled(toggle)
+            } else {
+                toggle.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                    let flip = flip.clone();
+                    this.pack_action(move |home| {
+                        packs::set_enabled(home, &flip, !flip.enabled).map(|()| {
+                            match flip.enabled {
+                                true => format!("{} is off.", flip.title),
+                                false => format!("{} is on.", flip.title),
+                            }
+                        })
+                    });
+                    cx.notify();
+                }))
+            };
+            let remove = button(id("remove"), "Remove", Kind::Ghost, &t);
+            let remove = if running {
+                disabled(remove)
+            } else {
+                remove.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                    this.game_packs.confirm_remove = Some(key.clone());
+                    cx.notify();
+                }))
+            };
+            actions = actions.child(toggle).child(remove);
+        }
+        let facts = match pack.description.is_empty() {
+            true => pack.file.clone(),
+            false if pack.title == pack.file => pack.description.clone(),
+            false => format!("{} · {}", pack.description, pack.file),
+        };
+        plate(&t)
+            .flex()
+            .items_center()
+            .gap(px(14.))
+            .px(px(14.))
+            .py(px(8.))
+            .child(picture)
+            .child(
+                div()
+                    .flex()
+                    .flex_col()
+                    .flex_1()
+                    .min_w_0()
+                    .child(
+                        blocks::pixel(14., FontWeight::MEDIUM)
+                            .text_color(if pack.enabled { t.ink } else { t.muted })
+                            .truncate()
+                            .child(pack.title.clone()),
+                    )
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .truncate()
+                            .child(facts),
+                    ),
+            )
+            .child(actions)
+    }
+}

From 7732ce986fb73be94434335d21e34fbb0d17e067 Mon Sep 17 00:00:00 2001
From: socksprox <info@shadowfly.net>
Date: Tue, 27 Oct 2026 02:31:11 +0100
Subject: [PATCH 405/475] Drop a client's remembered effects when it joins a
 world

A rejoining player kept the previous session's effect list, so the HUD
could show effects the server no longer had (nothing applied in combat,
no icon was earned). Vanilla's new LocalPlayer starts empty and gets its
effects from UpdateMobEffect; match that, and let the client-side tick
drop effects whose duration ran out, as its removeIf does.

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 crates/horizon-client/src/game/potions.rs | 6 ++++--
 crates/horizon-client/src/game/remote.rs  | 3 +++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index 2ccfd4116..6334ff5ad 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -427,9 +427,11 @@ impl Game<'_> {
     /// `MobEffectInstance.tickClient`): they count down, and the server
     /// removes them. Their modifiers and flags move the predicted player.
     pub(super) fn tick_client_effects(&mut self) {
-        for e in &mut self.potions.effects.list {
+        // LivingEntity.tickEffects (client): an exhausted effect drops.
+        self.potions.effects.list.retain_mut(|e| {
             e.tick_client();
-        }
+            e.duration != 0
+        });
         self.apply_effect_status();
     }
     /// Add an active effect to the player and update attributes / absorption.
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..47846735a 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -394,6 +394,9 @@ impl Game<'_> {
         self.carried = None;
         self.using = None;
         self.clicks.miss_time = 0;
+        // A new LocalPlayer has no effects: the server sends what it has
+        // (ClientboundUpdateMobEffectPacket on placement).
+        self.potions = Default::default();
         self.set_mode_id(0);
         self.experience = Experience {
             level: 0,

From 8866e618b5ca736ea430bc8e7f012791c2bd21b6 Mon Sep 17 00:00:00 2001
From: DanielGodriNeto <godrineto@gmail.com>
Date: Mon, 26 Oct 2026 22:31:59 -0300
Subject: [PATCH 406/475] perf(light): cache touched sections during relight

Relight now runs over a Region that clones each touched section's Arc once,
copies its light on first write and writes back only sections whose light
changed. The increase loop reads state and light in one lookup. Output is
identical; a randomized border test checks it against a full relight.

Co-Authored-By: Claude <noreply@anthropic.com>
---
 crates/horizon-client/src/chunk_map.rs |  19 +-
 crates/horizon-client/src/light.rs     | 410 +++++++++++++++++++------
 2 files changed, 334 insertions(+), 95 deletions(-)

diff --git a/crates/horizon-client/src/chunk_map.rs b/crates/horizon-client/src/chunk_map.rs
index ed25491c5..fddded9e1 100644
--- a/crates/horizon-client/src/chunk_map.rs
+++ b/crates/horizon-client/src/chunk_map.rs
@@ -76,14 +76,11 @@ impl<'a> IntoIterator for &'a ChunkMap {
     }
 }
 impl crate::light::LightWorld for ChunkMap {
-    fn state(&self, x: i32, y: i32, z: i32) -> Option<u32> {
-        self.columns.state(x, y, z)
+    fn section(&self, cx: i32, s: usize, cz: i32) -> Option<&Arc<crate::chunk::Section>> {
+        self.columns.section(cx, s, cz)
     }
-    fn light(&self, x: i32, y: i32, z: i32) -> Option<u8> {
-        self.columns.light(x, y, z)
-    }
-    fn set_light(&mut self, x: i32, y: i32, z: i32, packed: u8) {
-        self.columns.set_light(x, y, z, packed);
+    fn set_section_light(&mut self, cx: i32, s: usize, cz: i32, light: crate::chunk::Light) {
+        self.columns.set_section_light(cx, s, cz, light);
     }
 }
 
@@ -106,7 +103,13 @@ mod tests {
         for column in map.values_mut() {
             Arc::make_mut(column).light_loaded = true;
         }
-        crate::light::LightWorld::set_light(&mut map, 0, 0, 0, 0);
+        crate::light::LightWorld::set_section_light(
+            &mut map,
+            0,
+            0,
+            0,
+            crate::chunk::Light::Uniform(0),
+        );
         assert_eq!(inserted, map.membership_revision());
         map.remove(&(0, 0));
         map.insert((1, 0), chunk);
diff --git a/crates/horizon-client/src/light.rs b/crates/horizon-client/src/light.rs
index 6cb4b65b1..c8313c3d7 100644
--- a/crates/horizon-client/src/light.rs
+++ b/crates/horizon-client/src/light.rs
@@ -17,7 +17,7 @@
 use crate::fast_hash::FxHashMap;
 use crate::{
     blocks::BlockFacts,
-    chunk::{Chunk, HEIGHT, Light, MIN_Y, SECTIONS, index},
+    chunk::{Chunk, HEIGHT, Light, MIN_Y, SECTIONS, Section, index},
 };
 use horizon_core::geometry::{Direction, ShapeOp, VoxelShape};
 use horizon_world::registry::{BlockRegistry, BlockStateId};
@@ -565,43 +565,130 @@ pub fn update_light_layers<L: AsRef<[u8]>>(
 
 /// Resident chunks the incremental relighter reads and writes.
 pub trait LightWorld {
-    fn state(&self, x: i32, y: i32, z: i32) -> Option<u32>;
-    /// Packed light (sky << 4 | block), None outside loaded chunks.
-    fn light(&self, x: i32, y: i32, z: i32) -> Option<u8>;
-    fn set_light(&mut self, x: i32, y: i32, z: i32, packed: u8);
+    /// Section `s` of chunk (cx, cz), None unless the chunk is loaded and lit.
+    fn section(&self, cx: i32, s: usize, cz: i32) -> Option<&Arc<Section>>;
+    /// Replace the light of a section `section` returned.
+    fn set_section_light(&mut self, cx: i32, s: usize, cz: i32, light: Light);
 }
 impl<S: std::hash::BuildHasher> LightWorld for HashMap<(i32, i32), Arc<Chunk>, S> {
-    fn state(&self, x: i32, y: i32, z: i32) -> Option<u32> {
+    fn section(&self, cx: i32, s: usize, cz: i32) -> Option<&Arc<Section>> {
+        self.get(&(cx, cz))
+            .filter(|c| c.lit)
+            .map(|c| &c.sections[s])
+    }
+    fn set_section_light(&mut self, cx: i32, s: usize, cz: i32, light: Light) {
+        if let Some(chunk) = self.get_mut(&(cx, cz)) {
+            Arc::make_mut(&mut Arc::make_mut(chunk).sections[s]).light = light;
+        }
+    }
+}
+/// The sections one relight touches, held for the whole flood fill so each
+/// cell access is an array index instead of a chunk lookup. Light a section
+/// gets written is copied out on the first write and stored back by `finish`.
+struct Region<'w> {
+    world: &'w mut dyn LightWorld,
+    slots: Vec<Slot>,
+    /// Section key (cx, s, cz) to slot, `NONE` where the chunk isn't lit.
+    index: FxHashMap<Pos, u32>,
+    last: (Pos, u32),
+}
+struct Slot {
+    key: Pos,
+    /// The world's section; its light is the value before this relight.
+    section: Arc<Section>,
+    light: Option<Box<[u8; 4096]>>,
+}
+const NONE: u32 = u32::MAX;
+impl<'w> Region<'w> {
+    fn new(world: &'w mut dyn LightWorld) -> Self {
+        Self {
+            world,
+            slots: Vec::new(),
+            index: FxHashMap::default(),
+            last: ((i32::MIN, 0, 0), NONE),
+        }
+    }
+    #[inline]
+    fn slot(&mut self, x: i32, y: i32, z: i32) -> Option<usize> {
         if !(MIN_Y..MIN_Y + HEIGHT).contains(&y) {
             return None;
         }
-        self.get(&(x >> 4, z >> 4))
-            .filter(|c| c.lit)
-            .map(|c| c.get(x & 15, y, z & 15))
-    }
-    fn light(&self, x: i32, y: i32, z: i32) -> Option<u8> {
-        if !(MIN_Y..MIN_Y + HEIGHT).contains(&y) {
-            return None;
+        let key = (x >> 4, (y - MIN_Y) >> 4, z >> 4);
+        if self.last.0 != key {
+            self.last = (key, self.load(key));
         }
-        self.get(&(x >> 4, z >> 4))
-            .filter(|c| c.lit)
-            .map(|c| c.light(x & 15, y, z & 15))
+        (self.last.1 != NONE).then_some(self.last.1 as usize)
     }
-    fn set_light(&mut self, x: i32, y: i32, z: i32, packed: u8) {
-        let Some(chunk) = self.get_mut(&(x >> 4, z >> 4)) else {
+    fn load(&mut self, key: Pos) -> u32 {
+        if let Some(&slot) = self.index.get(&key) {
+            return slot;
+        }
+        let slot = match self.world.section(key.0, key.1 as usize, key.2) {
+            Some(section) => {
+                self.slots.push(Slot {
+                    key,
+                    section: section.clone(),
+                    light: None,
+                });
+                (self.slots.len() - 1) as u32
+            }
+            None => NONE,
+        };
+        self.index.insert(key, slot);
+        slot
+    }
+    fn state(&mut self, x: i32, y: i32, z: i32) -> Option<u32> {
+        let slot = self.slot(x, y, z)?;
+        Some(self.slots[slot].section.get(index(x, y, z)))
+    }
+    /// Packed light (sky << 4 | block), None outside loaded, lit chunks.
+    fn light(&mut self, x: i32, y: i32, z: i32) -> Option<u8> {
+        let slot = self.slot(x, y, z)?;
+        let slot = &self.slots[slot];
+        let i = index(x, y, z);
+        Some(match &slot.light {
+            Some(light) => light[i],
+            None => slot.section.light(i),
+        })
+    }
+    /// State and packed light of a cell, with a single section lookup.
+    fn cell(&mut self, x: i32, y: i32, z: i32) -> Option<(u32, u8)> {
+        let slot = self.slot(x, y, z)?;
+        let slot = &self.slots[slot];
+        let i = index(x, y, z);
+        let light = match &slot.light {
+            Some(light) => light[i],
+            None => slot.section.light(i),
+        };
+        Some((slot.section.get(i), light))
+    }
+    /// Rewrite a cell's packed light; nothing outside loaded, lit chunks.
+    fn update_light(&mut self, x: i32, y: i32, z: i32, f: impl FnOnce(u8) -> u8) {
+        let Some(slot) = self.slot(x, y, z) else {
             return;
         };
-        let s = ((y - MIN_Y) >> 4) as usize;
+        let slot = &mut self.slots[slot];
+        let light = slot.light.get_or_insert_with(|| match &slot.section.light {
+            Light::Uniform(v) => Box::new([*v; 4096]),
+            Light::Full(a) => a.clone(),
+        });
         let i = index(x, y, z);
-        if chunk.sections[s].light(i) == packed {
-            return;
-        }
-        let section = Arc::make_mut(&mut Arc::make_mut(chunk).sections[s]);
-        if let Light::Uniform(v) = section.light {
-            section.light = Light::Full(Box::new([v; 4096]));
-        }
-        if let Light::Full(a) = &mut section.light {
-            a[i] = packed;
+        light[i] = f(light[i]);
+    }
+    /// Store back the light of every section whose values changed.
+    fn finish(self) {
+        for slot in self.slots {
+            let Some(light) = slot.light else {
+                continue;
+            };
+            if (0..4096).all(|i| slot.section.light(i) == light[i]) {
+                continue;
+            }
+            // Drop the clone first so the world's section isn't copied.
+            drop(slot.section);
+            let (cx, s, cz) = slot.key;
+            self.world
+                .set_section_light(cx, s as usize, cz, Light::Full(light));
         }
     }
 }
@@ -690,25 +777,23 @@ impl LightChanges {
         }
     }
 }
-fn level(world: &impl LightWorld, sky: bool, p: Pos) -> Option<u8> {
+fn level(world: &mut Region, sky: bool, p: Pos) -> Option<u8> {
     world
         .light(p.0, p.1, p.2)
         .map(|v| if sky { v >> 4 } else { v & 15 })
 }
-fn set_level(world: &mut impl LightWorld, sky: bool, p: Pos, value: u8) {
-    let Some(old) = world.light(p.0, p.1, p.2) else {
-        return;
-    };
-    let packed = if sky {
-        (old & 0x0F) | value << 4
-    } else {
-        (old & 0xF0) | value
-    };
-    world.set_light(p.0, p.1, p.2, packed);
+fn set_level(world: &mut Region, sky: bool, p: Pos, value: u8) {
+    world.update_light(p.0, p.1, p.2, |old| {
+        if sky {
+            (old & 0x0F) | value << 4
+        } else {
+            (old & 0xF0) | value
+        }
+    });
 }
 /// `ChunkSkyLightSources`: the Y of the upper block of the highest occluded
 /// edge in the column (every block at or above it is a sky source).
-pub fn lowest_sky_source(world: &impl LightWorld, tables: &LightTables, x: i32, z: i32) -> i32 {
+fn lowest_sky_source(world: &mut Region, tables: &LightTables, x: i32, z: i32) -> i32 {
     let mut y = MIN_Y + HEIGHT - 1;
     let Some(mut top) = world.state(x, y, z) else {
         return MIN_Y;
@@ -739,34 +824,52 @@ pub fn relight(
     force: bool,
     changed: &mut LightChanges,
 ) {
-    relight_layer(world, tables, false, positions.to_vec(), force, changed);
+    let mut region = Region::new(world);
+    relight_region(&mut region, tables, sky_light, positions, force, changed);
+    region.finish();
+}
+fn relight_region(
+    world: &mut Region,
+    tables: &LightTables,
+    sky_light: bool,
+    positions: &[Pos],
+    force: bool,
+    changed: &mut LightChanges,
+) {
+    crate::spans::time("lt_block", || {
+        relight_layer(world, tables, false, positions.to_vec(), force, changed)
+    });
     if sky_light {
         let mut seeds = positions.to_vec();
-        let mut columns: HashMap<(i32, i32), i32> = HashMap::new();
-        for &(x, _, z) in positions {
-            if columns.contains_key(&(x, z)) {
-                continue;
-            }
-            let source = lowest_sky_source(world, tables, x, z);
-            columns.insert((x, z), source);
-            // Cells whose source status changed: non-15 at or above the new
-            // lowest source, and old 15s (sources) below it.
-            for y in source..MIN_Y + HEIGHT {
-                if level(world, true, (x, y, z)).is_some_and(|l| l != 15) {
+        let mut columns: FxHashMap<(i32, i32), i32> = FxHashMap::default();
+        crate::spans::time("lt_columns", || {
+            for &(x, _, z) in positions {
+                if columns.contains_key(&(x, z)) {
+                    continue;
+                }
+                let source = lowest_sky_source(world, tables, x, z);
+                columns.insert((x, z), source);
+                // Cells whose source status changed: non-15 at or above the new
+                // lowest source, and old 15s (sources) below it.
+                for y in source..MIN_Y + HEIGHT {
+                    if level(world, true, (x, y, z)).is_some_and(|l| l != 15) {
+                        seeds.push((x, y, z));
+                    }
+                }
+                let mut y = source - 1;
+                while y >= MIN_Y && level(world, true, (x, y, z)) == Some(15) {
                     seeds.push((x, y, z));
+                    y -= 1;
                 }
             }
-            let mut y = source - 1;
-            while y >= MIN_Y && level(world, true, (x, y, z)) == Some(15) {
-                seeds.push((x, y, z));
-                y -= 1;
-            }
-        }
-        relight_layer(world, tables, true, seeds, force, changed);
+        });
+        crate::spans::time("lt_sky", || {
+            relight_layer(world, tables, true, seeds, force, changed)
+        });
     }
 }
 fn relight_layer(
-    world: &mut impl LightWorld,
+    world: &mut Region,
     tables: &LightTables,
     sky: bool,
     seeds: Vec<Pos>,
@@ -809,42 +912,40 @@ fn relight_layer(
         }
     }
     // Sources inside the cleared area light up again.
-    let mut sources: HashMap<(i32, i32), i32> = HashMap::new();
-    for p in cleared {
-        let seed = if sky {
-            let lowest = *sources
-                .entry((p.0, p.2))
-                .or_insert_with(|| lowest_sky_source(world, tables, p.0, p.2));
-            if p.1 >= lowest { 15 } else { 0 }
-        } else {
-            world
-                .state(p.0, p.1, p.2)
-                .map_or(0, |s| tables.cells[s as usize].emission)
-        };
-        if seed > level(world, sky, p).unwrap_or(15) {
-            set_level(world, sky, p, seed);
-            changed.push(p);
-            increase.push_back(p);
+    let mut sources: FxHashMap<(i32, i32), i32> = FxHashMap::default();
+    crate::spans::time("lt_sources", || {
+        for p in cleared {
+            let seed = if sky {
+                let lowest = *sources
+                    .entry((p.0, p.2))
+                    .or_insert_with(|| lowest_sky_source(world, tables, p.0, p.2));
+                if p.1 >= lowest { 15 } else { 0 }
+            } else {
+                world
+                    .state(p.0, p.1, p.2)
+                    .map_or(0, |s| tables.cells[s as usize].emission)
+            };
+            if seed > level(world, sky, p).unwrap_or(15) {
+                set_level(world, sky, p, seed);
+                changed.push(p);
+                increase.push_back(p);
+            }
         }
-    }
+    });
     while let Some(p) = increase.pop_front() {
-        let Some(l) = level(world, sky, p) else {
+        let Some((from, packed)) = world.cell(p.0, p.1, p.2) else {
             continue;
         };
+        let l = if sky { packed >> 4 } else { packed & 15 };
         if l <= 1 {
             continue;
         }
-        let Some(from) = world.state(p.0, p.1, p.2) else {
-            continue;
-        };
         for (d, (ox, oy, oz)) in OFFSETS.iter().enumerate() {
             let q = (p.0 + ox, p.1 + oy, p.2 + oz);
-            let Some(to) = world.state(q.0, q.1, q.2) else {
-                continue;
-            };
-            let Some(ql) = level(world, sky, q) else {
+            let Some((to, packed)) = world.cell(q.0, q.1, q.2) else {
                 continue;
             };
+            let ql = if sky { packed >> 4 } else { packed & 15 };
             let next = l.saturating_sub(tables.cells[to as usize].dampening.max(1));
             if next > ql && !tables.blocked(from as usize, to as usize, d) {
                 set_level(world, sky, q, next);
@@ -915,10 +1016,10 @@ mod tests {
         lit.into_iter().collect()
     }
     fn sky(world: &HashMap<(i32, i32), Arc<Chunk>>, x: i32, y: i32, z: i32) -> u8 {
-        world.light(x, y, z).unwrap() >> 4
+        world[&(x >> 4, z >> 4)].light(x & 15, y, z & 15) >> 4
     }
     fn block(world: &HashMap<(i32, i32), Arc<Chunk>>, x: i32, y: i32, z: i32) -> u8 {
-        world.light(x, y, z).unwrap() & 15
+        world[&(x >> 4, z >> 4)].light(x & 15, y, z & 15) & 15
     }
 
     #[test]
@@ -954,6 +1055,108 @@ mod tests {
         assert_eq!(sky(&w, 8, 2, 8), 0, "the full bottom face stops sky light");
     }
     #[test]
+    fn relight_keeps_unchanged_and_unlit_sections() {
+        let mut w = world(|_| {});
+        Arc::make_mut(w.get_mut(&(1, 0)).unwrap()).lit = false;
+        let before = w.clone();
+        let same = |w: &HashMap<(i32, i32), Arc<Chunk>>, key| {
+            w[&key]
+                .sections
+                .iter()
+                .zip(&before[&key].sections)
+                .all(|(a, b)| Arc::ptr_eq(a, b))
+        };
+        // Cleared and lit back to the same values: nothing is stored.
+        relight(
+            &mut w,
+            &tables(),
+            true,
+            &[(8, 5, 8)],
+            false,
+            &mut LightChanges::default(),
+        );
+        assert!(w.keys().all(|&key| same(&w, key)));
+        // Light reaching an unlit chunk isn't written into it.
+        Arc::make_mut(w.get_mut(&(0, 0)).unwrap()).set(15, 0, 8, TORCH);
+        relight(
+            &mut w,
+            &tables(),
+            true,
+            &[(15, 0, 8)],
+            false,
+            &mut LightChanges::default(),
+        );
+        assert!(same(&w, (1, 0)));
+        assert_eq!(block(&w, 14, 0, 8), 13);
+    }
+    #[test]
+    fn random_border_relights_match_full_relight() {
+        // Edits around every border of chunk (0, 0), at the top and bottom of
+        // the world, in batches; a held clone of the chunk must not change.
+        let mut w = world(|_| {});
+        let held = w[&(0, 0)].clone();
+        let mut rng = 0x9e37_79b9_u32;
+        let mut next = |n: usize| {
+            rng ^= rng << 13;
+            rng ^= rng >> 17;
+            rng ^= rng << 5;
+            rng as usize % n
+        };
+        let xz = [-2, -1, 0, 1, 7, 14, 15, 16, 17];
+        let ys = [
+            MIN_Y,
+            MIN_Y + 1,
+            -2,
+            -1,
+            0,
+            1,
+            15,
+            16,
+            MIN_Y + HEIGHT - 2,
+            MIN_Y + HEIGHT - 1,
+        ];
+        for _ in 0..60 {
+            let positions: Vec<Pos> = (0..1 + next(6))
+                .map(|_| (xz[next(xz.len())], ys[next(ys.len())], xz[next(xz.len())]))
+                .collect();
+            for &(x, y, z) in &positions {
+                let state = [TORCH, SLAB, AIR, STONE][next(4)];
+                Arc::make_mut(w.get_mut(&(x >> 4, z >> 4)).unwrap()).set(x & 15, y, z & 15, state);
+            }
+            relight(
+                &mut w,
+                &tables(),
+                true,
+                &positions,
+                false,
+                &mut LightChanges::default(),
+            );
+        }
+        // Every chunk, the outer ring lit as `world` lit it (no neighbours
+        // past the 3x3).
+        for (&(cx, cz), chunk) in &w {
+            let region: [[Option<&Chunk>; 3]; 3] = std::array::from_fn(|dz| {
+                std::array::from_fn(|dx| {
+                    w.get(&(cx + dx as i32 - 1, cz + dz as i32 - 1))
+                        .map(|c| &**c)
+                })
+            });
+            for (si, s) in light_chunk(&region, &tables(), true).iter().enumerate() {
+                for i in 0..4096 {
+                    assert_eq!(
+                        s.get(i),
+                        chunk.sections[si].light(i),
+                        "chunk {cx},{cz} section {si} index {i}"
+                    );
+                }
+            }
+        }
+        let fresh = world(|_| {});
+        for (a, b) in held.sections.iter().zip(&fresh[&(0, 0)].sections) {
+            assert!((0..4096).all(|i| a.light(i) == b.light(i)));
+        }
+    }
+    #[test]
     fn incremental_relight_matches_full_relight() {
         let mut w = world(|c| {
             c.set(8, 0, 8, TORCH);
@@ -1319,4 +1522,37 @@ mod tests {
             "fixture heap payload {payload} bytes; old worker clones it plus 24 section Arcs; old application clones current payload and 98304 returned light bytes. New worker clones zero section payload; new application clones current payload only when shared."
         );
     }
+    /// Relight cost for torches placed and removed near chunk borders with
+    /// slabs flickering around them (fluids next to lava, in the game).
+    /// `cargo test --profile fast -p horizon-client relight_bench -- --ignored --nocapture`
+    #[test]
+    #[ignore]
+    fn relight_bench() {
+        let mut w: FxHashMap<_, _> = world(|_| {}).into_iter().collect();
+        let t = tables();
+        let mut rng = 0x2545_f491_u32;
+        let mut next = |n: i32| {
+            rng ^= rng << 13;
+            rng ^= rng >> 17;
+            rng ^= rng << 5;
+            (rng % n as u32) as i32
+        };
+        let start = std::time::Instant::now();
+        let mut changed = LightChanges::default();
+        for round in 0..400 {
+            let state = [TORCH, SLAB, AIR][round % 3];
+            let positions: Vec<Pos> = (0..32)
+                .map(|_| (next(32) - 8, next(12), next(32) - 8))
+                .collect();
+            for &(x, y, z) in &positions {
+                Arc::make_mut(w.get_mut(&(x >> 4, z >> 4)).unwrap()).set(x & 15, y, z & 15, state);
+            }
+            relight(&mut w, &t, true, &positions, false, &mut changed);
+        }
+        println!(
+            "relight_bench: {:?}, {} sections",
+            start.elapsed(),
+            changed.sections().count()
+        );
+    }
 }

From 2ef155348f8b22ddc030229a3c7945df95c39293 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:32:14 +0100
Subject: [PATCH 407/475] Launcher: keep test runs away from the real trash and
 clipboard

desktop_seams.rs holds the launcher's two hard-to-undo desktop effects.
HORIZON_LAUNCHER_TRASH=<folder> makes Delete (worlds, screenshots, packs)
move into that folder instead of the system's trash, and
HORIZON_LAUNCHER_CLIPBOARD=<file> makes every Copy in the window write into
that file instead of the clipboard. Test runs set both inside their scratch
folders.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 launcher/README.md               |  5 +-
 launcher/src/agents_page.rs      |  2 +-
 launcher/src/desktop_seams.rs    | 80 ++++++++++++++++++++++++++++++++
 launcher/src/internet.rs         |  2 +-
 launcher/src/lib.rs              |  1 +
 launcher/src/main.rs             | 25 ++++++++--
 launcher/src/packs.rs            |  2 +-
 launcher/src/screenshots.rs      |  2 +-
 launcher/src/screenshots_page.rs |  5 +-
 launcher/src/servers_page.rs     |  2 +-
 launcher/src/worlds.rs           | 17 +------
 11 files changed, 117 insertions(+), 26 deletions(-)
 create mode 100644 launcher/src/desktop_seams.rs

diff --git a/launcher/README.md b/launcher/README.md
index e1a9150d0..afe45b2fc 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -242,7 +242,10 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
 `--json` prints JSON where there is something to report (`versions`, `install`, `notes`,
 `next`, `links`, `game-args`, `update --check`, `logs`, `account`, `benchmark`, `data`, `modpack`). Errors go to stderr with exit code 1. `server` runs in the terminal,
 so lines you type reach its console. `HORIZON_LAUNCHER_HOME` replaces the data folder (for
-scripts and tests).
+scripts and tests). Test runs also set `HORIZON_LAUNCHER_TRASH=<folder>` and
+`HORIZON_LAUNCHER_CLIPBOARD=<file>` inside their scratch folders: what Delete would move to the
+system's trash goes into that folder, and what Copy would put on the clipboard is written to that
+file, so a test never touches the real trash or clipboard.
 
 ## AI agents (MCP)
 
diff --git a/launcher/src/agents_page.rs b/launcher/src/agents_page.rs
index e53d6550a..aae76b6f9 100644
--- a/launcher/src/agents_page.rs
+++ b/launcher/src/agents_page.rs
@@ -77,7 +77,7 @@ impl Launcher {
                 &t,
             )
             .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
-                cx.write_to_clipboard(gpui::ClipboardItem::new_string(text.clone()));
+                copy_to_clipboard(cx, gpui::ClipboardItem::new_string(text.clone()));
                 this.agents.copied = Some(id);
                 cx.notify();
             }))
diff --git a/launcher/src/desktop_seams.rs b/launcher/src/desktop_seams.rs
new file mode 100644
index 000000000..edec7ab8d
--- /dev/null
+++ b/launcher/src/desktop_seams.rs
@@ -0,0 +1,80 @@
+//! The two things the launcher does to the player's desktop that a test run must never do to the
+//! real one: moving files to the system's trash, and writing to the clipboard.
+//!
+//! - `HORIZON_LAUNCHER_TRASH=<folder>`: what would go to the trash is moved into that folder
+//!   instead (under a free name).
+//! - `HORIZON_LAUNCHER_CLIPBOARD=<file>`: what would be copied is written to that file instead
+//!   (text as UTF-8, a picture as its PNG or JPEG bytes).
+//!
+//! Test runs point both into their scratch folders, beside `HORIZON_HOME` and
+//! `HORIZON_LAUNCHER_HOME`.
+use std::path::{Path, PathBuf};
+
+pub const TRASH_ENV: &str = "HORIZON_LAUNCHER_TRASH";
+pub const CLIPBOARD_ENV: &str = "HORIZON_LAUNCHER_CLIPBOARD";
+
+/// Moves a file or folder to the system's trash, where the player can still get it back, or
+/// into `HORIZON_LAUNCHER_TRASH` when it is set.
+pub fn to_trash(path: &Path) -> Result<(), String> {
+    match std::env::var_os(TRASH_ENV).filter(|v| !v.is_empty()) {
+        Some(dir) => to_folder(path, Path::new(&dir)),
+        None => system_trash(path),
+    }
+}
+
+fn to_folder(path: &Path, dir: &Path) -> Result<(), String> {
+    std::fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let name = path.file_name().ok_or("Nothing to move")?.to_string_lossy();
+    let target = (1..)
+        .map(|n| match n {
+            1 => dir.join(&*name),
+            n => dir.join(format!("{name} {n}")),
+        })
+        .find(|p| !p.exists())
+        .unwrap();
+    std::fs::rename(path, &target).map_err(|e| e.to_string())
+}
+
+fn system_trash(path: &Path) -> Result<(), String> {
+    #[allow(unused_mut)]
+    let mut trash = trash::TrashContext::default();
+    // The crate's default on macOS asks Finder through AppleScript, which needs the player to
+    // allow the launcher to control Finder first; the file manager call needs nothing.
+    #[cfg(target_os = "macos")]
+    trash::macos::TrashContextExtMacos::set_delete_method(
+        &mut trash,
+        trash::macos::DeleteMethod::NsFileManager,
+    );
+    trash.delete(path).map_err(|e| e.to_string())
+}
+
+/// The file copies go to instead of the clipboard, when `HORIZON_LAUNCHER_CLIPBOARD` is set.
+pub fn clipboard_file() -> Option<PathBuf> {
+    std::env::var_os(CLIPBOARD_ENV)
+        .filter(|v| !v.is_empty())
+        .map(PathBuf::from)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_trash_folder_takes_what_would_go_to_the_trash() {
+        let root = std::env::temp_dir().join(format!("horizon-seams-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&root);
+        let (home, bin) = (root.join("home"), root.join("trash"));
+        std::fs::create_dir_all(home.join("World/region")).unwrap();
+        std::fs::write(home.join("World/level.dat"), b"x").unwrap();
+        std::fs::write(home.join("shot.png"), b"1").unwrap();
+        to_folder(&home.join("World"), &bin).unwrap();
+        to_folder(&home.join("shot.png"), &bin).unwrap();
+        std::fs::write(home.join("shot.png"), b"2").unwrap();
+        to_folder(&home.join("shot.png"), &bin).unwrap();
+        assert!(bin.join("World/level.dat").is_file());
+        assert_eq!(std::fs::read(bin.join("shot.png")).unwrap(), b"1");
+        assert_eq!(std::fs::read(bin.join("shot.png 2")).unwrap(), b"2");
+        assert!(std::fs::read_dir(&home).unwrap().next().is_none());
+        std::fs::remove_dir_all(&root).unwrap();
+    }
+}
diff --git a/launcher/src/internet.rs b/launcher/src/internet.rs
index 76ab8dab8..d4f70ed18 100644
--- a/launcher/src/internet.rs
+++ b/launcher/src/internet.rs
@@ -267,7 +267,7 @@ impl Launcher {
         )
         .bg(self.theme.plate)
         .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
-            cx.write_to_clipboard(gpui::ClipboardItem::new_string(text.clone()));
+            copy_to_clipboard(cx, gpui::ClipboardItem::new_string(text.clone()));
             this.internet.copied = Some((text.clone(), Instant::now()));
             cx.notify();
         }))
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index 9fafb80f8..4fb3c38d1 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -4,6 +4,7 @@ pub mod agents;
 pub mod backend;
 pub mod browser;
 pub mod desktop;
+pub mod desktop_seams;
 #[cfg(unix)]
 pub mod game_app;
 pub mod heads;
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 0542d7504..e7f606cd8 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -1192,6 +1192,22 @@ fn button(
     keyboard(track_hover(base, id), &t).active(|s| s.opacity(theme::PRESSED).top(px(1.)))
 }
 
+/// Copies to the clipboard, or into `HORIZON_LAUNCHER_CLIPBOARD` when a test run sets it
+/// (`horizon_launcher::desktop_seams`).
+fn copy_to_clipboard(cx: &mut App, item: gpui::ClipboardItem) {
+    let Some(file) = horizon_launcher::desktop_seams::clipboard_file() else {
+        cx.write_to_clipboard(item);
+        return;
+    };
+    let bytes = match item.entries().first() {
+        Some(gpui::ClipboardEntry::Image(image)) => image.bytes.clone(),
+        _ => item.text().unwrap_or_default().into_bytes(),
+    };
+    if let Err(e) = std::fs::write(&file, bytes) {
+        eprintln!("{}: {e}", file.display());
+    }
+}
+
 /// An on/off switch: a square knob sliding in a sunk track that turns violet when on.
 fn switch(id: impl Into<SharedString>, on: bool, t: &Theme) -> Stateful<Div> {
     let t = *t;
@@ -2251,7 +2267,7 @@ impl Launcher {
                     .on_click(cx.listener(
                         move |this, _: &ClickEvent, _, cx| {
                             if let Ok(text) = std::fs::read_to_string(&report) {
-                                cx.write_to_clipboard(gpui::ClipboardItem::new_string(text));
+                                copy_to_clipboard(cx, gpui::ClipboardItem::new_string(text));
                                 if let Some(c) = &mut this.crash {
                                     c.copied = true;
                                 }
@@ -2968,9 +2984,10 @@ impl Launcher {
                     .child(
                         button("sign-in-copy", "Copy code", Kind::Secondary, &t).on_click(
                             move |_, _, cx| {
-                                cx.write_to_clipboard(gpui::ClipboardItem::new_string(
-                                    user_code.clone(),
-                                ))
+                                copy_to_clipboard(
+                                    cx,
+                                    gpui::ClipboardItem::new_string(user_code.clone()),
+                                )
                             },
                         ),
                     )
diff --git a/launcher/src/packs.rs b/launcher/src/packs.rs
index 260d7f21a..368fe3408 100644
--- a/launcher/src/packs.rs
+++ b/launcher/src/packs.rs
@@ -329,7 +329,7 @@ pub fn remove(home: &Path, pack: &Pack) -> Result<(), String> {
     if pack.enabled {
         set_enabled(home, pack, false)?;
     }
-    crate::worlds::to_trash(&pack.path)
+    crate::desktop_seams::to_trash(&pack.path)
         .map_err(|e| format!("Could not move {} to the trash: {e}", pack.file))
 }
 
diff --git a/launcher/src/screenshots.rs b/launcher/src/screenshots.rs
index 79e534df6..1d7c79fe1 100644
--- a/launcher/src/screenshots.rs
+++ b/launcher/src/screenshots.rs
@@ -55,7 +55,7 @@ pub fn find(home: &Path, query: &str) -> Result<Shot, String> {
 
 /// Moves the screenshot to the system's trash.
 pub fn delete(shot: &Shot) -> Result<(), String> {
-    crate::worlds::to_trash(&shot.path)
+    crate::desktop_seams::to_trash(&shot.path)
         .map_err(|e| format!("Could not move {} to the trash: {e}", shot.name))
 }
 
diff --git a/launcher/src/screenshots_page.rs b/launcher/src/screenshots_page.rs
index ce8d75227..d4017ade1 100644
--- a/launcher/src/screenshots_page.rs
+++ b/launcher/src/screenshots_page.rs
@@ -82,7 +82,10 @@ impl Launcher {
         };
         self.screenshots.note = Some(match std::fs::read(&shot.path) {
             Ok(bytes) => {
-                cx.write_to_clipboard(ClipboardItem::new_image(&Image::from_bytes(format, bytes)));
+                copy_to_clipboard(
+                    cx,
+                    ClipboardItem::new_image(&Image::from_bytes(format, bytes)),
+                );
                 Ok("Copied to the clipboard.".into())
             }
             Err(e) => Err(format!("Could not read {}: {e}", shot.name)),
diff --git a/launcher/src/servers_page.rs b/launcher/src/servers_page.rs
index ce4906a6a..4c52893bc 100644
--- a/launcher/src/servers_page.rs
+++ b/launcher/src/servers_page.rs
@@ -1643,7 +1643,7 @@ impl Launcher {
                         )
                         .bg(t.plate)
                         .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
-                            cx.write_to_clipboard(gpui::ClipboardItem::new_string(
+                            copy_to_clipboard(cx, gpui::ClipboardItem::new_string(
                                 copy_text.clone(),
                             ));
                             this.servers.copied = Some(Instant::now());
diff --git a/launcher/src/worlds.rs b/launcher/src/worlds.rs
index 68cbebd1a..3317ab1b8 100644
--- a/launcher/src/worlds.rs
+++ b/launcher/src/worlds.rs
@@ -251,21 +251,8 @@ fn rename_level(world: &Path, name: &str) -> std::io::Result<()> {
 
 /// Moves the world to the system's trash, where the player can still get it back.
 pub fn delete(world: &World) -> Result<(), String> {
-    to_trash(&world.path).map_err(|e| format!("Could not move {} to the trash: {e}", world.name))
-}
-
-/// Moves a file or folder to the system's trash.
-pub(crate) fn to_trash(path: &Path) -> Result<(), trash::Error> {
-    #[allow(unused_mut)]
-    let mut trash = trash::TrashContext::default();
-    // The crate's default on macOS asks Finder through AppleScript, which needs the player to
-    // allow the launcher to control Finder first; the file manager call needs nothing.
-    #[cfg(target_os = "macos")]
-    trash::macos::TrashContextExtMacos::set_delete_method(
-        &mut trash,
-        trash::macos::DeleteMethod::NsFileManager,
-    );
-    trash.delete(path)
+    crate::desktop_seams::to_trash(&world.path)
+        .map_err(|e| format!("Could not move {} to the trash: {e}", world.name))
 }
 
 #[cfg(test)]

From 3c257bb3e64f4bf9b017f410e79be98adb850b84 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:33:31 +0100
Subject: [PATCH 408/475] AGENTS.md: launcher test runs set
 HORIZON_LAUNCHER_TRASH and HORIZON_LAUNCHER_CLIPBOARD

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/AGENTS.md b/AGENTS.md
index e1fa9e7fe..932eb1067 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -10,7 +10,8 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
   `tools/check_public_tree.py` rejects them; `git config core.hooksPath .githooks` runs it on commit.
 - **Keep your runs away from real player data.** Any game or launcher you start gets fresh `mktemp -d`
   folders in `HORIZON_HOME` (the game's data), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
-  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`. Never write to
+  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`, and, for the
+  launcher, `HORIZON_LAUNCHER_TRASH` and `HORIZON_LAUNCHER_CLIPBOARD` pointing into the scratch home. Never write to
   `~/.local/share/{applications,horizon,horizon-launcher}` or `~/.local/bin`.
 - **Mark what an agent posts.** A PR body starts with a line naming whose agent opened it and with what.
   Ludovic's agents write `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.`, and a

From b39c4b8dd4eb0a55c8254352ab3696bba04562b1 Mon Sep 17 00:00:00 2001
From: socksprox <info@shadowfly.net>
Date: Tue, 27 Oct 2026 02:36:53 +0100
Subject: [PATCH 409/475] mobs: jumpOutOfFluid wants a dry, entity-free box

Entity.isFree is noCollision(this, box) && !containsAnyLiquid(box); the
check only looked at block collisions, so a mob pressed against a wall by
water flow hopped out where vanilla refuses, and it ignored other
collidable entities entirely.

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 crates/horizon-client/src/mobs/living.rs | 39 ++++++++++++++++++++----
 1 file changed, 33 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs
index 394821ace..7331eb344 100644
--- a/crates/horizon-client/src/mobs/living.rs
+++ b/crates/horizon-client/src/mobs/living.rs
@@ -235,6 +235,26 @@ impl MobWorld<'_> {
         };
         scene.unobstructed(b).unwrap_or(false)
     }
+    /// `LevelReader.containsAnyLiquid`: the blocks from the box's minimum
+    /// corner to the block holding its maximum corner.
+    pub fn contains_any_liquid(&self, b: Aabb) -> bool {
+        let (lo, hi) = (b.min_position(), b.max_position());
+        let (x0, y0, z0) = (
+            lo.x.floor() as i32,
+            lo.y.floor() as i32,
+            lo.z.floor() as i32,
+        );
+        let (x1, y1, z1) = (
+            hi.x.floor() as i32,
+            hi.y.floor() as i32,
+            hi.z.floor() as i32,
+        );
+        (x0..=x1).any(|x| {
+            (y0..=y1).any(|y| {
+                (z0..=z1).any(|z| self.facts.get(self.world.block(x, y, z)).fluid != Fluid::None)
+            })
+        })
+    }
 }
 impl Mob {
     /// `Entity.refreshDimensions` after growing from `old_w` by `old_h`:
@@ -813,14 +833,21 @@ impl Mob {
                 self.velocity.y -= gravity / 4.0;
             }
         }
-        // jumpOutOfFluid
+        // jumpOutOfFluid: Entity.isFree wants the box dry and clear of
+        // collidable entities too.
         let m = self.velocity;
+        let ahead = self.bounds().move_by(Vec3::new(
+            m.x,
+            m.y + f64::from(0.6_f32) - self.position.y + old_y,
+            m.z,
+        ));
+        let wide = ahead.inflate(Vec3::new(1.0e-7, 1.0e-7, 1.0e-7));
         if self.horizontal_collision
-            && w.no_collision(self.bounds().move_by(Vec3::new(
-                m.x,
-                m.y + f64::from(0.6_f32) - self.position.y + old_y,
-                m.z,
-            )))
+            && w.no_collision(ahead)
+            && !w.contains_any_liquid(ahead)
+            && !w
+                .others_near(wide)
+                .any(|s| s.id != self.id && s.alive && s.bounds.intersects(wide))
         {
             self.velocity.y = f64::from(0.3_f32);
         }

From 9ae37fcb5062707871c1f25d7e755f857a19feb8 Mon Sep 17 00:00:00 2001
From: DanielGodriNeto <godrineto@gmail.com>
Date: Mon, 26 Oct 2026 19:17:58 -0300
Subject: [PATCH 410/475] feat(threads): measure thread CPU time on Windows
 from cycle counts

thread_cpu() returned None on Windows. Implement it from thread cycle counts,
inside horizon-threads so horizon-client keeps forbid(unsafe_code).

Co-Authored-By: Claude <noreply@anthropic.com>
---
 crates/horizon-client/src/spans.rs |  5 ++--
 crates/horizon-threads/Cargo.toml  |  2 +-
 crates/horizon-threads/src/lib.rs  | 37 ++++++++++++++++++++++++++++++
 3 files changed, 41 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/spans.rs b/crates/horizon-client/src/spans.rs
index ce69be8ce..33c4bb933 100644
--- a/crates/horizon-client/src/spans.rs
+++ b/crates/horizon-client/src/spans.rs
@@ -52,8 +52,9 @@ pub fn thread_cpu() -> Option<Duration> {
         Some(Duration::new(t.tv_sec as u64, t.tv_nsec as u32))
     }
     #[cfg(not(unix))]
-    None
+    horizon_threads::thread_cpu()
 }
+
 /// The frame's spans, summed by name, slowest first; clears them.
 pub fn take() -> Vec<Span> {
     let spans = SPANS.with(|s| std::mem::take(&mut *s.borrow_mut()));
@@ -135,7 +136,7 @@ mod tests {
 
     /// The thread's CPU clock moves with work done on it, not with time
     /// spent asleep.
-    #[cfg(unix)]
+    #[cfg(any(unix, all(windows, target_arch = "x86_64")))]
     #[test]
     fn thread_cpu_counts_work_not_sleep() {
         let start = super::thread_cpu().unwrap();
diff --git a/crates/horizon-threads/Cargo.toml b/crates/horizon-threads/Cargo.toml
index d43b3e4fc..67b3c20da 100644
--- a/crates/horizon-threads/Cargo.toml
+++ b/crates/horizon-threads/Cargo.toml
@@ -10,7 +10,7 @@ description = "Scheduling hints for the game's threads: the OS calls the crates
 libc = "0.2"
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.61", features = ["Win32_System_Threading"] }
+windows-sys = { version = "0.61", features = ["Win32_System_Threading", "Win32_System_WindowsProgramming"] }
 
 [lints]
 workspace = true
diff --git a/crates/horizon-threads/src/lib.rs b/crates/horizon-threads/src/lib.rs
index 917c3b502..85957b7e1 100644
--- a/crates/horizon-threads/src/lib.rs
+++ b/crates/horizon-threads/src/lib.rs
@@ -41,6 +41,43 @@ fn favour() -> bool {
     false
 }
 
+/// The CPU time the calling thread has used, where only an OS call gives it
+/// precisely. Windows counts it exactly only in cycles of the time-stamp
+/// counter (`QueryThreadCycleTime`; `GetThreadTimes` moves in scheduler ticks
+/// of ~15.6 ms), so the counter's rate is measured once against the wall
+/// clock and cycles convert to time. `None` elsewhere: unix callers read
+/// `CLOCK_THREAD_CPUTIME_ID` themselves.
+#[cfg(all(windows, target_arch = "x86_64"))]
+pub fn thread_cpu() -> Option<std::time::Duration> {
+    use std::{
+        sync::OnceLock,
+        time::{Duration, Instant},
+    };
+    use windows_sys::Win32::System::{
+        Threading::GetCurrentThread, WindowsProgramming::QueryThreadCycleTime,
+    };
+    // Time-stamp counter cycles per nanosecond.
+    static RATE: OnceLock<f64> = OnceLock::new();
+    let rate = *RATE.get_or_init(|| {
+        // SAFETY: RDTSC has no preconditions on x86_64.
+        let tsc = || unsafe { core::arch::x86_64::_rdtsc() };
+        let (wall, start) = (Instant::now(), tsc());
+        std::thread::sleep(Duration::from_millis(20));
+        (tsc() - start) as f64 / wall.elapsed().as_nanos() as f64
+    });
+    let mut cycles = 0;
+    // SAFETY: GetCurrentThread's pseudo handle needs no closing; a valid out pointer.
+    if unsafe { QueryThreadCycleTime(GetCurrentThread(), &mut cycles) } == 0 {
+        return None;
+    }
+    Some(Duration::from_nanos((cycles as f64 / rate) as u64))
+}
+
+#[cfg(not(all(windows, target_arch = "x86_64")))]
+pub fn thread_cpu() -> Option<std::time::Duration> {
+    None
+}
+
 /// Set once as the game starts, before its helper threads do: they then go
 /// behind the server thread and the render thread (`behind_server`).
 static HELPERS_BEHIND: AtomicBool = AtomicBool::new(false);

From cac63dedca1ff062acee58b1c688e5809ad259c8 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:42:09 +0100
Subject: [PATCH 411/475] Launcher: Update all for installed packs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Mods page's Installed list gets "Update all (N)" when newer versions
were found: every pack with one is updated in turn on a thread (each
download checked as an install is), with "1 of 2: …" progress, and one that
fails is named without stopping the others. The CLI already does this with
`mods update` and no pack name (MCP: mods_update).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/mod-browser.md       |  4 +-
 launcher/README.md        |  4 +-
 launcher/src/mods_page.rs | 99 +++++++++++++++++++++++++++++++++++++--
 3 files changed, 101 insertions(+), 6 deletions(-)

diff --git a/docs/mod-browser.md b/docs/mod-browser.md
index dfdd1617d..d4483cd4e 100644
--- a/docs/mod-browser.md
+++ b/docs/mod-browser.md
@@ -82,7 +82,8 @@ downloads, source and licence, how well it runs (and why), **Page** (the project
 **Install** (**Import** for a modpack). The Modpacks tab lists the imported packs first, with their coverage
 report, **Port** and **Play** ([modpacks.md](modpacks.md)). Installed packs are listed above the results with their version, source,
 file and the checksum they were checked against, with **Update to …** when a newer version runs and **Remove**
-(asked twice).
+(asked twice). **Update all (N)** above the list updates every pack a newer version was found for, of every kind,
+one after the other; one that fails is named and doesn't stop the others.
 
 ### Project pages, filters and icons
 
@@ -130,6 +131,7 @@ same name the player put there is never overwritten.
   pack still has to be turned on in the game's Resource Packs screen, as in vanilla, and a shader pack picked in
   the game's Shader Packs page.
 - **Update** installs the newer version and removes the old file.
+- **Update all** does the same for each pack with a newer version (`horizon-launcher mods update` with no pack name).
 - **Remove** deletes the file and its entry. Packs installed as dependencies stay.
 - **A modpack** is downloaded (checked the same way) into `ports/downloads/`, imported, and ported straight away
   for the selected version when it is prepared (`modpacks::import_and_port`): the jars of the mods Horizon can carry
diff --git a/launcher/README.md b/launcher/README.md
index afe45b2fc..8e1a69178 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -28,8 +28,8 @@ The opening, then Play ([clip](docs/opening.webm)):
   packs and modpacks, each marked Works, Partly or Doesn't run in
   Horizon; Java mod jars are never offered. Install puts a pack and what it needs in
   `resourcepacks/` only after its SHA-512 matches, and a
-  modpack goes to the Modpacks page; installed packs show their source and checksum, with Update
-  and Remove ([docs/mod-browser.md](../docs/mod-browser.md)).
+  modpack goes to the Modpacks page; installed packs show their source and checksum, with Update,
+  **Update all** and Remove ([docs/mod-browser.md](../docs/mod-browser.md)).
 - **Modpacks**: import a Java modpack (a Modrinth `.mrpack`, a CurseForge zip, or a Prism,
   MultiMC or CurseForge instance folder) and see its coverage report: per mod, ported, partial,
   not yet or not needed, with the reason ([docs/modpacks.md](../docs/modpacks.md)). **Port**
diff --git a/launcher/src/mods_page.rs b/launcher/src/mods_page.rs
index f74fc73c1..b98cfb654 100644
--- a/launcher/src/mods_page.rs
+++ b/launcher/src/mods_page.rs
@@ -468,6 +468,70 @@ impl Launcher {
         });
     }
 
+    /// Updates every installed pack a newer version was found for, one after the other on a
+    /// thread, each checked as an install is. One failing doesn't stop the others.
+    fn mods_update_all(&mut self) {
+        if self.mods.busy.is_some() || self.mods.updates.is_empty() {
+            return;
+        }
+        let mut todo: Vec<(SourceId, String, String)> = self
+            .mods
+            .installed
+            .iter()
+            .filter(|e| {
+                self.mods
+                    .updates
+                    .contains_key(&(e.source, e.project.clone()))
+            })
+            .map(|e| (e.source, e.project.clone(), e.title.clone()))
+            .collect();
+        todo.dedup_by(|a, b| a.0 == b.0 && a.1 == b.1);
+        self.mods.message = None;
+        self.mods.busy = Some(("all".into(), "Updating…".into(), 0.));
+        self.mods.updates.clear();
+        let tx = self.mods.tx.clone();
+        std::thread::spawn(move || {
+            let home = backend::game_home();
+            let count = todo.len();
+            let (mut done, mut failed) = (Vec::new(), Vec::new());
+            for (i, (source_id, id, title)) in todo.into_iter().enumerate() {
+                let step = |line: &str, f: f32| {
+                    let overall = (i as f32 + f) / count as f32;
+                    let _ = tx.send(Event::Progress(
+                        format!("{} of {count}: {line}", i + 1),
+                        overall,
+                    ));
+                };
+                let updated = browser::source(source_id)
+                    .ok_or_else(|| format!("{} isn't set up", source_id.label()))
+                    .and_then(|source| {
+                        let p = source.project(&id)?;
+                        installed::install(&*source, &p, true, &home, &step)
+                    });
+                match updated {
+                    Ok(entries) => done.extend(
+                        entries
+                            .into_iter()
+                            .filter(|e| e.project == id)
+                            .map(|e| format!("{} {}", e.title, e.number)),
+                    ),
+                    Err(e) => failed.push(format!("{title}: {e}")),
+                }
+            }
+            let updated = match done.is_empty() {
+                true => String::new(),
+                false => format!("Updated {}, checksums checked.", done.join(", ")),
+            };
+            let result = match failed.is_empty() {
+                true => Ok(updated),
+                false => Err(format!("{updated} Not updated: {}", failed.join("; "))
+                    .trim()
+                    .to_string()),
+            };
+            let _ = tx.send(Event::Done(result, false));
+        });
+    }
+
     /// Installs (or updates) a project on a thread: a pack into its folder, a modpack into
     /// Modpacks. `known` is the project when the page has it; else it is asked for first.
     pub(super) fn mods_install(&mut self, source: SourceId, id: String, known: Option<Project>) {
@@ -731,14 +795,19 @@ impl Launcher {
     pub(super) fn mods_busy_plate(&self) -> Vec<Div> {
         let t = self.theme;
         let mut out = Vec::new();
-        if let Some((_, line, f)) = &self.mods.busy {
+        if let Some((what, line, f)) = &self.mods.busy {
+            let caption = if what == "all" {
+                "Updating"
+            } else {
+                "Installing"
+            };
             out.push(
                 plate(&t)
                     .flex()
                     .flex_col()
                     .gap(px(8.))
                     .p(px(16.))
-                    .child(caps("Installing").text_color(t.accent))
+                    .child(caps(caption).text_color(t.accent))
                     .child(
                         text(theme::CAPTION)
                             .font_family(theme::MONO)
@@ -889,6 +958,23 @@ impl Launcher {
                 &t,
             )
         };
+        // Every kind's updates at once, whichever tab is open.
+        let update_all = (!self.mods.updates.is_empty()).then(|| {
+            let b = button(
+                "mods-update-all",
+                format!("Update all ({})", self.mods.updates.len()),
+                Kind::Secondary,
+                &t,
+            );
+            if busy {
+                disabled(b)
+            } else {
+                b.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                    this.mods_update_all();
+                    cx.notify();
+                }))
+            }
+        });
         let list = self.mods.installed_list.column(
             &self.content_scroll.handle,
             entries.len(),
@@ -901,7 +987,14 @@ impl Launcher {
                 .flex()
                 .flex_col()
                 .gap(px(12.))
-                .child(caps("Installed").text_color(t.muted))
+                .child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .justify_between()
+                        .child(caps("Installed").text_color(t.muted))
+                        .children(update_all),
+                )
                 .child(list),
         )
     }

From aa6fdac5018a11026a6e7947c8e010e1e44f06ed Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:49:42 +0100
Subject: [PATCH 412/475] Launcher: data packs into a world
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

datapacks.rs lists a world's datapacks/ (zips and folders with
pack.mcmeta, as the game discovers them; off when datapacks.json lists them
disabled), adds a data pack zip under a free name (refusing resource packs:
no data/ folder) and removes one to the trash, forgetting it in
datapacks.json. The game turns a new pack on when the world opens.

Home: each world gets "Data packs", which opens its packs under the row
with Add data pack… and Remove; a zip dropped on a world goes into it.
CLI: `worlds datapack-list|datapack-add|datapack-remove <world>`;
datapack-remove needs confirm over MCP.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md       |  35 +++++
 launcher/README.md              |   6 +-
 launcher/src/cli.rs             |  62 ++++++++
 launcher/src/cli_tools.rs       |   1 +
 launcher/src/datapacks.rs       | 156 +++++++++++++++++++
 launcher/src/datapacks/tests.rs | 103 +++++++++++++
 launcher/src/datapacks_page.rs  | 255 ++++++++++++++++++++++++++++++++
 launcher/src/lib.rs             |   1 +
 launcher/src/main.rs            |   3 +
 launcher/src/packs.rs           |   4 +-
 launcher/src/worlds_page.rs     |  18 ++-
 11 files changed, 640 insertions(+), 4 deletions(-)
 create mode 100644 launcher/src/datapacks.rs
 create mode 100644 launcher/src/datapacks/tests.rs
 create mode 100644 launcher/src/datapacks_page.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index db3c6a03a..c88c38c6b 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -374,6 +374,41 @@ Move a world to the system's trash.
 
 MCP: `worlds_delete`, needs `confirm: true`.
 
+## `horizon-launcher worlds datapack-list`
+
+A world's data packs, and which are on.
+
+    horizon-launcher worlds datapack-list <WORLD>
+
+- `WORLD`
+- `--instance`
+
+MCP: `worlds_datapack_list`.
+
+## `horizon-launcher worlds datapack-add`
+
+Copy a data pack zip into a world (the game turns it on when the world opens).
+
+    horizon-launcher worlds datapack-add <WORLD> <FILE>
+
+- `WORLD`
+- `FILE`
+- `--instance`
+
+MCP: `worlds_datapack_add`.
+
+## `horizon-launcher worlds datapack-remove`
+
+Move a world's data pack to the system's trash.
+
+    horizon-launcher worlds datapack-remove <WORLD> <PACK>
+
+- `WORLD`
+- `PACK`: Its file name, with or without .zip
+- `--instance`
+
+MCP: `worlds_datapack_remove`, needs `confirm: true`.
+
 ## `horizon-launcher packs list`
 
 The resource and shader packs, and which are on (the default).
diff --git a/launcher/README.md b/launcher/README.md
index 8e1a69178..ddf7e3056 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -88,7 +88,11 @@ The opening, then Play ([clip](docs/opening.webm)):
   (`<date>_<time>_<folder>.zip`); **Copy** puts "<name> (1)" beside it; **Delete** moves it to the
   system's trash after a confirmation; **Open folder**. The same from the command line:
   `horizon-launcher worlds [list|backup|copy|delete] [--instance <name>]`.
-  **Play** on a world starts the game straight into it.
+  **Play** on a world starts the game straight into it. **Data packs** opens the world's
+  `datapacks/` under its row: what is there (and which the game has turned off), **Add data pack…**,
+  and **Remove** (to the trash); a data pack `.zip` dropped on a world goes into it. The game turns
+  a new one on when the world opens. From the command line: `horizon-launcher worlds
+  datapack-list|datapack-add|datapack-remove <world> …`.
 - **Packs**: Home lists the selected instance's resource packs and shader packs, each with a switch.
   The choice is the game's own: `resourcePacks` in options.txt (a pack turned on goes on top, as
   the game's Resource Packs screen does) and `pickedShaderPack` in `horizon-graphics.txt` (one shader
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 4b462e9fd..852fde696 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -212,6 +212,27 @@ enum WorldsCmd {
         #[arg(long)]
         instance: Option<String>,
     },
+    /// A world's data packs, and which are on
+    DatapackList {
+        world: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Copy a data pack zip into a world (the game turns it on when the world opens)
+    DatapackAdd {
+        world: String,
+        file: PathBuf,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Move a world's data pack to the system's trash
+    DatapackRemove {
+        world: String,
+        /// Its file name, with or without .zip
+        pack: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
 }
 
 #[derive(Clone, Copy, clap::ValueEnum)]
@@ -1816,6 +1837,7 @@ fn multiplayer(action: MultiplayerCmd, as_json: bool) -> Result<(), String> {
 }
 
 fn worlds(action: WorldsCmd, as_json: bool) -> Result<(), String> {
+    use horizon_launcher::datapacks;
     use horizon_launcher::worlds::{self, World};
     let home = |instance: Option<String>| -> Result<PathBuf, String> {
         Ok(match instance {
@@ -1873,6 +1895,46 @@ fn worlds(action: WorldsCmd, as_json: bool) -> Result<(), String> {
             worlds::delete(&w)?;
             println!("{} is in the trash.", w.name);
         }
+        WorldsCmd::DatapackList { world, instance } => {
+            let w = worlds::find(&home(instance)?, &world)?;
+            let packs = datapacks::list(&w.path);
+            if as_json {
+                json(
+                    packs
+                        .iter()
+                        .map(|p| serde_json::json!({ "file": p.file, "description": p.description, "enabled": p.enabled, "path": p.path }))
+                        .collect(),
+                );
+            } else if packs.is_empty() {
+                println!("No data packs in {}", w.name);
+            }
+            for p in packs.iter().filter(|_| !as_json) {
+                let on = if p.enabled { "on " } else { "off" };
+                println!("  {on} {}  {}", p.file, p.description);
+            }
+        }
+        WorldsCmd::DatapackAdd {
+            world,
+            file,
+            instance,
+        } => {
+            let w = worlds::find(&home(instance)?, &world)?;
+            let p = datapacks::add(&w.path, &file)?;
+            println!(
+                "Added {} to {}: the game turns it on when the world opens.",
+                p.file, w.name
+            );
+        }
+        WorldsCmd::DatapackRemove {
+            world,
+            pack,
+            instance,
+        } => {
+            let w = worlds::find(&home(instance)?, &world)?;
+            let p = datapacks::find(&w.path, &pack)?;
+            datapacks::remove(&w.path, &p)?;
+            println!("{} is in the trash.", p.file);
+        }
     }
     Ok(())
 }
diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs
index c19f191a2..ddbfefab8 100644
--- a/launcher/src/cli_tools.rs
+++ b/launcher/src/cli_tools.rs
@@ -30,6 +30,7 @@ pub const DESTRUCTIVE: &[&str] = &[
     "multiplayer remove",
     "screenshots delete",
     "packs remove",
+    "worlds datapack-remove",
 ];
 
 /// Commands that send something or reach other people: only when the player asks.
diff --git a/launcher/src/datapacks.rs b/launcher/src/datapacks.rs
new file mode 100644
index 000000000..1c6a2ac46
--- /dev/null
+++ b/launcher/src/datapacks.rs
@@ -0,0 +1,156 @@
+//! A world's data packs: `<world>/datapacks/`, each a `.zip` or a folder with a `pack.mcmeta`, as
+//! the game discovers them (`datapack::discover`). The game turns on every pack it finds there
+//! that `<world>/datapacks.json` doesn't list as disabled, when the world opens or on `/reload`,
+//! so adding one is copying it in.
+use crate::packs::{entry, plain};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+const SETTINGS: &str = "datapacks.json";
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct DataPack {
+    /// Its file or folder name in `datapacks/`; the game's id is `file/<name>`.
+    pub file: String,
+    pub path: PathBuf,
+    /// `pack.mcmeta`'s description as plain text.
+    pub description: String,
+    /// Off when `datapacks.json` lists it as disabled (the game's `/datapack disable`).
+    pub enabled: bool,
+}
+
+fn settings(world: &Path) -> serde_json::Value {
+    fs::read(world.join(SETTINGS))
+        .ok()
+        .and_then(|b| serde_json::from_slice(&b).ok())
+        .unwrap_or_else(|| serde_json::json!({}))
+}
+
+fn disabled(settings: &serde_json::Value) -> Vec<String> {
+    settings["disabled"]
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter_map(|v| v.as_str().map(str::to_string))
+        .collect()
+}
+
+/// The data packs of the world folder `world`, by name.
+pub fn list(world: &Path) -> Vec<DataPack> {
+    let off = disabled(&settings(world));
+    let mut packs: Vec<DataPack> = fs::read_dir(world.join("datapacks"))
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter_map(|e| {
+            let path = e.path();
+            let file = e.file_name().to_str()?.to_string();
+            let zip = path.is_file() && file.to_ascii_lowercase().ends_with(".zip");
+            if !(zip || path.is_dir()) {
+                return None;
+            }
+            let meta: serde_json::Value =
+                serde_json::from_slice(&entry(&path, "pack.mcmeta")?).ok()?;
+            Some(DataPack {
+                enabled: !off.contains(&format!("file/{file}")),
+                description: plain(&meta["pack"]["description"]),
+                file,
+                path,
+            })
+        })
+        .collect();
+    packs.sort_by_key(|p| p.file.to_lowercase());
+    packs
+}
+
+/// Whether a zip is a data pack: a `pack.mcmeta` and a `data/` folder.
+fn check(file: &Path) -> Result<(), String> {
+    let name = file
+        .file_name()
+        .map(|n| n.to_string_lossy().into_owned())
+        .unwrap_or_default();
+    let zip = fs::File::open(file)
+        .ok()
+        .and_then(|f| zip::ZipArchive::new(f).ok())
+        .ok_or_else(|| format!("{name} is not a zip file that can be read."))?;
+    if zip.index_for_name("pack.mcmeta").is_none() {
+        return Err(format!("{name} is not a pack: it has no pack.mcmeta."));
+    }
+    if !zip.file_names().any(|n| n.starts_with("data/")) {
+        return Err(format!(
+            "{name} has no data folder: it is a resource pack, not a data pack."
+        ));
+    }
+    Ok(())
+}
+
+/// Copies a data pack zip into the world's `datapacks/` under a free name. The game turns it on
+/// the next time the world opens (or on `/reload`).
+pub fn add(world: &Path, file: &Path) -> Result<DataPack, String> {
+    check(file)?;
+    let dir = world.join("datapacks");
+    fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let name = file.file_name().ok_or("A pack file has a name")?;
+    let stem = Path::new(name)
+        .file_stem()
+        .unwrap_or(name)
+        .to_string_lossy();
+    let target = (1..)
+        .map(|n| match n {
+            1 => dir.join(name),
+            n => dir.join(format!("{stem} ({n}).zip")),
+        })
+        .find(|p| !p.exists())
+        .unwrap();
+    fs::copy(file, &target).map_err(|e| format!("Could not copy {}: {e}", file.display()))?;
+    let file_name = target.file_name().unwrap().to_string_lossy().into_owned();
+    // A pack of the same name removed while it was disabled would stay off.
+    forget(world, &file_name)?;
+    list(world)
+        .into_iter()
+        .find(|p| p.file == file_name)
+        .ok_or_else(|| format!("{} is not a data pack the game reads", target.display()))
+}
+
+/// Drops `file/<name>` from both lists of `datapacks.json`, when it is there.
+fn forget(world: &Path, file: &str) -> Result<(), String> {
+    let mut s = settings(world);
+    let id = format!("file/{file}");
+    let mut changed = false;
+    for key in ["enabled", "disabled"] {
+        if let Some(list) = s[key].as_array_mut() {
+            let before = list.len();
+            list.retain(|v| v.as_str() != Some(id.as_str()));
+            changed |= list.len() != before;
+        }
+    }
+    if !changed {
+        return Ok(());
+    }
+    let text = serde_json::to_string_pretty(&s).unwrap();
+    fs::write(world.join(SETTINGS), text).map_err(|e| format!("{SETTINGS}: {e}"))
+}
+
+/// The data pack a command names: its file name, with or without `.zip`.
+pub fn find(world: &Path, query: &str) -> Result<DataPack, String> {
+    list(world)
+        .into_iter()
+        .find(|p| p.file == query || p.file.strip_suffix(".zip") == Some(query))
+        .ok_or_else(|| {
+            format!(
+                "No data pack {query} in {}",
+                world.join("datapacks").display()
+            )
+        })
+}
+
+/// Moves the data pack to the system's trash and forgets it in `datapacks.json`.
+pub fn remove(world: &Path, pack: &DataPack) -> Result<(), String> {
+    crate::desktop_seams::to_trash(&pack.path)
+        .map_err(|e| format!("Could not move {} to the trash: {e}", pack.file))?;
+    forget(world, &pack.file)
+}
+
+#[cfg(test)]
+#[path = "datapacks/tests.rs"]
+mod tests;
diff --git a/launcher/src/datapacks/tests.rs b/launcher/src/datapacks/tests.rs
new file mode 100644
index 000000000..6fa54dd38
--- /dev/null
+++ b/launcher/src/datapacks/tests.rs
@@ -0,0 +1,103 @@
+use super::*;
+use std::io::Write;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-datapacks-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+fn zip_file(path: &Path, files: &[(&str, &str)]) {
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    let mut zip = zip::ZipWriter::new(fs::File::create(path).unwrap());
+    for (name, text) in files {
+        zip.start_file(*name, zip::write::SimpleFileOptions::default())
+            .unwrap();
+        zip.write_all(text.as_bytes()).unwrap();
+    }
+    zip.finish().unwrap();
+}
+
+const META: &str = r#"{"pack":{"pack_format":88,"description":"More trades"}}"#;
+
+#[test]
+fn lists_adds_and_removes_as_the_game_reads_them() {
+    let root = scratch("all");
+    let world = root.join("saves/My World");
+    zip_file(
+        &world.join("datapacks/Trades.zip"),
+        &[
+            ("pack.mcmeta", META),
+            ("data/t/function/a.mcfunction", "say hi"),
+        ],
+    );
+    fs::create_dir_all(world.join("datapacks/folder pack")).unwrap();
+    fs::write(
+        world.join("datapacks/folder pack/pack.mcmeta"),
+        r#"{"pack":{"description":{"text":"Mine"}}}"#,
+    )
+    .unwrap();
+    fs::write(world.join("datapacks/readme.txt"), "").unwrap();
+    fs::write(
+        world.join("datapacks.json"),
+        r#"{"enabled":[],"disabled":["file/folder pack","file/Gone.zip"]}"#,
+    )
+    .unwrap();
+    let packs = list(&world);
+    let seen: Vec<(&str, &str, bool)> = packs
+        .iter()
+        .map(|p| (p.file.as_str(), p.description.as_str(), p.enabled))
+        .collect();
+    assert_eq!(
+        seen,
+        [
+            ("folder pack", "Mine", false),
+            ("Trades.zip", "More trades", true)
+        ]
+    );
+
+    let drops = root.join("drops");
+    zip_file(
+        &drops.join("Gone.zip"),
+        &[("pack.mcmeta", META), ("data/g/tags/x.json", "{}")],
+    );
+    zip_file(
+        &drops.join("Trades.zip"),
+        &[("pack.mcmeta", META), ("data/t/function/b.mcfunction", "")],
+    );
+    zip_file(
+        &drops.join("Textures.zip"),
+        &[
+            ("pack.mcmeta", META),
+            ("assets/minecraft/textures/a.png", ""),
+        ],
+    );
+    // A pack disabled before it was taken out comes back on.
+    let gone = add(&world, &drops.join("Gone.zip")).unwrap();
+    assert!(gone.enabled);
+    assert!(!fs::read_to_string(world.join("datapacks.json"))
+        .unwrap()
+        .contains("Gone.zip"));
+    assert_eq!(
+        add(&world, &drops.join("Trades.zip")).unwrap().file,
+        "Trades (2).zip"
+    );
+    let refused = add(&world, &drops.join("Textures.zip")).unwrap_err();
+    assert!(refused.contains("resource pack"), "{refused}");
+
+    let folder = find(&world, "folder pack").unwrap();
+    let trash = root.join("trash");
+    std::env::set_var(crate::desktop_seams::TRASH_ENV, &trash);
+    remove(&world, &folder).unwrap();
+    std::env::remove_var(crate::desktop_seams::TRASH_ENV);
+    assert!(trash.join("folder pack/pack.mcmeta").is_file());
+    assert!(!fs::read_to_string(world.join("datapacks.json"))
+        .unwrap()
+        .contains("folder pack"));
+    assert_eq!(find(&world, "Trades").unwrap().file, "Trades.zip");
+    fs::remove_dir_all(&root).unwrap();
+}
diff --git a/launcher/src/datapacks_page.rs b/launcher/src/datapacks_page.rs
new file mode 100644
index 000000000..85c94a167
--- /dev/null
+++ b/launcher/src/datapacks_page.rs
@@ -0,0 +1,255 @@
+//! A world's data packs, opened under its row on Home (`horizon_launcher::datapacks`): what is
+//! in `datapacks/`, Add (a file picker) or a zip dropped on the world, and Remove (to the trash,
+//! after a confirmation).
+use super::*;
+use gpui::ExternalPaths;
+use horizon_launcher::datapacks::{self, DataPack};
+use horizon_launcher::worlds::World;
+use std::path::PathBuf;
+
+#[derive(Default)]
+pub(super) struct WorldPacks {
+    /// The world whose packs are open, and its packs as last read.
+    open: Option<PathBuf>,
+    list: Vec<DataPack>,
+    confirm_remove: Option<String>,
+    note: Option<Result<String, String>>,
+}
+
+impl Launcher {
+    /// Opens or closes the packs of `world` under its row.
+    pub(super) fn toggle_world_packs(&mut self, world: &World) {
+        if self.world_packs.open.as_ref() == Some(&world.path) {
+            self.world_packs = WorldPacks::default();
+        } else {
+            self.world_packs = WorldPacks {
+                open: Some(world.path.clone()),
+                list: datapacks::list(&world.path),
+                ..WorldPacks::default()
+            };
+        }
+    }
+
+    pub(super) fn world_packs_open(&self, world: &World) -> bool {
+        self.world_packs.open.as_ref() == Some(&world.path)
+    }
+
+    /// Copies dropped or picked zips into `world`, and opens its packs to show them.
+    pub(super) fn add_world_packs(&mut self, world: PathBuf, files: Vec<PathBuf>) {
+        let added: Result<Vec<String>, String> = files
+            .iter()
+            .map(|f| datapacks::add(&world, f).map(|p| p.file))
+            .collect();
+        self.world_packs = WorldPacks {
+            list: datapacks::list(&world),
+            note: Some(added.map(|names| {
+                format!(
+                    "Added {}: the game turns it on when the world opens.",
+                    names.join(", ")
+                )
+            })),
+            open: Some(world),
+            confirm_remove: None,
+        };
+    }
+
+    fn choose_world_packs(&mut self, world: PathBuf, cx: &mut Context<Self>) {
+        let paths = cx.prompt_for_paths(PathPromptOptions {
+            files: true,
+            directories: false,
+            multiple: true,
+            prompt: Some("Add".into()),
+        });
+        cx.spawn(async move |this, cx| {
+            if let Ok(Ok(Some(paths))) = paths.await {
+                let _ = this.update(cx, |this, cx| {
+                    this.add_world_packs(world, paths);
+                    cx.notify();
+                });
+            }
+        })
+        .detach();
+    }
+
+    /// A world row that takes dropped data packs.
+    pub(super) fn world_drop_target(
+        &self,
+        i: usize,
+        world: &World,
+        row: Div,
+        cx: &mut Context<Self>,
+    ) -> Stateful<Div> {
+        let t = self.theme;
+        let path = world.path.clone();
+        div()
+            .id(SharedString::from(format!("world-drop-{i}")))
+            .border_2()
+            .mx(px(-4.))
+            .p(px(2.))
+            .border_color(gpui::transparent_black())
+            .drag_over::<ExternalPaths>(move |s, _, _, _| s.border_color(t.accent))
+            .on_drop(cx.listener(move |this, paths: &ExternalPaths, _, cx| {
+                this.add_world_packs(path.clone(), paths.paths().to_vec());
+                cx.notify();
+            }))
+            .child(row)
+    }
+
+    /// The open world's packs, under its row.
+    pub(super) fn world_packs_panel(
+        &mut self,
+        world: &World,
+        cx: &mut Context<Self>,
+    ) -> Option<Div> {
+        if !self.world_packs_open(world) {
+            return None;
+        }
+        let t = self.theme;
+        let path = world.path.clone();
+        let mut panel = div()
+            .flex()
+            .flex_col()
+            .gap(px(6.))
+            .ml(px(62.))
+            .mb(px(6.))
+            .child(
+                div()
+                    .flex()
+                    .items_center()
+                    .justify_between()
+                    .child(caps("Data packs").text_color(t.muted))
+                    .child(
+                        div()
+                            .flex()
+                            .gap(px(6.))
+                            .child(
+                                button("world-packs-add", "Add data pack…", Kind::Ghost, &t)
+                                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                                        this.choose_world_packs(path.clone(), cx);
+                                        cx.notify();
+                                    })),
+                            )
+                            .child({
+                                let dir = world.path.join("datapacks");
+                                button("world-packs-folder", "Open folder", Kind::Ghost, &t)
+                                    .on_click(move |_, _, cx| {
+                                        let _ = std::fs::create_dir_all(&dir);
+                                        cx.open_with_system(&dir);
+                                    })
+                            }),
+                    ),
+            );
+        match &self.world_packs.note {
+            Some(Ok(m)) => {
+                panel = panel.child(text(theme::CAPTION).text_color(t.muted).child(m.clone()))
+            }
+            Some(Err(e)) => panel = panel.child(notice(e.clone(), &t)),
+            None => {}
+        }
+        if self.world_packs.list.is_empty() {
+            panel = panel.child(
+                text(theme::CAPTION)
+                    .text_color(t.muted)
+                    .child("None yet: drop a data pack .zip on the world, or use Add data pack…"),
+            );
+        }
+        for (i, pack) in self.world_packs.list.clone().into_iter().enumerate() {
+            let confirming = self.world_packs.confirm_remove.as_ref() == Some(&pack.file);
+            let mut actions = div().flex().items_center().gap(px(6.));
+            if confirming {
+                let (world, gone) = (world.path.clone(), pack.clone());
+                actions = actions
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.danger)
+                            .child("Move it to the trash?"),
+                    )
+                    .child(
+                        button(
+                            SharedString::from(format!("world-pack-keep-{i}")),
+                            "Keep",
+                            Kind::Ghost,
+                            &t,
+                        )
+                        .on_click(cx.listener(
+                            |this, _: &ClickEvent, _, cx| {
+                                this.world_packs.confirm_remove = None;
+                                cx.notify();
+                            },
+                        )),
+                    )
+                    .child(
+                        button(
+                            SharedString::from(format!("world-pack-trash-{i}")),
+                            "Move to trash",
+                            Kind::Secondary,
+                            &t,
+                        )
+                        .on_click(cx.listener(
+                            move |this, _: &ClickEvent, _, cx| {
+                                let note = datapacks::remove(&world, &gone)
+                                    .map(|()| format!("{} moved to the trash.", gone.file));
+                                this.world_packs.list = datapacks::list(&world);
+                                this.world_packs.note = Some(note);
+                                this.world_packs.confirm_remove = None;
+                                cx.notify();
+                            },
+                        )),
+                    );
+            } else {
+                let file = pack.file.clone();
+                if !pack.enabled {
+                    actions = actions.child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .child("Off in the game"),
+                    );
+                }
+                actions = actions.child(
+                    button(
+                        SharedString::from(format!("world-pack-remove-{i}")),
+                        "Remove",
+                        Kind::Ghost,
+                        &t,
+                    )
+                    .on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            this.world_packs.confirm_remove = Some(file.clone());
+                            cx.notify();
+                        },
+                    )),
+                );
+            }
+            panel = panel.child(
+                plate(&t)
+                    .flex()
+                    .items_center()
+                    .gap(px(12.))
+                    .px(px(12.))
+                    .py(px(6.))
+                    .child(blocks::icon("package", 16., t.muted))
+                    .child(
+                        div()
+                            .flex()
+                            .flex_col()
+                            .flex_1()
+                            .min_w_0()
+                            .child(
+                                text(theme::LABEL)
+                                    .text_color(t.ink)
+                                    .truncate()
+                                    .child(pack.file.clone()),
+                            )
+                            .child(
+                                text(theme::CAPTION)
+                                    .text_color(t.muted)
+                                    .truncate()
+                                    .child(pack.description.clone()),
+                            ),
+                    )
+                    .child(actions),
+            );
+        }
+        Some(panel)
+    }
+}
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index 4fb3c38d1..466c9330d 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -3,6 +3,7 @@ pub mod account;
 pub mod agents;
 pub mod backend;
 pub mod browser;
+pub mod datapacks;
 pub mod desktop;
 pub mod desktop_seams;
 #[cfg(unix)]
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index e7f606cd8..e0636600b 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -11,6 +11,7 @@ mod cli_tools;
 mod collection;
 mod console;
 mod cull;
+mod datapacks_page;
 mod game_tools;
 mod instances_page;
 mod internet;
@@ -239,6 +240,7 @@ struct Launcher {
     multiplayer: multiplayer_page::Multiplayer,
     screenshots: screenshots_page::Screenshots,
     game_packs: packs_page::Packs,
+    world_packs: datapacks_page::WorldPacks,
     /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar.
     offline_name: Option<String>,
     /// The player's servers, for the sidebar until the Servers page has read them.
@@ -402,6 +404,7 @@ impl Launcher {
             multiplayer: multiplayer_page::Multiplayer::default(),
             screenshots: screenshots_page::Screenshots::default(),
             game_packs: packs_page::Packs::default(),
+            world_packs: datapacks_page::WorldPacks::default(),
             offline_name: offline_name(),
             side_servers: horizon_launcher::servers::list(),
             art: art::Art::default(),
diff --git a/launcher/src/packs.rs b/launcher/src/packs.rs
index 368fe3408..7845fdcde 100644
--- a/launcher/src/packs.rs
+++ b/launcher/src/packs.rs
@@ -124,7 +124,7 @@ fn read(path: &Path, kind: Kind, on: &[String]) -> Option<Pack> {
 }
 
 /// A file at the root of a pack folder or zip, at most 4 MB.
-fn entry(path: &Path, name: &str) -> Option<Vec<u8>> {
+pub(crate) fn entry(path: &Path, name: &str) -> Option<Vec<u8>> {
     let mut out = Vec::new();
     if path.is_dir() {
         fs::File::open(path.join(name))
@@ -141,7 +141,7 @@ fn entry(path: &Path, name: &str) -> Option<Vec<u8>> {
 }
 
 /// A text component as plain text: its strings, without `§` formatting codes.
-fn plain(component: &serde_json::Value) -> String {
+pub(crate) fn plain(component: &serde_json::Value) -> String {
     fn walk(v: &serde_json::Value, out: &mut String) {
         match v {
             serde_json::Value::String(s) => out.push_str(s),
diff --git a/launcher/src/worlds_page.rs b/launcher/src/worlds_page.rs
index 5b7d4f9ee..16484a10a 100644
--- a/launcher/src/worlds_page.rs
+++ b/launcher/src/worlds_page.rs
@@ -166,7 +166,10 @@ impl Launcher {
             );
         }
         for (i, w) in list.into_iter().enumerate() {
-            section = section.child(self.world_row(i, w, cx));
+            let row = self.world_row(i, w.clone(), cx);
+            section = section
+                .child(self.world_drop_target(i, &w, row, cx))
+                .children(self.world_packs_panel(&w, cx));
         }
         Some(section)
     }
@@ -275,6 +278,19 @@ impl Launcher {
                         },
                     )),
                 )
+                .child({
+                    let world = w.clone();
+                    let label = match self.world_packs_open(&w) {
+                        true => "Hide data packs",
+                        false => "Data packs",
+                    };
+                    act("world-packs", label, Kind::Ghost).on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            this.toggle_world_packs(&world);
+                            cx.notify();
+                        },
+                    ))
+                })
                 .child(
                     act("world-folder", "Open folder", Kind::Ghost)
                         .on_click(move |_, _, cx| cx.open_with_system(&folder)),

From e70ead5bfe57eac08d45065d62859b5e326aebc1 Mon Sep 17 00:00:00 2001
From: socksprox <info@shadowfly.net>
Date: Tue, 27 Oct 2026 02:51:55 +0100
Subject: [PATCH 413/475] Multiplayer parity: four client/server movement and
 use divergences

- A remote client no longer tramples farmland or turtle eggs locally:
  BlockLandingWorld.is_server_level/is_client_side now reflect the
  player's client_side flag, as vanilla's fallOn gates trampling and
  entity events on `level instanceof ServerLevel`. The server's block
  change and teleport drive the change, so a player no longer ends up
  inside the grown block (phasing through when farmland turns to dirt).
- key.swapOffhand, key.drop and a mount's inventory key on a server now
  wait for the tick's input phase instead of sending a packet straight
  from the window event, like the click queue: no action packet leaks
  between CLIENT_TICK_END and a later pong.
- remote_use_item treats a refused consume like vanilla's
  InteractionResult.FAIL: a full player who right-clicks food no longer
  starts a use the server will refuse (the eat/noslow desync), the off
  hand gets its turn, and no use cooldown starts.
- The host's "moved too quickly" check subtracts the guest's
  server-simulated velocity like vanilla's expectedDist term, so a
  fast legitimate arrival (e.g. landing with elytra) isn't flagged.

Co-Authored-By: Devin <noreply@cognition.ai>
---
 crates/horizon-client/src/game.rs        |  6 +-
 crates/horizon-client/src/game/remote.rs | 83 +++++++++++++++++-------
 crates/horizon-client/src/lan/hub.rs     | 11 +++-
 crates/horizon-client/src/landing.rs     |  7 +-
 4 files changed, 75 insertions(+), 32 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 2bfdc1d49..fa0d09a31 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -11256,8 +11256,10 @@ impl Game<'_> {
             // key.swapOffhand: on a server, ServerboundPlayerActionPacket SWAP_ITEM_WITH_OFFHAND
             // (the server swaps the hands and sends both slots back; spectators can't).
             KeyCode::KeyF if self.screen == Screen::Playing && self.remote.is_some() => {
-                if !self.spectator() {
-                    self.remote_swap_hands();
+                if !self.spectator()
+                    && let Some(r) = self.remote.as_mut()
+                {
+                    r.pending_keys.push(key);
                 }
             }
             KeyCode::KeyF if self.screen == Screen::Playing => {
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 945af4585..946e55488 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -189,6 +189,10 @@ pub(super) struct Remote {
     destroying: Option<([i32; 3], u8, f32)>,
     destroy_delay: u32,
     input: horizon_client::interaction_input::InteractionInput,
+    /// Keys whose presses send a packet (swap hands, drop, a mount's
+    /// inventory): like the click queue, they wait for the tick's
+    /// `handleKeybinds` phase rather than going out between window events.
+    pub(super) pending_keys: Vec<KeyCode>,
     stop_mining: bool,
     placing: Option<([i32; 3], u64)>,
     death_message: Option<String>,
@@ -473,6 +477,7 @@ impl Game<'_> {
             destroying: None,
             destroy_delay: 0,
             input: Default::default(),
+            pending_keys: Vec::new(),
             stop_mining: false,
             placing: None,
             death_message: None,
@@ -4295,13 +4300,18 @@ impl Game<'_> {
         let Some(info) = self.res.items().get(&held.item).cloned() else {
             return false;
         };
+        // Food starts being eaten (Consumable.startConsuming). A food that
+        // can't be eaten (full and not always-edible) fails the use
+        // (InteractionResult.FAIL): startUseItem tries the other hand, and
+        // no cooldown or use animation starts.
+        let eating = self.with_hand(hand, |g| g.start_eating(&info));
+        if info.food.is_some() && !eating {
+            return false;
+        }
         // MultiPlayerGameMode.useItem runs the use here too (inside
         // startPrediction): the `use_cooldown` component starts its entry, and
         // the server's ClientboundCooldownPacket confirms it.
         self.apply_use_cooldown(&held);
-        // Food starts being eaten (Consumable.startConsuming), a book and
-        // quill opens.
-        self.with_hand(hand, |g| g.start_eating(&info));
         if self.with_hand(hand, |g| g.remote_use_book(&held)) {
             return true;
         }
@@ -4483,6 +4493,31 @@ impl Game<'_> {
         }
         let (attack, use_item) = (self.left, self.right);
         input.tick(&mut RemoteInputWorld(self), attack, use_item);
+        // handleKeybinds' keybind polls: the queued presses act now, in tick
+        // order, so no packet goes out between CLIENT_TICK_END and a pong.
+        let pending = self
+            .remote
+            .as_mut()
+            .map(|r| std::mem::take(&mut r.pending_keys))
+            .unwrap_or_default();
+        for key in pending {
+            match key {
+                KeyCode::KeyF if !self.spectator() => self.remote_swap_hands(),
+                KeyCode::KeyQ if !self.spectator() => {
+                    let all = self.keys.contains(&KeyCode::ControlLeft);
+                    self.remote_drop(all);
+                }
+                KeyCode::KeyE if self.riding_mount_with_menu() => {
+                    let id = self.remote.as_ref().map_or(0, |r| r.entity_id);
+                    self.send(S::PlayerCommand(play::PlayerCommand {
+                        id,
+                        action: 5,
+                        data: 0,
+                    }));
+                }
+                _ => {}
+            }
+        }
         if self.clicks.miss_time > 0 {
             self.clicks.miss_time -= 1;
         }
@@ -4594,22 +4629,8 @@ impl Game<'_> {
                 if self.spectator() {
                     return Ok(true);
                 }
-                let all = self.keys.contains(&KeyCode::ControlLeft);
-                // MultiPlayerGameMode.dropItem: predict removal before sending
-                // the action, then swing only if a nonempty stack was removed.
-                let dropped = horizon_client::items::take_held_drop(
-                    &mut self.inventory[self.selected],
-                    all,
-                    false,
-                );
-                self.send(S::PlayerAction(play::PlayerAction {
-                    action: if all { 4 } else { 5 },
-                    pos: [0; 3],
-                    direction: 0,
-                    sequence: 0,
-                }));
-                if dropped.is_some() {
-                    self.swing_hand(Hand::Main, SwingAnimation::DEFAULT);
+                if let Some(r) = self.remote.as_mut() {
+                    r.pending_keys.push(key);
                 }
                 Ok(true)
             }
@@ -4617,12 +4638,9 @@ impl Game<'_> {
             // horse or llama, the server opens its inventory
             // (ServerboundPlayerCommandPacket OPEN_INVENTORY).
             KeyCode::KeyE if self.riding_mount_with_menu() => {
-                let id = self.remote.as_ref().map_or(0, |r| r.entity_id);
-                self.send(S::PlayerCommand(play::PlayerCommand {
-                    id,
-                    action: 5,
-                    data: 0,
-                }));
+                if let Some(r) = self.remote.as_mut() {
+                    r.pending_keys.push(key);
+                }
                 Ok(true)
             }
             KeyCode::KeyE => {
@@ -4669,6 +4687,21 @@ impl Game<'_> {
             }));
         }
     }
+    /// MultiPlayerGameMode.dropItem (key.drop): predict the removal, then send
+    /// the action; swing only if a nonempty stack was removed.
+    fn remote_drop(&mut self, all: bool) {
+        let dropped =
+            horizon_client::items::take_held_drop(&mut self.inventory[self.selected], all, false);
+        self.send(S::PlayerAction(play::PlayerAction {
+            action: if all { 4 } else { 5 },
+            pos: [0; 3],
+            direction: 0,
+            sequence: 0,
+        }));
+        if dropped.is_some() {
+            self.swing_hand(Hand::Main, SwingAnimation::DEFAULT);
+        }
+    }
     /// Minecraft.handleKeybinds, key.swapOffhand: the server swaps the hands
     /// (ServerboundPlayerActionPacket SWAP_ITEM_WITH_OFFHAND at BlockPos.ZERO, facing down) and
     /// sends both slots back; nothing is predicted.
diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs
index b1a8cbc62..4e7ad2e79 100644
--- a/crates/horizon-client/src/lan/hub.rs
+++ b/crates/horizon-client/src/lan/hub.rs
@@ -2134,11 +2134,16 @@ impl Hub {
                 packets = 1;
             }
             // shouldCheckPlayerMovement (never the single-player owner).
-            // The server holds no velocity for a guest (getDeltaMovement),
-            // so nothing is expected.
             if !owner && check && (!g.fall_flying || elytra_check) {
                 let limit = if g.fall_flying { 300.0 } else { 100.0 };
-                if moved > limit * f64::from(packets) {
+                // `movedDist - expectedDist` (getDeltaMovement): the velocity
+                // the server last simulated for the guest is expected
+                // movement, not a violation — a landing glide keeps its speed.
+                let expected = g.motion.as_ref().map_or(0.0, |m| {
+                    let v = m.velocity;
+                    v.x * v.x + v.y * v.y + v.z * v.z
+                });
+                if moved - expected > limit * f64::from(packets) {
                     events.push(HostEvent::Warn(format!(
                         "{} moved too quickly! {},{},{}",
                         g.name,
diff --git a/crates/horizon-client/src/landing.rs b/crates/horizon-client/src/landing.rs
index 6fb1f7580..629d8c042 100644
--- a/crates/horizon-client/src/landing.rs
+++ b/crates/horizon-client/src/landing.rs
@@ -324,10 +324,13 @@ impl BlockLandingWorld for MotionWorld<'_, '_, '_> {
     type DamageSource = LandingDamage;
     type Sound = SceneSound;
     fn is_server_level(&self) -> bool {
-        true
+        // A remote client's world is a client level: it never tramples,
+        // the server's block change and teleport do it (FarmlandBlock.fallOn
+        // and TurtleEggBlock.fallOn check `level instanceof ServerLevel`).
+        !self.player.client_side
     }
     fn is_client_side(&mut self) -> Result<bool> {
-        Ok(false)
+        Ok(self.player.client_side)
     }
     fn random_float(&mut self) -> Result<f32> {
         Ok(self.scene.random.next_float())

From 9cb27796089e8ee1be9d03da58e82dd2487b6ff7 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:02:09 +0100
Subject: [PATCH 414/475] launcher: install mods and packs into the selected
 instance

The Mods page and `mods` commands installed everything into the default
game folder whichever instance was picked. Mods, resource packs and
shader packs now go into the selected instance's folder, and the
Installed list, updates, Remove and the mod switches are that
instance's; picking another instance reads its list. The page says which
instance it installs into when there are several. `mods list|install|
update|remove|enable|disable` take `--instance` (default: the selected
one). Java mods' checks stay shared in the default folder for the
search results.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md |  11 ++++-
 docs/mod-browser.md       |   5 ++
 launcher/src/cli.rs       | 101 +++++++++++++++++++++++++++++++++-----
 launcher/src/mods_page.rs |  65 ++++++++++++++++++------
 4 files changed, 153 insertions(+), 29 deletions(-)

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index c88c38c6b..9efaa1f37 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -572,10 +572,12 @@ MCP: `modpack_remove`, needs `confirm: true`.
 
 ## `horizon-launcher mods list`
 
-What the browser installed (the default).
+What the browser installed in an instance (the default).
 
     horizon-launcher mods list
 
+- `--instance`: The instance (default: the selected one)
+
 MCP: `mods_list`.
 
 ## `horizon-launcher mods search`
@@ -605,11 +607,12 @@ MCP: `mods_check`.
 
 ## `horizon-launcher mods install`
 
-Install a pack and what it needs, by its id or slug (checksums checked); a Java mod is ported into horizon-mods and turned on; a modpack is imported.
+Install a pack and what it needs into an instance, by its id or slug (checksums checked); a Java mod is ported into horizon-mods and turned on; a modpack is imported as an instance of its own.
 
     horizon-launcher mods install <PROJECT>
 
 - `PROJECT`
+- `--instance`: The instance (default: the selected one)
 - `--everything`: Allow a version made for another Minecraft version
 - `--source` (modrinth, curseforge, horizon)
 
@@ -623,6 +626,7 @@ Update what the browser installed (or one pack).
 
 - `PROJECT`
 - `--check`: Only say what is newer
+- `--instance`: The instance (default: the selected one)
 
 MCP: `mods_update`.
 
@@ -633,6 +637,7 @@ Remove a pack the browser installed.
     horizon-launcher mods remove <PROJECT>
 
 - `PROJECT`
+- `--instance`: The instance (default: the selected one)
 
 MCP: `mods_remove`, needs `confirm: true`.
 
@@ -643,6 +648,7 @@ Turn on a mod the browser installed (horizon-mods.txt, as the game's Options > M
     horizon-launcher mods enable <PROJECT>
 
 - `PROJECT`
+- `--instance`: The instance (default: the selected one)
 
 MCP: `mods_enable`.
 
@@ -653,6 +659,7 @@ Turn off a mod the browser installed; it stays installed.
     horizon-launcher mods disable <PROJECT>
 
 - `PROJECT`
+- `--instance`: The instance (default: the selected one)
 
 MCP: `mods_disable`.
 
diff --git a/docs/mod-browser.md b/docs/mod-browser.md
index d4483cd4e..dac595d8e 100644
--- a/docs/mod-browser.md
+++ b/docs/mod-browser.md
@@ -18,6 +18,11 @@ yet (Modrinth has no `horizon` loader).
 | Modpacks (`.mrpack`, CurseForge zip) | the Modpacks page's import | **Partly**: Horizon runs the mods it can port, from the player's own downloads ([modpacks.md](modpacks.md)) |
 | Shader packs (`.hshader`, Horizon's registry only) | `shaderpacks/` beside `options.txt` | **Works** when made for 26.3: checked by the game's own check before install ([shaders.md](shaders.md)). The `shaders/`-format packs on Modrinth and CurseForge are not offered |
 
+Mods, resource packs and shader packs go into the game folder of the instance selected in the sidebar, and the
+Installed list, updates and Remove are that instance's: picking another instance reads its list. The page says which
+instance it installs into when there is more than one. The CLI's `mods list|install|update|remove|enable|disable` take
+`--instance <name>` (default: the selected one). A modpack becomes an instance of its own.
+
 By default a search shows only what runs: Java mods made for 26.3, resource packs made for 26.3, and every modpack. **Show everything** lists the rest of the kind too, each marked with how well it runs; what doesn't run is
 never offered for install.
 
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 852fde696..f05d32ad1 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -339,8 +339,12 @@ enum MultiplayerCmd {
 
 #[derive(Subcommand)]
 enum ModsCmd {
-    /// What the browser installed (the default)
-    List,
+    /// What the browser installed in an instance (the default)
+    List {
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
     /// Search for packs Horizon loads
     Search {
         text: Vec<String>,
@@ -362,10 +366,14 @@ enum ModsCmd {
         #[arg(long, value_enum, default_value_t = SourceArg::Modrinth)]
         source: SourceArg,
     },
-    /// Install a pack and what it needs, by its id or slug (checksums checked); a Java mod is
-    /// ported into horizon-mods and turned on; a modpack is imported
+    /// Install a pack and what it needs into an instance, by its id or slug (checksums
+    /// checked); a Java mod is ported into horizon-mods and turned on; a modpack is imported as
+    /// an instance of its own
     Install {
         project: String,
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
         /// Allow a version made for another Minecraft version
         #[arg(long)]
         everything: bool,
@@ -378,13 +386,31 @@ enum ModsCmd {
         /// Only say what is newer
         #[arg(long)]
         check: bool,
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
     },
     /// Remove a pack the browser installed
-    Remove { project: String },
+    Remove {
+        project: String,
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
     /// Turn on a mod the browser installed (horizon-mods.txt, as the game's Options > Mods does)
-    Enable { project: String },
+    Enable {
+        project: String,
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
     /// Turn off a mod the browser installed; it stays installed
-    Disable { project: String },
+    Disable {
+        project: String,
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
 }
 
 #[derive(Clone, Copy, clap::ValueEnum)]
@@ -1035,7 +1061,7 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
         )?,
         Cmd::Instance { action } => instance(action.unwrap_or(InstanceCmd::List), as_json)?,
         Cmd::Modpack { action } => modpack(action.unwrap_or(ModpackCmd::List), as_json)?,
-        Cmd::Mods { action } => mods(action.unwrap_or(ModsCmd::List), as_json)?,
+        Cmd::Mods { action } => mods(action.unwrap_or(ModsCmd::List { instance: None }), as_json)?,
         Cmd::Servers { action } => servers(action.unwrap_or(ServersCmd::List), as_json)?,
         Cmd::Mcp => unreachable!(),
     }
@@ -1337,7 +1363,20 @@ fn servers(action: ServersCmd, as_json: bool) -> Result<(), String> {
 fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
     use horizon_launcher::browser::{horizon, installed, Kind, Query, SourceId};
     use horizon_launcher::modpacks;
-    let home = backend::game_home();
+    // What the browser installs goes into an instance's game folder; Java mods' checks are kept
+    // in the default one, shared by all.
+    let home = match &action {
+        ModsCmd::List { instance }
+        | ModsCmd::Install { instance, .. }
+        | ModsCmd::Update { instance, .. }
+        | ModsCmd::Remove { instance, .. }
+        | ModsCmd::Enable { instance, .. }
+        | ModsCmd::Disable { instance, .. } => match instance {
+            Some(name) => instances::find(name)?.home,
+            None => instances::selected().home,
+        },
+        ModsCmd::Search { .. } | ModsCmd::Check { .. } => backend::game_home(),
+    };
     let entry_json = |e: &installed::Entry| serde_json::to_value(e).unwrap_or_default();
     let line = |label: &str, f: f32| progress(label.to_string())(f);
     let from_registry = installed::Installed::load(&home)
@@ -1353,7 +1392,7 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
     }
     let on = matches!(action, ModsCmd::Enable { .. });
     match action {
-        ModsCmd::List => {
+        ModsCmd::List { .. } => {
             let list = installed::Installed::load(&home).entries;
             if as_json {
                 json(list.iter().map(entry_json).collect());
@@ -1476,6 +1515,7 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
             project,
             everything,
             source,
+            ..
         } => {
             let source = source.get()?;
             let p = source.project(&project)?;
@@ -1521,7 +1561,7 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
                 }
             }
         }
-        ModsCmd::Update { project, check } => {
+        ModsCmd::Update { project, check, .. } => {
             let list = installed::Installed::load(&home).entries;
             let chosen: Vec<_> = list
                 .iter()
@@ -1556,11 +1596,11 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
                 }
             }
         }
-        ModsCmd::Remove { project } => {
+        ModsCmd::Remove { project, .. } => {
             let e = installed::remove(&home, &project)?;
             println!("Removed {} ({}).", e.title, e.file);
         }
-        ModsCmd::Enable { project } | ModsCmd::Disable { project } => {
+        ModsCmd::Enable { project, .. } | ModsCmd::Disable { project, .. } => {
             let e = installed::Installed::load(&home)
                 .lookup(&project)
                 .cloned()
@@ -2070,4 +2110,39 @@ mod tests {
             _ => panic!("expected game-args"),
         }
     }
+
+    #[test]
+    fn mods_commands_name_their_instance() {
+        let parse = |args: &[&str]| {
+            let cli = Cli::try_parse_from([&["horizon-launcher", "mods"], args].concat()).unwrap();
+            match cli.command {
+                Some(Cmd::Mods { action }) => action,
+                _ => panic!("expected mods"),
+            }
+        };
+        match parse(&["install", "fresh-animations", "--instance", "Skyblock"]) {
+            Some(ModsCmd::Install {
+                project, instance, ..
+            }) => assert_eq!(
+                (project.as_str(), instance.as_deref()),
+                ("fresh-animations", Some("Skyblock"))
+            ),
+            _ => panic!("expected mods install"),
+        }
+        assert!(matches!(
+            parse(&["list"]),
+            Some(ModsCmd::List { instance: None })
+        ));
+        assert!(parse(&[]).is_none());
+        // Search and Check read no instance: checks are shared.
+        assert!(Cli::try_parse_from([
+            "horizon-launcher",
+            "mods",
+            "search",
+            "x",
+            "--instance",
+            "A"
+        ])
+        .is_err());
+    }
 }
diff --git a/launcher/src/mods_page.rs b/launcher/src/mods_page.rs
index b98cfb654..9feed87e0 100644
--- a/launcher/src/mods_page.rs
+++ b/launcher/src/mods_page.rs
@@ -12,6 +12,7 @@ use horizon_launcher::browser::{
 use horizon_launcher::modpacks;
 use horizon_port_pack::check::Check;
 use std::collections::HashMap;
+use std::path::PathBuf;
 
 /// The kinds, as the Mods page's tabs: name and icon.
 const KINDS: [(PackKind, &str, &str); 4] = [
@@ -71,6 +72,8 @@ pub(super) struct Mods {
     error: Option<String>,
     installed: Vec<installed::Entry>,
     loaded: bool,
+    /// The game folder the browser installs into and lists: the selected instance's.
+    home: Option<PathBuf>,
     /// The project being installed, and the line and fraction of its download.
     pub(super) busy: Option<(String, String, f32)>,
     message: Option<Result<String, String>>,
@@ -93,6 +96,11 @@ impl Mods {
         self.report_list.reset();
     }
 
+    /// The game folder installs go into: the selected instance's, once the page has read it.
+    pub(super) fn home(&self) -> PathBuf {
+        self.home.clone().unwrap_or_else(backend::game_home)
+    }
+
     /// Whether the Modpacks tab is open (the sidebar marks the pack shown there).
     pub(super) fn on_modpacks(&self) -> bool {
         self.kind == PackKind::Modpack
@@ -130,6 +138,7 @@ impl Mods {
             error: None,
             installed: Vec::new(),
             loaded: false,
+            home: None,
             busy: None,
             message: None,
             updates: HashMap::new(),
@@ -264,7 +273,7 @@ impl Launcher {
                 Event::Done(result, modpack) => {
                     m.busy = None;
                     m.message = Some(result);
-                    m.installed = installed::Installed::load(&backend::game_home()).entries;
+                    m.installed = installed::Installed::load(&m.home()).entries;
                     m.installed_list.reset();
                     if modpack {
                         // The Modpacks page reads its list again.
@@ -287,7 +296,7 @@ impl Launcher {
                 }
                 Event::TakenDown(lines) => {
                     m.message = Some(Ok(lines.join("\n")));
-                    m.installed = installed::Installed::load(&backend::game_home()).entries;
+                    m.installed = installed::Installed::load(&m.home()).entries;
                     m.installed_list.reset();
                 }
             }
@@ -363,11 +372,12 @@ impl Launcher {
             return;
         }
         let tx = self.mods.tx.clone();
+        let home = self.mods.home();
         std::thread::spawn(move || {
             let Ok(index) = horizon::index() else {
                 return;
             };
-            let lines = horizon::turn_off_revoked(&index, &backend::game_home());
+            let lines = horizon::turn_off_revoked(&index, &home);
             if !lines.is_empty() {
                 let _ = tx.send(Event::TakenDown(lines));
             }
@@ -376,7 +386,7 @@ impl Launcher {
 
     /// Turns a Horizon mod the browser installed on or off, as the game's Options > Mods does.
     fn mods_switch(&mut self, e: &installed::Entry) {
-        let home = backend::game_home();
+        let home = self.mods.home();
         let Some(id) = horizon::mod_id(e) else {
             return;
         };
@@ -418,6 +428,7 @@ impl Launcher {
         let tx = m.tx.clone();
         let queue = std::sync::Mutex::new(todo.into_iter());
         std::thread::spawn(move || {
+            // Checks are kept in the default game folder, shared by every instance.
             let home = backend::game_home();
             std::thread::scope(|s| {
                 for _ in 0..CHECKING {
@@ -490,8 +501,8 @@ impl Launcher {
         self.mods.busy = Some(("all".into(), "Updating…".into(), 0.));
         self.mods.updates.clear();
         let tx = self.mods.tx.clone();
+        let home = self.mods.home();
         std::thread::spawn(move || {
-            let home = backend::game_home();
             let count = todo.len();
             let (mut done, mut failed) = (Vec::new(), Vec::new());
             for (i, (source_id, id, title)) in todo.into_iter().enumerate() {
@@ -548,6 +559,7 @@ impl Launcher {
             .filter(|tag| backend::is_prepared(tag))
             .map(|tag| backend::resources(tag));
         let tx = self.mods.tx.clone();
+        let home = self.mods.home();
         std::thread::spawn(move || {
             let last = std::cell::Cell::new(-1);
             let progress = |line: &str, f: f32| {
@@ -587,7 +599,6 @@ impl Launcher {
                             modpacks::outcome(&pack)
                         ));
                     }
-                    let home = backend::game_home();
                     let done = installed::install(&*source, &p, everything, &home, &progress)?;
                     let names: Vec<String> = done
                         .iter()
@@ -690,12 +701,20 @@ impl Launcher {
 
     pub(super) fn mods_page(&mut self, cx: &mut Context<Self>) -> Div {
         let t = self.theme;
-        if !self.mods.loaded {
-            self.mods.loaded = true;
-            self.mods.installed = installed::Installed::load(&backend::game_home()).entries;
+        // Packs and mods go into the selected instance: picking another reads its list.
+        let home = self.selected_instance().map(|i| i.home.clone());
+        if !self.mods.loaded || (home.is_some() && self.mods.home != home) {
+            self.mods.home = home;
+            self.mods.installed = installed::Installed::load(&self.mods.home()).entries;
+            self.mods.installed_list.reset();
+            self.mods.updates.clear();
+            self.mods.confirm_remove = None;
             self.mods_check_updates();
             self.mods_taken_down();
-            self.mods_search(0);
+            if !self.mods.loaded {
+                self.mods_search(0);
+            }
+            self.mods.loaded = true;
         }
         let header = page_header(
             "Mods",
@@ -763,7 +782,8 @@ impl Launcher {
                     .when(!registry, |d| d.child(toggle)),
             )
             .child(source_note)
-            .children(filters);
+            .children(filters)
+            .children(self.mods_target_line());
         // The kinds are inventory tabs on the panel that holds the open one.
         let body = blocks::panel(&t).flex().flex_col().gap(px(24.)).p(px(20.));
         let page = |body: Div| {
@@ -791,6 +811,23 @@ impl Launcher {
         page(body.child(self.mods_results(cx)))
     }
 
+    /// Which instance installs go into, when there is more than one to pick from. A modpack
+    /// becomes an instance of its own.
+    fn mods_target_line(&self) -> Option<Div> {
+        let instance = self.selected_instance()?;
+        if self.instances.list.len() < 2 || self.mods.kind == PackKind::Modpack {
+            return None;
+        }
+        Some(
+            text(theme::CAPTION)
+                .text_color(self.theme.muted)
+                .child(format!(
+                    "Installs into {}: pick another instance on the left.",
+                    instance.name
+                )),
+        )
+    }
+
     /// The install under way and the last install's answer.
     pub(super) fn mods_busy_plate(&self) -> Vec<Div> {
         let t = self.theme;
@@ -885,7 +922,7 @@ impl Launcher {
             .when(confirming, |b| b.text_color(t.danger))
             .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
                 if this.mods.confirm_remove.as_ref() == Some(&id) {
-                    let home = backend::game_home();
+                    let home = this.mods.home();
                     this.mods.message = Some(
                         installed::remove(&home, &id).map(|e| format!("Removed {}.", e.title)),
                     );
@@ -898,8 +935,8 @@ impl Launcher {
                 cx.notify();
             }));
             if e.source == SourceId::Horizon && e.kind == PackKind::Mod {
-                let on = horizon::mod_id(e)
-                    .is_some_and(|id| java::is_enabled(&backend::game_home(), id));
+                let on =
+                    horizon::mod_id(e).is_some_and(|id| java::is_enabled(&self.mods.home(), id));
                 let entry = e.clone();
                 right = right.child(
                     div()

From d6017151266c7c9890a6d5d5604b0949daecd7c1 Mon Sep 17 00:00:00 2001
From: FusselTV <github@fussel.tv>
Date: Tue, 27 Oct 2026 03:08:53 +0100
Subject: [PATCH 415/475] Streaming: the last finished ring is lit against
 decorated neighbours

A chunk was lit only once all eight neighbours were finished, so the
outermost finished ring of a loaded area (a /forceload square, a /pregen
band's edge, a player's last ring) stayed unlit: saved as FULL with no
light at all, and with no generation animals, which wait for light.
Vanilla's LIGHT step needs its neighbours only at INITIALIZE_LIGHT
(ChunkPyramid), so its last FULL ring is lit against decorated chunks.

A light job now reads a neighbour that will not finish (past the area)
from its decorated proto chunk (ChunkGenerator::light_view). A chunk
saved unlit is saved again once lit, and one whose light changes when a
neighbour finishes later is saved again. `execute if loaded` needs the
chunk lit, as vanilla's needs it ENTITY_TICKING.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/game/commands/execute.rs              | 10 +++--
 crates/horizon-client/src/save.rs             |  3 ++
 crates/horizon-client/src/streaming.rs        | 40 ++++++++++++++++++-
 crates/horizon-client/src/vanillagen.rs       |  6 +++
 4 files changed, 53 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/game/commands/execute.rs b/crates/horizon-client/src/game/commands/execute.rs
index 3f7e4c2a0..b2b410337 100644
--- a/crates/horizon-client/src/game/commands/execute.rs
+++ b/crates/horizon-client/src/game/commands/execute.rs
@@ -807,10 +807,12 @@ impl Game<'_> {
                 .coords(c, "pos")
                 .map(|co| co.block(self.source_position(), self.source_rotation()));
             let dimension = self.command_source.map_or(self.dim, |s| s.dimension);
-            return Ok(flag(
-                dimension == self.dim
-                    && p.is_some_and(|p| self.world.chunks.contains_key(&(p[0] >> 4, p[2] >> 4))),
-            ));
+            // ExecuteCommand.isChunkLoaded: ENTITY_TICKING, which is past lit.
+            let loaded = |p: [i32; 3]| {
+                let key = (p[0] >> 4, p[2] >> 4);
+                self.world.chunks.contains_key(&key) && self.streaming.is_lit(key.0, key.1)
+            };
+            return Ok(flag(dimension == self.dim && p.is_some_and(loaded)));
         }
         if c.has("dimension") {
             let dimension = self.command_source.map_or(self.dim, |s| s.dimension);
diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs
index 5431adcd6..033392224 100644
--- a/crates/horizon-client/src/save.rs
+++ b/crates/horizon-client/src/save.rs
@@ -3841,6 +3841,9 @@ impl<G: ChunkGenerator> ChunkGenerator for Persistent<G> {
     fn is_decorated(&self, proto: &crate::streaming::Proto) -> bool {
         self.inner.is_decorated(proto)
     }
+    fn light_view(&self, proto: &crate::streaming::Proto) -> Option<Chunk> {
+        self.inner.light_view(proto)
+    }
     fn save_protos(&self, protos: &[&crate::streaming::Proto]) {
         self.save
             .tables
diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs
index 643a604bc..7d25cf64c 100644
--- a/crates/horizon-client/src/streaming.rs
+++ b/crates/horizon-client/src/streaming.rs
@@ -70,6 +70,11 @@ pub trait ChunkGenerator: Send + Sync + 'static {
         false
     }
     /// What to save of a proto chunk dropped before it became final.
+    /// A decorated proto chunk's blocks as a column, to light a finished
+    /// neighbour against (vanilla lights with neighbours at FEATURES).
+    fn light_view(&self, _proto: &Proto) -> Option<Chunk> {
+        None
+    }
     fn saved_proto(&self, _proto: &Proto) -> Option<crate::save::SavedProto> {
         None
     }
@@ -207,6 +212,7 @@ struct Shared {
 }
 pub struct Streaming {
     shared: Arc<Shared>,
+    light_view: Arc<dyn Fn(&Proto) -> Option<Chunk> + Send + Sync>,
     results: mpsc::Receiver<Done>,
     threads: Vec<thread::JoinHandle<()>>,
     order: u64,
@@ -531,8 +537,13 @@ impl Streaming {
                     .expect("spawn worker")
             })
             .collect();
+        let light_view = {
+            let generator = generator.clone();
+            Arc::new(move |p: &Proto| generator.light_view(p))
+        };
         Self {
             shared,
+            light_view,
             results,
             threads,
             order: 0,
@@ -746,6 +757,26 @@ impl Streaming {
     fn distance(&self, x: i32, z: i32) -> i64 {
         self.ranges().priority(x, z, self.loading)
     }
+    /// The 3x3 a light job reads: the finished columns, and for a neighbour
+    /// that will not finish (past the area), its decorated proto chunk, as
+    /// vanilla lights its last FULL ring against neighbours at FEATURES.
+    fn light_region(&self, world: &World, x: i32, z: i32) -> Option<Box<Region>> {
+        let mut region: Region = Default::default();
+        for dz in 0..3 {
+            for dx in 0..3 {
+                let n = (x + dx as i32 - 1, z + dz as i32 - 1);
+                region[dz][dx] = Some(match world.chunks.get(&n) {
+                    Some(chunk) => chunk.clone(),
+                    None if !self.in_range(n.0, n.1, 1) && self.decorated.contains(&n) => {
+                        let proto = self.protos.get(&n)?.as_ref()?;
+                        Arc::new((self.light_view)(proto)?)
+                    }
+                    None => return None,
+                });
+            }
+        }
+        Some(Box::new(region))
+    }
     fn region(world: &World, x: i32, z: i32) -> Option<Box<Region>> {
         let mut region: Region = Default::default();
         for dz in 0..3 {
@@ -866,6 +897,11 @@ impl Streaming {
                         } else {
                             apply_relighting(chunk, sections, &mut changed);
                         }
+                        // Saved unlit (at the edge of what was loaded), or its light
+                        // changed: saved again.
+                        if (first && !chunk.light_loaded) || !changed.is_empty() {
+                            world.modified.insert((x, z));
+                        }
                         chunk.lit = true;
                         if first {
                             for dz in -1..=1 {
@@ -1102,7 +1138,7 @@ impl Streaming {
                 world.dirty_light.remove(&(x, z));
                 continue;
             }
-            let Some(region) = Self::region(world, x, z) else {
+            let Some(region) = self.light_region(world, x, z) else {
                 continue;
             };
             world.dirty_light.remove(&(x, z));
@@ -1424,7 +1460,7 @@ impl Streaming {
                 counts[1] += 1;
             } else {
                 counts[2] += 1;
-                if Self::region(world, key.0, key.1).is_some() {
+                if self.light_region(world, key.0, key.1).is_some() {
                     world.dirty_light.insert(key);
                 }
             }
diff --git a/crates/horizon-client/src/vanillagen.rs b/crates/horizon-client/src/vanillagen.rs
index 923818a08..c07082426 100644
--- a/crates/horizon-client/src/vanillagen.rs
+++ b/crates/horizon-client/src/vanillagen.rs
@@ -433,6 +433,12 @@ impl ChunkGenerator for VanillaTerrain {
     fn is_decorated(&self, proto: &Proto) -> bool {
         matches!(proto.downcast_ref::<VanillaProto>(), Some(VanillaProto::Ready(c)) if c.is_decorated())
     }
+    fn light_view(&self, proto: &Proto) -> Option<Chunk> {
+        match proto.downcast_ref::<VanillaProto>() {
+            Some(VanillaProto::Ready(chunk)) => Some(self.column(chunk)),
+            _ => None,
+        }
+    }
     fn saved_proto(&self, proto: &Proto) -> Option<SavedProto> {
         let Some(VanillaProto::Ready(chunk)) = proto.downcast_ref::<VanillaProto>() else {
             return None;

From c3a12bf7924e141518b82431452377a5b73856ac Mon Sep 17 00:00:00 2001
From: Silas Lunsford <silaslunsford1@gmail.com>
Date: Mon, 26 Oct 2026 21:11:35 -0500
Subject: [PATCH 416/475] client: retune the entity-shadow depth bias to kill
 its rim flicker

The shadow quads lie exactly on block tops like vanilla's, but terrain
and shadows are separate draws: their fp32 depth interpolations disagree
by a few dozen ulps of the fragment depth, and at a constant bias of
16 ulps the rim re-rolled the fight with the block top as the camera
drifted a subpixel - the visible speckle. Subpixel yaw glides at three
camera pitches (70, 45, 20 down) measured ~88/~60/~26 strong flip
pixels a frame with the shadow, all on the rim, none without it.
A constant bias of 128 ulps covers the spread at any resolution while
staying far below what the 0.001 a model's feet sit higher amounts to,
so shadows never bleed onto the feet.

Co-Authored-By: GLM 5.3-Flash <noreply@z.ai>
---
 crates/horizon-client/src/gfx.rs | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index 70d882a98..22a96ffba 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -1818,19 +1818,21 @@ impl Renderer {
             false,
         );
         // RenderPipelines.ENTITY_SHADOW: translucent, depth test without
-        // writes. The quads lie on the block tops like vanilla's, but the
-        // terrain under them snaps to the subpixel grid at other vertices, so
-        // at a slant their depths differ by up to 1/256 of a pixel's depth
-        // slope and whole shadows failed the test. The bias covers that and
-        // the rounding, and stays below the 0.001 a model's feet sit higher
-        // (1/27 of a pixel's slope at the 16-block shadow range in 720p).
+        // writes. The quads lie exactly on the block tops like vanilla's, but
+        // terrain and shadows are separate draw paths, so their fp32 depth
+        // interpolations disagree by a few dozen ulps of the fragment depth
+        // and the shadow's rim z-fights with the block top (speckle that
+        // re-rolls as the camera drifts a subpixel). A constant bias of 128
+        // ulps covers that spread at any resolution while staying far below
+        // the 0.001 a model's feet sit higher, so shadows never bleed onto
+        // the feet.
         let shadow_blob_pipeline = entity_pipeline(
             "Entity shadows",
             None,
             false,
             wgpu::CompareFunction::GreaterEqual,
             wgpu::DepthBiasState {
-                constant: 16,
+                constant: 128,
                 slope_scale: 0.015,
                 clamp: 0.0,
             },

From 2a7420651e8b03e255cf63bba91a462b4b4ea335 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:15:49 +0100
Subject: [PATCH 417/475] launcher: find data packs on Modrinth and install one
 into a world

The Mods page gains a Data packs tab: Modrinth's data packs for 26.3,
each marked Partly with what Horizon runs of a data pack today
(functions, function tags, predicates, item modifiers). Install puts the
project's data pack file (not its mod build), checksum checked, into the
datapacks/ of a world picked on the tab, and says what of that zip runs
and what isn't read yet. A pack with nothing Horizon runs (worldgen
only) is refused. The world's list on Home shows it.

CLI and MCP: `mods search --kind datapack`, `mods install <pack> --world
<world>`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md               |   5 +-
 docs/mod-browser.md                     |   3 +-
 launcher/README.md                      |   4 +-
 launcher/src/browser.rs                 |  58 +++++++++++--
 launcher/src/browser/curseforge.rs      |   1 +
 launcher/src/browser/horizon.rs         |   1 +
 launcher/src/browser/installed.rs       |  62 ++++++++++++++
 launcher/src/browser/installed/tests.rs |  88 +++++++++++++++++++
 launcher/src/browser/modrinth.rs        |  25 +++++-
 launcher/src/browser/tests.rs           |  45 ++++++++++
 launcher/src/cli.rs                     |  48 ++++++++++-
 launcher/src/datapacks.rs               |  76 +++++++++++++++++
 launcher/src/datapacks/tests.rs         |  35 ++++++++
 launcher/src/datapacks_page.rs          |   9 ++
 launcher/src/main.rs                    |   2 +-
 launcher/src/mods_page.rs               | 107 ++++++++++++++++++++++--
 16 files changed, 548 insertions(+), 21 deletions(-)

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 9efaa1f37..a71df4257 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -587,7 +587,7 @@ Search for packs Horizon loads.
     horizon-launcher mods search [TEXT]...
 
 - `TEXT`
-- `--kind` (mod, resource, modpack, shader)
+- `--kind` (mod, resource, modpack, shader, datapack)
 - `--everything`: Also what was made for other versions or runs only partly, each marked
 - `--source` (modrinth, curseforge, horizon)
 
@@ -607,11 +607,12 @@ MCP: `mods_check`.
 
 ## `horizon-launcher mods install`
 
-Install a pack and what it needs into an instance, by its id or slug (checksums checked); a Java mod is ported into horizon-mods and turned on; a modpack is imported as an instance of its own.
+Install a pack and what it needs into an instance, by its id or slug (checksums checked); a Java mod is ported into horizon-mods and turned on; a modpack is imported as an instance of its own; a data pack goes into the world `--world` names.
 
     horizon-launcher mods install <PROJECT>
 
 - `PROJECT`
+- `--world`: Install the project's data pack into this world of the instance (its name or folder)
 - `--instance`: The instance (default: the selected one)
 - `--everything`: Allow a version made for another Minecraft version
 - `--source` (modrinth, curseforge, horizon)
diff --git a/docs/mod-browser.md b/docs/mod-browser.md
index dac595d8e..8db26c26a 100644
--- a/docs/mod-browser.md
+++ b/docs/mod-browser.md
@@ -1,6 +1,6 @@
 # The launcher's mod browser
 
-Search Modrinth (CurseForge support is coming soon) for Java mods, modpacks and resource packs, and Horizon's
+Search Modrinth (CurseForge support is coming soon) for Java mods, modpacks, resource packs and data packs, and Horizon's
 registry for Horizon's own mods, modpacks, resource packs and shader packs; see how well each one runs before installing it, and install it with its checksum checked. This is item 16 of the roadmap and issue #577. The code is in
 `launcher/src/browser.rs` and `launcher/src/browser/`.
 
@@ -17,6 +17,7 @@ yet (Modrinth has no `horizon` loader).
 | Resource packs | `resourcepacks/` beside `options.txt` | **Works** when made for 26.3 ([resource-packs.md](resource-packs.md) lists what Horizon reads). Older packs are **Partly**: they load with vanilla's compatibility warning |
 | Modpacks (`.mrpack`, CurseForge zip) | the Modpacks page's import | **Partly**: Horizon runs the mods it can port, from the player's own downloads ([modpacks.md](modpacks.md)) |
 | Shader packs (`.hshader`, Horizon's registry only) | `shaderpacks/` beside `options.txt` | **Works** when made for 26.3: checked by the game's own check before install ([shaders.md](shaders.md)). The `shaders/`-format packs on Modrinth and CurseForge are not offered |
+| Data packs (Modrinth) | `datapacks/` of the world picked on the **Data packs** tab (`mods install <pack> --world <world>`); not in the Installed list: each world's list on Home has them | **Partly**: Horizon runs a data pack's functions, function tags, predicates and item modifiers, not yet its recipes, loot tables, advancements, other tags or worldgen. The install reads the zip and says what of it runs; a pack with none of those (worldgen only, such as Tectonic) is refused |
 
 Mods, resource packs and shader packs go into the game folder of the instance selected in the sidebar, and the
 Installed list, updates and Remove are that instance's: picking another instance reads its list. The page says which
diff --git a/launcher/README.md b/launcher/README.md
index ddf7e3056..0fa2a6aef 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -92,7 +92,9 @@ The opening, then Play ([clip](docs/opening.webm)):
   `datapacks/` under its row: what is there (and which the game has turned off), **Add data pack…**,
   and **Remove** (to the trash); a data pack `.zip` dropped on a world goes into it. The game turns
   a new one on when the world opens. From the command line: `horizon-launcher worlds
-  datapack-list|datapack-add|datapack-remove <world> …`.
+  datapack-list|datapack-add|datapack-remove <world> …`. The Mods page's **Data packs** tab finds
+  them on Modrinth and installs one into the world picked there (`mods search --kind datapack`,
+  `mods install <pack> --world <world>`), saying what of it runs in Horizon.
 - **Packs**: Home lists the selected instance's resource packs and shader packs, each with a switch.
   The choice is the game's own: `resourcePacks` in options.txt (a pack turned on goes on top, as
   the game's Resource Packs screen does) and `pickedShaderPack` in `horizon-graphics.txt` (one shader
diff --git a/launcher/src/browser.rs b/launcher/src/browser.rs
index 295ba3c08..4d8bc5be4 100644
--- a/launcher/src/browser.rs
+++ b/launcher/src/browser.rs
@@ -3,8 +3,9 @@
 //! matches (docs/mod-browser.md).
 //!
 //! Offered: Java mods (Fabric, NeoForge, Forge), whose content Horizon ports and whose jar is
-//! checked before install ([`java`]), modpacks (imported and ported) and resource packs
-//! (`resourcepacks/`). Java code itself doesn't run in Horizon (docs/mods.md).
+//! checked before install ([`java`]), modpacks (imported and ported), resource packs
+//! (`resourcepacks/`) and data packs (into a world, [`installed::install_datapack`]). Java code
+//! itself doesn't run in Horizon (docs/mods.md).
 pub mod curseforge;
 pub mod details;
 pub mod download;
@@ -31,10 +32,18 @@ pub enum Kind {
     /// One of Horizon's own shader packs (`.hshader`, docs/shaders.md), from Horizon's registry
     /// only.
     Shader,
+    /// A data pack: it goes into one world's `datapacks/` (`crate::datapacks`).
+    DataPack,
 }
 
 impl Kind {
-    pub const ALL: [Kind; 4] = [Kind::Mod, Kind::Modpack, Kind::ResourcePack, Kind::Shader];
+    pub const ALL: [Kind; 5] = [
+        Kind::Mod,
+        Kind::Modpack,
+        Kind::ResourcePack,
+        Kind::Shader,
+        Kind::DataPack,
+    ];
 
     pub fn label(self) -> &'static str {
         match self {
@@ -42,16 +51,17 @@ impl Kind {
             Kind::ResourcePack => "Resource packs",
             Kind::Modpack => "Modpacks",
             Kind::Shader => "Shader packs",
+            Kind::DataPack => "Data packs",
         }
     }
 
-    /// The folder beside `options.txt` the file goes in; a modpack is imported and a mod
-    /// ported instead.
+    /// The folder beside `options.txt` the file goes in; a modpack is imported, a mod ported
+    /// and a data pack put in a world instead.
     pub fn folder(self) -> Option<&'static str> {
         match self {
             Kind::ResourcePack => Some("resourcepacks"),
             Kind::Shader => Some("shaderpacks"),
-            Kind::Modpack | Kind::Mod => None,
+            Kind::Modpack | Kind::Mod | Kind::DataPack => None,
         }
     }
 }
@@ -132,6 +142,19 @@ impl Project {
     pub fn support(&self) -> Support {
         support(self.kind, &self.game_versions, &self.loaders)
     }
+
+    /// The project as a data pack, for a search of data packs or an install into a world;
+    /// its page is Modrinth's data pack page.
+    pub fn as_datapack(self) -> Project {
+        Project {
+            page: match self.source {
+                SourceId::Modrinth => format!("https://modrinth.com/datapack/{}", self.slug),
+                _ => self.page,
+            },
+            kind: Kind::DataPack,
+            ..self
+        }
+    }
 }
 
 /// One downloadable file of a version, with the checksums its source publishes.
@@ -286,6 +309,14 @@ pub fn support(kind: Kind, game_versions: &[String], loaders: &[String]) -> Supp
             Support::Partial("Horizon runs the mods it can port, from your own downloads.".into())
         }
         Kind::Shader => Support::No("Not one of Horizon's own shader packs.".into()),
+        Kind::DataPack => {
+            let made_for = match newest_release(game_versions) {
+                _ if game_versions.iter().any(|v| v == GAME) => String::new(),
+                Some(newest) => format!("Made for {newest}: the game may refuse it. "),
+                None => "Lists no Minecraft version. ".into(),
+            };
+            Support::Partial(format!("{made_for}{DATAPACK_SUPPORT}"))
+        }
         Kind::Mod => {
             if !loaders.iter().any(|l| java::LOADERS.contains(&l.as_str())) {
                 Support::No("Not a Fabric, NeoForge or Forge mod.".into())
@@ -303,6 +334,12 @@ pub fn support(kind: Kind, game_versions: &[String], loaders: &[String]) -> Supp
     }
 }
 
+/// What a data pack does in Horizon today, said before install; the install says it for the
+/// pack's own files (`crate::datapacks::coverage`).
+pub const DATAPACK_SUPPORT: &str = "Horizon runs a data pack's functions, function tags, \
+     predicates and item modifiers; not yet its recipes, loot tables, advancements, other tags \
+     or worldgen.";
+
 /// A Minecraft version whose mods port-pack carries over: 1.21 and later (the data folders
 /// took their current names in 1.21).
 pub fn portable_version(v: &str) -> bool {
@@ -356,6 +393,15 @@ pub fn pick(kind: Kind, versions: &[Version], everything: bool) -> Option<&Versi
             .find(made_for)
             .or_else(|| usable.filter(java).find(|v| everything && ported(v)));
     }
+    if kind == Kind::DataPack {
+        // Most data packs on Modrinth ship a mod build too: only the data pack files.
+        let mut packs = usable.filter(|v| v.loaders.iter().any(|l| l == "datapack"));
+        let made_for = |v: &&Version| v.game_versions.iter().any(|g| g == GAME);
+        return packs
+            .clone()
+            .find(made_for)
+            .or_else(|| packs.find(|_| everything));
+    }
     let runs = |v: &&Version| match support(kind, &v.game_versions, &v.loaders) {
         Support::Works => true,
         // A modpack's version is for its own Minecraft.
diff --git a/launcher/src/browser/curseforge.rs b/launcher/src/browser/curseforge.rs
index 56d73777a..68002c5ed 100644
--- a/launcher/src/browser/curseforge.rs
+++ b/launcher/src/browser/curseforge.rs
@@ -25,6 +25,7 @@ fn class(kind: Kind) -> u64 {
         Kind::Modpack => 4471,
         Kind::Mod => 6,
         Kind::Shader => 6552,
+        Kind::DataPack => 6945,
     }
 }
 
diff --git a/launcher/src/browser/horizon.rs b/launcher/src/browser/horizon.rs
index 741fe336a..7357efc22 100644
--- a/launcher/src/browser/horizon.rs
+++ b/launcher/src/browser/horizon.rs
@@ -484,6 +484,7 @@ fn relative(kind: Kind, id: &str, file_name: &str) -> Result<String, String> {
         Kind::ResourcePack => Ok(format!("resourcepacks/{file_name}")),
         Kind::Shader => Ok(format!("shaderpacks/{file_name}")),
         Kind::Modpack => Err("A modpack installs as its own profile (pack::install).".into()),
+        Kind::DataPack => Err("Horizon's registry has no data packs.".into()),
     }
 }
 
diff --git a/launcher/src/browser/installed.rs b/launcher/src/browser/installed.rs
index c866dd26d..c6dcfb41f 100644
--- a/launcher/src/browser/installed.rs
+++ b/launcher/src/browser/installed.rs
@@ -296,5 +296,67 @@ pub fn fetch_modpack(
     source.fetch(file, folder, progress)
 }
 
+/// A data pack installed into a world.
+pub struct DataPackInstall {
+    pub pack: crate::datapacks::DataPack,
+    /// Its version's number.
+    pub number: String,
+    /// What of it runs in Horizon.
+    pub coverage: crate::datapacks::Coverage,
+}
+
+/// Downloads a project's data pack (checksum checked) into the world folder `world`, under a
+/// free name. Refused when nothing in it runs in Horizon yet. It isn't recorded with the
+/// browser's installs: the world's data pack list (Home, `worlds datapack-list`) has it.
+pub fn install_datapack(
+    source: &dyn Source,
+    project: &Project,
+    everything: bool,
+    world: &Path,
+    progress: &dyn Fn(f32),
+) -> Result<DataPackInstall, String> {
+    if project.kind != Kind::DataPack && !project.loaders.iter().any(|l| l == "datapack") {
+        return Err(format!("{} isn't a data pack.", project.title));
+    }
+    let versions = source.versions(project)?;
+    let version = pick(Kind::DataPack, &versions, everything).ok_or_else(|| {
+        format!(
+            "{} has no data pack for {}{}.",
+            project.title,
+            super::GAME,
+            if everything {
+                " or any other version"
+            } else {
+                ""
+            }
+        )
+    })?;
+    let file = version.file().expect("pick keeps versions with a file");
+    let folder = std::env::temp_dir().join(format!(
+        "horizon-launcher-datapack-{}-{}",
+        std::process::id(),
+        version.id
+    ));
+    let result = source.fetch(file, &folder, progress).and_then(|zip| {
+        let coverage = crate::datapacks::coverage(&zip)?;
+        if coverage.read.is_empty() {
+            return Err(format!(
+                "{} would change nothing in Horizon yet: it has no functions, predicates or item \
+                 modifiers, and Horizon doesn't read its {} yet.",
+                project.title,
+                coverage.not_read()
+            ));
+        }
+        let pack = crate::datapacks::add(world, &zip)?;
+        Ok(DataPackInstall {
+            pack,
+            number: version.number.clone(),
+            coverage,
+        })
+    });
+    let _ = fs::remove_dir_all(&folder);
+    result
+}
+
 #[cfg(test)]
 mod tests;
diff --git a/launcher/src/browser/installed/tests.rs b/launcher/src/browser/installed/tests.rs
index cb2814c29..152ff03c3 100644
--- a/launcher/src/browser/installed/tests.rs
+++ b/launcher/src/browser/installed/tests.rs
@@ -340,3 +340,91 @@ fn shader_packs_older_launchers_installed_are_left_alone() {
     assert!(home.join("shaderpacks/old-pack.zip").is_file());
     fs::remove_dir_all(&home).unwrap();
 }
+
+/// A data pack zip with these files.
+fn datapack_zip(files: &[&str]) -> Vec<u8> {
+    use std::io::Write;
+    let mut zip = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+    let options = zip::write::SimpleFileOptions::default();
+    zip.start_file("pack.mcmeta", options).unwrap();
+    zip.write_all(br#"{"pack":{"pack_format":94,"description":"Test"}}"#)
+        .unwrap();
+    for name in files {
+        zip.start_file(*name, options).unwrap();
+        zip.write_all(b"{}").unwrap();
+    }
+    zip.finish().unwrap().into_inner()
+}
+
+#[test]
+fn data_packs_go_into_a_world_when_something_in_them_runs() {
+    let world = home("datapack").join("saves/New World");
+    fs::create_dir_all(&world).unwrap();
+    let mut fake = Fake::default();
+    let mut tools = project("tools", Kind::DataPack);
+    tools.loaders = vec!["datapack".into()];
+    fake.add(tools);
+    let mut terrain = project("terrain", Kind::Mod);
+    terrain.loaders = vec!["datapack".into(), "fabric".into()];
+    fake.add(terrain);
+    let mut jar = project("jar", Kind::Mod);
+    jar.loaders = vec!["fabric".into()];
+    fake.add(jar);
+    let runs = datapack_zip(&[
+        "data/t/function/a.mcfunction",
+        "data/t/function/b.mcfunction",
+        "data/minecraft/tags/function/load.json",
+        "data/t/recipe/r.json",
+    ]);
+    fake.release("tools", "2.0", &[], &runs, false);
+    fake.release(
+        "terrain",
+        "1.0",
+        &[],
+        &datapack_zip(&["data/t/worldgen/biome/b.json"]),
+        false,
+    );
+    let tools = fake.project("tools").unwrap();
+    let off = &|_: f32| {};
+
+    let done = install_datapack(&fake, &tools, false, &world, off).unwrap();
+    assert_eq!(done.pack.file, "tools-2.0.zip");
+    assert!(done.pack.enabled);
+    assert_eq!(done.number, "2.0");
+    assert_eq!(
+        done.coverage.summary(),
+        "Runs its 2 functions, 1 function tag. Not read yet: 1 recipe."
+    );
+    assert!(world.join("datapacks/tools-2.0.zip").is_file());
+    // Nothing of it in the browser's own list.
+    assert!(Installed::load(world.parent().unwrap().parent().unwrap())
+        .entries
+        .is_empty());
+    let again = install_datapack(&fake, &tools, false, &world, off).unwrap();
+    assert_eq!(again.pack.file, "tools-2.0 (2).zip");
+
+    let terrain = fake.project("terrain").unwrap();
+    let refused = install_datapack(&fake, &terrain, false, &world, off)
+        .err()
+        .unwrap();
+    assert_eq!(
+        refused,
+        "Pack terrain would change nothing in Horizon yet: it has no functions, predicates or \
+         item modifiers, and Horizon doesn't read its 1 worldgen yet."
+    );
+    let jar = fake.project("jar").unwrap();
+    assert!(install_datapack(&fake, &jar, false, &world, off).is_err());
+
+    let mut bad = project("bad", Kind::DataPack);
+    bad.loaders = vec!["datapack".into()];
+    fake.add(bad);
+    fake.release("bad", "1", &[], &runs, true);
+    let bad = fake.project("bad").unwrap();
+    assert!(install_datapack(&fake, &bad, false, &world, off).is_err());
+    let names: Vec<String> = fs::read_dir(world.join("datapacks"))
+        .unwrap()
+        .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
+        .collect();
+    assert_eq!(names.len(), 2, "{names:?}");
+    fs::remove_dir_all(world.parent().unwrap().parent().unwrap()).unwrap();
+}
diff --git a/launcher/src/browser/modrinth.rs b/launcher/src/browser/modrinth.rs
index fb71d0391..7e821abaf 100644
--- a/launcher/src/browser/modrinth.rs
+++ b/launcher/src/browser/modrinth.rs
@@ -14,14 +14,17 @@ fn project_type(kind: Kind) -> &'static str {
         Kind::Modpack => "modpack",
         Kind::Mod => "mod",
         Kind::Shader => "shader",
+        Kind::DataPack => "datapack",
     }
 }
 
-/// The kind of a Modrinth project; its shader packs (the shaders/ format) are not offered.
+/// The kind of a Modrinth project; its shader packs (the shaders/ format) are not offered. A
+/// data pack says it is a `mod` (most also ship a mod build): the search for data packs marks
+/// its hits, and an install into a world asks for its data pack files.
 fn kind_of(project_type: &str) -> Option<Kind> {
     Kind::ALL
         .into_iter()
-        .filter(|k| *k != Kind::Shader)
+        .filter(|k| !matches!(k, Kind::Shader | Kind::DataPack))
         .find(|k| self::project_type(*k) == project_type)
 }
 
@@ -31,7 +34,9 @@ pub(super) fn facets(query: &Query) -> String {
     let mut all = vec![vec![format!("project_type:{}", project_type(query.kind))]];
     match &f.game_version {
         Some(v) => all.push(vec![format!("versions:{v}")]),
-        None if !query.everything && matches!(query.kind, Kind::ResourcePack | Kind::Mod) => {
+        None if !query.everything
+            && matches!(query.kind, Kind::ResourcePack | Kind::Mod | Kind::DataPack) =>
+        {
             all.push(vec![format!("versions:{GAME}")])
         }
         None => {}
@@ -182,6 +187,10 @@ impl Source for Modrinth {
             .into_iter()
             .flatten()
             .filter_map(parse_hit)
+            .map(|p| match query.kind {
+                Kind::DataPack => p.as_datapack(),
+                _ => p,
+            })
             .collect())
     }
 
@@ -222,7 +231,15 @@ impl Source for Modrinth {
             ));
         }
         let (c, l, v) = cached.as_ref().expect("filled above");
-        Ok(details::modrinth_tags(project_type(kind), c, l, v))
+        // Data packs share the mods' categories; their one loader is `datapack`.
+        let mut tags = match kind {
+            Kind::DataPack => details::modrinth_tags("mod", c, l, v),
+            _ => details::modrinth_tags(project_type(kind), c, l, v),
+        };
+        if kind == Kind::DataPack {
+            tags.loaders.clear();
+        }
+        Ok(tags)
     }
 }
 
diff --git a/launcher/src/browser/tests.rs b/launcher/src/browser/tests.rs
index 50bfbae40..eb22be38a 100644
--- a/launcher/src/browser/tests.rs
+++ b/launcher/src/browser/tests.rs
@@ -72,6 +72,51 @@ fn picks_the_newest_version_that_runs() {
     assert!(pick(Kind::ResourcePack, &[blocked, empty], true).is_none());
 }
 
+#[test]
+fn data_packs_are_their_own_kind() {
+    // Most data packs on Modrinth also ship a mod build; only the data pack files are picked.
+    let versions = [
+        version("fabric", &[GAME], &["fabric", "neoforge"]),
+        version("pack", &[GAME], &["datapack"]),
+        version("old", &["1.21.4"], &["datapack"]),
+    ];
+    assert_eq!(pick(Kind::DataPack, &versions, false).unwrap().id, "pack");
+    assert!(pick(Kind::DataPack, &versions[2..], false).is_none());
+    assert_eq!(
+        pick(Kind::DataPack, &versions[2..], true).unwrap().id,
+        "old"
+    );
+    assert!(pick(Kind::DataPack, &versions[..1], true).is_none());
+
+    let now = support(Kind::DataPack, &v(&[GAME]), &v(&["datapack"]));
+    assert_eq!(now.reason(), Some(DATAPACK_SUPPORT));
+    let old = support(Kind::DataPack, &v(&["1.21.4"]), &v(&["datapack"]));
+    assert!(
+        old.reason().unwrap().starts_with("Made for 1.21.4"),
+        "{old:?}"
+    );
+    assert!(old.installable());
+
+    assert_eq!(
+        modrinth::facets(&Query::new("", Kind::DataPack)),
+        r#"[["project_type:datapack"],["versions:26.3"]]"#
+    );
+    // A data pack's hit says `mod`: the search for data packs marks it.
+    let hit = serde_json::json!({
+        "project_id": "bVrj3hwG", "project_type": "mod", "slug": "terralith",
+        "title": "Terralith", "categories": ["datapack", "fabric", "worldgen"],
+        "versions": [GAME],
+    });
+    let p = modrinth::parse_hit(&hit).unwrap();
+    assert_eq!(p.kind, Kind::Mod);
+    let p = p.as_datapack();
+    assert_eq!(
+        (p.kind, p.page.as_str()),
+        (Kind::DataPack, "https://modrinth.com/datapack/terralith")
+    );
+    assert_eq!(Kind::DataPack.folder(), None);
+}
+
 #[test]
 fn file_names_must_be_plain() {
     for good in [
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index f05d32ad1..739db4234 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -368,9 +368,12 @@ enum ModsCmd {
     },
     /// Install a pack and what it needs into an instance, by its id or slug (checksums
     /// checked); a Java mod is ported into horizon-mods and turned on; a modpack is imported as
-    /// an instance of its own
+    /// an instance of its own; a data pack goes into the world `--world` names
     Install {
         project: String,
+        /// Install the project's data pack into this world of the instance (its name or folder)
+        #[arg(long)]
+        world: Option<String>,
         /// The instance (default: the selected one)
         #[arg(long)]
         instance: Option<String>,
@@ -420,6 +423,8 @@ enum KindArg {
     Modpack,
     /// Horizon's own shader packs (Horizon's registry only)
     Shader,
+    /// Data packs (Modrinth): install one into a world with `mods install <pack> --world <name>`
+    Datapack,
 }
 
 #[derive(Clone, Copy, clap::ValueEnum)]
@@ -1424,12 +1429,14 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
                 KindArg::Modpack => Kind::Modpack,
                 KindArg::Mod => Kind::Mod,
                 KindArg::Shader => Kind::Shader,
+                KindArg::Datapack => Kind::DataPack,
             };
             let query = Query {
                 everything,
                 ..Query::new(&text.join(" "), kind)
             };
             let found = source.get()?.search(&query)?;
+            let datapack = kind == Kind::DataPack;
             if as_json {
                 json(found.iter().map(|p| {
                     let support = p.support();
@@ -1441,6 +1448,9 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
                     })
                 }).collect());
             } else {
+                if datapack && !found.is_empty() {
+                    println!("{}\n", horizon_launcher::browser::DATAPACK_SUPPORT);
+                }
                 for p in &found {
                     let support = p.support();
                     if p.source == SourceId::Horizon {
@@ -1465,6 +1475,8 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
                     );
                     if unchecked {
                         println!("  horizon-launcher mods check {}", p.slug);
+                    } else if datapack {
+                        println!("  horizon-launcher mods install {} --world <world>", p.slug);
                     } else if let Some(why) = support.reason() {
                         println!("  {why}");
                     }
@@ -1515,10 +1527,44 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
             project,
             everything,
             source,
+            world,
             ..
         } => {
             let source = source.get()?;
             let p = source.project(&project)?;
+            if let Some(world) = world {
+                let world = horizon_launcher::worlds::find(&home, &world)?;
+                let done = installed::install_datapack(
+                    &*source,
+                    &p,
+                    everything,
+                    &world.path,
+                    &progress(p.title.clone()),
+                )?;
+                if as_json {
+                    json(serde_json::json!({
+                        "world": world.folder, "file": done.pack.file, "version": done.number,
+                        "runs": done.coverage.read, "not_read": done.coverage.unread,
+                    }));
+                } else {
+                    println!(
+                        "{} {} is in {}'s data packs as {}: the game turns it on when the world \
+                         opens. {}",
+                        p.title,
+                        done.number,
+                        world.name,
+                        done.pack.file,
+                        done.coverage.summary()
+                    );
+                }
+                return Ok(());
+            }
+            if p.kind == Kind::DataPack {
+                return Err(format!(
+                    "{} is a data pack: say which world with --world.",
+                    p.title
+                ));
+            }
             if p.kind == Kind::Modpack && p.source == SourceId::Horizon {
                 let pack = horizon::pack::install(&p.id, &line)?;
                 if as_json {
diff --git a/launcher/src/datapacks.rs b/launcher/src/datapacks.rs
index 1c6a2ac46..956a1dffe 100644
--- a/launcher/src/datapacks.rs
+++ b/launcher/src/datapacks.rs
@@ -151,6 +151,82 @@ pub fn remove(world: &Path, pack: &DataPack) -> Result<(), String> {
     forget(world, &pack.file)
 }
 
+/// What of a data pack the game reads today (its `DataStore`): `data/<namespace>/<kind>/`.
+pub const READ: [&str; 4] = ["function", "function tag", "predicate", "item_modifier"];
+
+/// A data pack's files by kind (`function`, `worldgen`, `item tag`...), with how many each.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Coverage {
+    /// What Horizon runs.
+    pub read: Vec<(String, usize)>,
+    /// What it doesn't read yet.
+    pub unread: Vec<(String, usize)>,
+}
+
+impl Coverage {
+    /// "Runs its 12 functions, 1 predicate. Not read yet: 40 worldgen, 3 recipes."
+    pub fn summary(&self) -> String {
+        let runs = match self.read.is_empty() {
+            true => "Nothing in it runs in Horizon yet.".to_string(),
+            false => format!("Runs its {}.", counts(&self.read)),
+        };
+        match self.unread.is_empty() {
+            true => runs,
+            false => format!("{runs} Not read yet: {}.", self.not_read()),
+        }
+    }
+
+    /// "1077 worldgen, 653 loot tables, 16 recipes": what Horizon doesn't read yet, the six
+    /// biggest kinds and how many other kinds.
+    pub fn not_read(&self) -> String {
+        let mut biggest = self.unread.clone();
+        biggest.sort_by_key(|(_, n)| std::cmp::Reverse(*n));
+        let others = biggest.len().saturating_sub(6);
+        biggest.truncate(6);
+        match others {
+            0 => counts(&biggest),
+            1 => format!("{} and 1 other kind", counts(&biggest)),
+            n => format!("{} and {n} other kinds", counts(&biggest)),
+        }
+    }
+}
+
+fn counts(list: &[(String, usize)]) -> String {
+    list.iter()
+        .map(|(k, n)| {
+            let k = k.replace('_', " ");
+            match *n == 1 || k == "worldgen" {
+                true => format!("{n} {k}"),
+                false => format!("{n} {k}s"),
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+/// Counts a data pack zip's files by kind, and splits them into what the game reads and what
+/// it doesn't yet.
+pub fn coverage(file: &Path) -> Result<Coverage, String> {
+    let zip = fs::File::open(file)
+        .ok()
+        .and_then(|f| zip::ZipArchive::new(f).ok())
+        .ok_or_else(|| format!("{} is not a zip file that can be read.", file.display()))?;
+    let mut kinds = std::collections::BTreeMap::<String, usize>::new();
+    for name in zip.file_names().filter(|n| !n.ends_with('/')) {
+        let parts: Vec<&str> = name.split('/').collect();
+        let kind = match parts.as_slice() {
+            ["data", _, "tags", tag, _, ..] => format!("{tag} tag"),
+            ["data", _, kind, _, ..] => kind.to_string(),
+            _ => continue,
+        };
+        *kinds.entry(kind).or_default() += 1;
+    }
+    let (read, unread) = kinds
+        .into_iter()
+        .partition(|(k, _)| READ.contains(&k.as_str()));
+    Ok(Coverage { read, unread })
+}
+
 #[cfg(test)]
 #[path = "datapacks/tests.rs"]
 mod tests;
diff --git a/launcher/src/datapacks/tests.rs b/launcher/src/datapacks/tests.rs
index 6fa54dd38..f5695c706 100644
--- a/launcher/src/datapacks/tests.rs
+++ b/launcher/src/datapacks/tests.rs
@@ -101,3 +101,38 @@ fn lists_adds_and_removes_as_the_game_reads_them() {
     assert_eq!(find(&world, "Trades").unwrap().file, "Trades.zip");
     fs::remove_dir_all(&root).unwrap();
 }
+
+#[test]
+fn coverage_says_what_runs() {
+    let root = scratch("coverage");
+    let file = root.join("p.zip");
+    zip_file(
+        &file,
+        &[
+            ("pack.mcmeta", META),
+            ("data/a/function/x.mcfunction", ""),
+            ("data/a/predicate/p.json", "{}"),
+            ("data/a/item_modifier/m.json", "{}"),
+            ("data/a/tags/item/i.json", "{}"),
+            ("data/a/loot_table/l.json", "{}"),
+            ("data/a/loot_table/k.json", "{}"),
+            ("data/a/worldgen/biome/b.json", "{}"),
+            ("assets/a/lang/en_us.json", "{}"),
+        ],
+    );
+    let c = coverage(&file).unwrap();
+    assert_eq!(
+        c.summary(),
+        "Runs its 1 function, 1 item modifier, 1 predicate. Not read yet: 2 loot tables, 1 item \
+         tag, 1 worldgen."
+    );
+    let many = Coverage {
+        read: Vec::new(),
+        unread: (1..=8).map(|n| (format!("kind{n}"), n)).collect(),
+    };
+    assert_eq!(
+        many.not_read(),
+        "8 kind8s, 7 kind7s, 6 kind6s, 5 kind5s, 4 kind4s, 3 kind3s and 2 other kinds"
+    );
+    fs::remove_dir_all(&root).unwrap();
+}
diff --git a/launcher/src/datapacks_page.rs b/launcher/src/datapacks_page.rs
index 85c94a167..452e2d2d5 100644
--- a/launcher/src/datapacks_page.rs
+++ b/launcher/src/datapacks_page.rs
@@ -16,6 +16,15 @@ pub(super) struct WorldPacks {
     note: Option<Result<String, String>>,
 }
 
+impl WorldPacks {
+    /// Reads the open world's packs again, after something else changed them.
+    pub(super) fn reread(&mut self) {
+        if let Some(world) = &self.open {
+            self.list = datapacks::list(world);
+        }
+    }
+}
+
 impl Launcher {
     /// Opens or closes the packs of `world` under its row.
     pub(super) fn toggle_world_packs(&mut self, world: &World) {
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index e0636600b..7534a000d 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -66,7 +66,7 @@ impl Page {
     /// `settings`) opens on that page, for screenshots; Home otherwise.
     fn from_env() -> Page {
         match std::env::var("HORIZON_LAUNCHER_PAGE").as_deref() {
-            Ok("mods" | "modpacks" | "shaders") => Page::Mods,
+            Ok("mods" | "modpacks" | "shaders" | "datapacks") => Page::Mods,
             Ok("servers") => Page::Servers,
             Ok("versions") => Page::Versions,
             Ok("notes") => Page::Notes,
diff --git a/launcher/src/mods_page.rs b/launcher/src/mods_page.rs
index 9feed87e0..5a3e88b24 100644
--- a/launcher/src/mods_page.rs
+++ b/launcher/src/mods_page.rs
@@ -15,11 +15,12 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 
 /// The kinds, as the Mods page's tabs: name and icon.
-const KINDS: [(PackKind, &str, &str); 4] = [
+const KINDS: [(PackKind, &str, &str); 5] = [
     (PackKind::Mod, "Mods", "box"),
     (PackKind::Modpack, "Modpacks", "archive"),
     (PackKind::ResourcePack, "Resource packs", "image"),
     (PackKind::Shader, "Shader packs", "zap"),
+    (PackKind::DataPack, "Data packs", "notes"),
 ];
 /// Java mods checked at once.
 const CHECKING: usize = 2;
@@ -74,6 +75,9 @@ pub(super) struct Mods {
     loaded: bool,
     /// The game folder the browser installs into and lists: the selected instance's.
     home: Option<PathBuf>,
+    /// Its worlds (folder, name), the last played first, and the one data packs go into.
+    worlds: Vec<(PathBuf, String)>,
+    world: Option<PathBuf>,
     /// The project being installed, and the line and fraction of its download.
     pub(super) busy: Option<(String, String, f32)>,
     message: Option<Result<String, String>>,
@@ -101,6 +105,22 @@ impl Mods {
         self.home.clone().unwrap_or_else(backend::game_home)
     }
 
+    /// Reads the instance's worlds again; the world picked for data packs stays when it is
+    /// still there, else the last played.
+    fn read_worlds(&mut self) {
+        self.worlds = horizon_launcher::worlds::list(&self.home())
+            .into_iter()
+            .map(|w| (w.path, w.name))
+            .collect();
+        if !self
+            .worlds
+            .iter()
+            .any(|(p, _)| Some(p) == self.world.as_ref())
+        {
+            self.world = self.worlds.first().map(|(p, _)| p.clone());
+        }
+    }
+
     /// Whether the Modpacks tab is open (the sidebar marks the pack shown there).
     pub(super) fn on_modpacks(&self) -> bool {
         self.kind == PackKind::Modpack
@@ -112,6 +132,7 @@ impl Mods {
         let kind = match page.as_deref() {
             Ok("modpacks") => PackKind::Modpack,
             Ok("shaders") => PackKind::Shader,
+            Ok("datapacks") => PackKind::DataPack,
             _ => PackKind::Mod,
         };
         Self {
@@ -139,6 +160,8 @@ impl Mods {
             installed: Vec::new(),
             loaded: false,
             home: None,
+            worlds: Vec::new(),
+            world: None,
             busy: None,
             message: None,
             updates: HashMap::new(),
@@ -245,6 +268,7 @@ impl Launcher {
         let mut changed = false;
         let mut to_check = Vec::new();
         let mut loaded = Vec::new();
+        let mut done = false;
         while let Ok(event) = self.mods.rx.try_recv() {
             changed = true;
             let m = &mut self.mods;
@@ -271,6 +295,7 @@ impl Launcher {
                     }
                 }
                 Event::Done(result, modpack) => {
+                    done = true;
                     m.busy = None;
                     m.message = Some(result);
                     m.installed = installed::Installed::load(&m.home()).entries;
@@ -318,6 +343,10 @@ impl Launcher {
             }
         }
         self.mods_check(to_check);
+        if done {
+            // A data pack put into a world shows in its list on Home.
+            self.world_packs.reread();
+        }
         for l in loaded {
             self.mods_loaded(l);
         }
@@ -560,6 +589,10 @@ impl Launcher {
             .map(|tag| backend::resources(tag));
         let tx = self.mods.tx.clone();
         let home = self.mods.home();
+        let world = self.mods.world.clone().and_then(|path| {
+            let (_, name) = self.mods.worlds.iter().find(|(p, _)| *p == path)?;
+            Some((path, name.clone()))
+        });
         std::thread::spawn(move || {
             let last = std::cell::Cell::new(-1);
             let progress = |line: &str, f: f32| {
@@ -576,6 +609,21 @@ impl Launcher {
                         Some(p) => p,
                         None => source.project(&id)?,
                     };
+                    if p.kind == PackKind::DataPack {
+                        let (world, name) =
+                            world.ok_or("Pick the world the data pack goes into first.")?;
+                        let done =
+                            installed::install_datapack(&*source, &p, everything, &world, &|f| {
+                                progress(&p.title, f)
+                            })?;
+                        return Ok(format!(
+                            "Put {} {} in {name}'s data packs, checksum checked: the game turns \
+                             it on when the world opens. {}",
+                            p.title,
+                            done.number,
+                            done.coverage.summary()
+                        ));
+                    }
                     modpack = p.kind == PackKind::Modpack;
                     if modpack && p.source == SourceId::Horizon {
                         let pack = horizon::pack::install(&p.id, &progress)?;
@@ -709,6 +757,7 @@ impl Launcher {
             self.mods.installed_list.reset();
             self.mods.updates.clear();
             self.mods.confirm_remove = None;
+            self.mods.read_worlds();
             self.mods_check_updates();
             self.mods_taken_down();
             if !self.mods.loaded {
@@ -735,6 +784,11 @@ impl Launcher {
                         if kind == PackKind::Shader {
                             this.mods.source = SourceId::Horizon;
                         }
+                        // Data packs are on Modrinth only; a world may have been made since.
+                        if kind == PackKind::DataPack {
+                            this.mods.source = SourceId::Modrinth;
+                            this.mods.read_worlds();
+                        }
                         // Categories and loaders differ by kind.
                         this.mods.browse.filters = Default::default();
                         this.mods.browse.open = None;
@@ -764,7 +818,8 @@ impl Launcher {
             }));
         // CurseForge support is coming soon: shown, inert, never searched (like the Microsoft
         // account's "Coming soon").
-        let source_note = div().flex().child(self.mods_source_switch(cx));
+        let source_note = (self.mods.kind != PackKind::DataPack)
+            .then(|| div().flex().child(self.mods_source_switch(cx)));
         // The registry lists only what was made for Horizon: no "everything", no Modrinth filters.
         let registry = self.mods.source == SourceId::Horizon;
         let filters = (!registry).then(|| self.mods_filters(cx));
@@ -781,9 +836,9 @@ impl Launcher {
                     .child(self.mods_field(cx))
                     .when(!registry, |d| d.child(toggle)),
             )
-            .child(source_note)
+            .children(source_note)
             .children(filters)
-            .children(self.mods_target_line());
+            .children(self.mods_target_line(cx));
         // The kinds are inventory tabs on the panel that holds the open one.
         let body = blocks::panel(&t).flex().flex_col().gap(px(24.)).p(px(20.));
         let page = |body: Div| {
@@ -813,8 +868,11 @@ impl Launcher {
 
     /// Which instance installs go into, when there is more than one to pick from. A modpack
     /// becomes an instance of its own.
-    fn mods_target_line(&self) -> Option<Div> {
+    fn mods_target_line(&self, cx: &mut Context<Self>) -> Option<Div> {
         let instance = self.selected_instance()?;
+        if self.mods.kind == PackKind::DataPack {
+            return Some(self.mods_world_picker(&instance.name.clone(), cx));
+        }
         if self.instances.list.len() < 2 || self.mods.kind == PackKind::Modpack {
             return None;
         }
@@ -828,6 +886,45 @@ impl Launcher {
         )
     }
 
+    /// The world data packs go into: one of the instance's, picked here.
+    fn mods_world_picker(&self, instance: &str, cx: &mut Context<Self>) -> Div {
+        let t = self.theme;
+        let caption = |s: String| text(theme::CAPTION).text_color(t.muted).child(s);
+        if self.mods.worlds.is_empty() {
+            return div().child(caption(format!(
+                "A data pack goes into a world, and {instance} has none yet: create one in the \
+                 game, then come back."
+            )));
+        }
+        let mut chips = div().flex().flex_wrap().items_center().gap(px(6.));
+        for (i, (path, name)) in self.mods.worlds.iter().enumerate() {
+            let on = self.mods.world.as_ref() == Some(path);
+            let path = path.clone();
+            chips = chips.child(
+                button(
+                    SharedString::from(format!("mods-world-{i}")),
+                    name.clone(),
+                    if on { Kind::Secondary } else { Kind::Ghost },
+                    &t,
+                )
+                .when(on, |b| b.border_color(t.accent))
+                .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                    this.mods.world = Some(path.clone());
+                    cx.notify();
+                })),
+            );
+        }
+        div()
+            .flex()
+            .flex_col()
+            .gap(px(8.))
+            .child(caption(format!(
+                "Installs into a world of {instance}; the game turns the pack on when the world \
+                 opens."
+            )))
+            .child(chips)
+    }
+
     /// The install under way and the last install's answer.
     pub(super) fn mods_busy_plate(&self) -> Vec<Div> {
         let t = self.theme;

From a9e5214ae46d0201ce7c4b026954c986b1e2eac6 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:24:53 +0100
Subject: [PATCH 418/475] launcher: export an instance as a .mrpack or a zip

`horizon-launcher instance export [<instance>] [--format mrpack|zip]
[--world <w>]... [--out <file>]` (and its MCP tool) writes what makes an
instance, or a port: options.txt, horizon-*.txt, servers.dat, resource
and shader packs, horizon-mods/ and config/, plus the worlds named. It
never includes logs, screenshots, backups, caches or account files. A
world leaves out playerdata/, stats/ and advancements/, and its level.dat
is written without the player's UUID.

A .mrpack follows Modrinth's published format: modrinth.index.json
lists the resource packs the browser installed from Modrinth that are
unchanged, by their download with SHA-1 and SHA-512 asked from
Modrinth's API. The rest goes under overrides/. An instance with nothing
to share is refused.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md        |  13 ++
 launcher/src/browser/modrinth.rs |   8 +
 launcher/src/cli.rs              |  74 ++++++++
 launcher/src/export.rs           | 286 +++++++++++++++++++++++++++++++
 launcher/src/export/tests.rs     | 211 +++++++++++++++++++++++
 launcher/src/lib.rs              |   1 +
 6 files changed, 593 insertions(+)
 create mode 100644 launcher/src/export.rs
 create mode 100644 launcher/src/export/tests.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index a71df4257..dc4179468 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -331,6 +331,19 @@ Keep an instance on one installed Horizon version, or "latest" to follow updates
 
 MCP: `instance_version`.
 
+## `horizon-launcher instance export`
+
+Export an instance (or a port) to share: its settings, packs, Horizon mods and the worlds named, as a .mrpack (resource packs from Modrinth listed by download) or a zip. Never logs, screenshots or account data; worlds go without their per-player files.
+
+    horizon-launcher instance export [INSTANCE]
+
+- `INSTANCE`: The instance (default: the selected one)
+- `--format` (mrpack, zip)
+- `--world`: A world to put in it (its name or folder); repeat for more
+- `--out`: Where to write it (default: "<name>.mrpack" in the current folder)
+
+MCP: `instance_export`.
+
 ## `horizon-launcher worlds list`
 
 The worlds: name, mode, version, last played and size (the default).
diff --git a/launcher/src/browser/modrinth.rs b/launcher/src/browser/modrinth.rs
index 7e821abaf..d62e2a26d 100644
--- a/launcher/src/browser/modrinth.rs
+++ b/launcher/src/browser/modrinth.rs
@@ -172,6 +172,14 @@ pub(super) fn parse_version(v: &Value) -> Option<Version> {
     })
 }
 
+/// The files of one version (`GET /version/{id}`), with their downloads and checksums.
+pub fn version_files(version: &str) -> Result<Vec<FileRef>, String> {
+    let v = get(&format!("{API}/version/{}", encode(version)))?;
+    parse_version(&v)
+        .map(|v| v.files)
+        .ok_or_else(|| format!("Modrinth: no version {version}."))
+}
+
 impl Source for Modrinth {
     fn id(&self) -> SourceId {
         SourceId::Modrinth
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 739db4234..a2be8f7ed 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -183,6 +183,29 @@ enum InstanceCmd {
     Select { instance: String },
     /// Keep an instance on one installed Horizon version, or "latest" to follow updates again
     Version { instance: String, version: String },
+    /// Export an instance (or a port) to share: its settings, packs, Horizon mods and the worlds
+    /// named, as a .mrpack (resource packs from Modrinth listed by download) or a zip. Never
+    /// logs, screenshots or account data; worlds go without their per-player files
+    Export {
+        /// The instance (default: the selected one)
+        instance: Option<String>,
+        #[arg(long, value_enum, default_value_t = ExportFormat::Mrpack)]
+        format: ExportFormat,
+        /// A world to put in it (its name or folder); repeat for more
+        #[arg(long)]
+        world: Vec<String>,
+        /// Where to write it (default: "<name>.mrpack" in the current folder)
+        #[arg(long)]
+        out: Option<PathBuf>,
+    },
+}
+
+#[derive(Clone, Copy, clap::ValueEnum)]
+enum ExportFormat {
+    /// Modrinth's modpack format
+    Mrpack,
+    /// The game folder's layout, zipped
+    Zip,
 }
 
 #[derive(Subcommand)]
@@ -1742,6 +1765,57 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
             };
             changed(instances::edit(&instance, |m| m.version = pin)?)
         }
+        InstanceCmd::Export {
+            instance,
+            format,
+            world,
+            out,
+        } => {
+            use horizon_launcher::export::{self, Format};
+            let i = match instance {
+                Some(name) => instances::find(&name)?,
+                None => instances::selected(),
+            };
+            let format = match format {
+                ExportFormat::Mrpack => Format::Mrpack,
+                ExportFormat::Zip => Format::Zip,
+            };
+            let worlds = world
+                .iter()
+                .map(|w| horizon_launcher::worlds::find(&i.home, w).map(|w| w.folder))
+                .collect::<Result<Vec<_>, _>>()?;
+            let linked = match format {
+                Format::Mrpack => export::linkable(&i.home, &export::from_modrinth),
+                Format::Zip => Vec::new(),
+            };
+            let out = match out {
+                Some(out) => out,
+                None => export::free_path(
+                    &std::env::current_dir().map_err(|e| e.to_string())?,
+                    &i.name,
+                    format,
+                ),
+            };
+            let done = export::export(&i.home, &i.name, format, &worlds, &linked, &out)?;
+            if as_json {
+                json(serde_json::json!({
+                    "path": done.path, "copied": done.copied, "linked": done.linked,
+                    "worlds": done.worlds,
+                }));
+            } else {
+                println!(
+                    "Exported {} to {}: {} files, {} listed by their Modrinth download{}.",
+                    i.name,
+                    done.path.display(),
+                    done.copied,
+                    done.linked,
+                    match done.worlds.is_empty() {
+                        true => String::new(),
+                        false => format!(", worlds: {}", done.worlds.join(", ")),
+                    }
+                );
+            }
+        }
     }
     Ok(())
 }
diff --git a/launcher/src/export.rs b/launcher/src/export.rs
new file mode 100644
index 000000000..c1a1b9e45
--- /dev/null
+++ b/launcher/src/export.rs
@@ -0,0 +1,286 @@
+//! Sharing an instance (or a port): its settings, packs and Horizon mods, and the worlds the
+//! player picks, as a `.mrpack` (Modrinth's modpack format, from its published spec) or a plain
+//! `.zip` of the game folder's layout.
+//!
+//! Only what makes the instance goes in, from a fixed list ([`FILES`], [`FOLDERS`]): never logs,
+//! screenshots, backups, caches, or anything tied to the player's account. A world goes without
+//! its per-player files (`playerdata/`, `stats/`, `advancements/`) and its level.dat without the
+//! player's UUID.
+//!
+//! In a `.mrpack`, a resource pack the browser installed from Modrinth, still the same file, is
+//! listed by its download (`files`, with its SHA-1 and SHA-512) instead of being copied; the
+//! rest goes under `overrides/`, which a launcher copies into the game folder.
+use crate::browser::installed::{Entry, Installed};
+use crate::browser::{FileRef, Kind, SourceId, GAME};
+use horizon_world::nbt::{self, Limits, Tag};
+use sha2::Digest;
+use std::fs;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+
+/// The game folder's own files that are the instance's settings.
+pub const FILES: [&str; 6] = [
+    "options.txt",
+    "horizon-graphics.txt",
+    "horizon-extras.txt",
+    "horizon-controller.txt",
+    "horizon-mods.txt",
+    "servers.dat",
+];
+/// Its folders of packs, mods and their settings.
+pub const FOLDERS: [&str; 4] = ["resourcepacks", "shaderpacks", "horizon-mods", "config"];
+/// What a world keeps per player: left out.
+const PER_PLAYER: [&str; 4] = ["playerdata", "stats", "advancements", "session.lock"];
+const INDEX: &str = "modrinth.index.json";
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Format {
+    Mrpack,
+    Zip,
+}
+
+impl Format {
+    pub fn extension(self) -> &'static str {
+        match self {
+            Format::Mrpack => "mrpack",
+            Format::Zip => "zip",
+        }
+    }
+}
+
+/// A file of the instance that its source serves, listed in a `.mrpack` rather than copied.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Linked {
+    /// Relative to the game folder: `resourcepacks/<name>`.
+    pub path: String,
+    pub file: FileRef,
+}
+
+/// What an export wrote.
+#[derive(Debug, PartialEq)]
+pub struct Exported {
+    pub path: PathBuf,
+    /// Files copied in (overrides, for a `.mrpack`).
+    pub copied: usize,
+    /// Files listed by their download.
+    pub linked: usize,
+    /// The worlds in it, by folder.
+    pub worlds: Vec<String>,
+}
+
+/// Writes the instance whose game folder is `home` to `out`. `worlds` are folders of its
+/// `saves/`; `linked` comes from [`linkable`] (empty for a zip).
+pub fn export(
+    home: &Path,
+    name: &str,
+    format: Format,
+    worlds: &[String],
+    linked: &[Linked],
+    out: &Path,
+) -> Result<Exported, String> {
+    let mut files: Vec<(String, PathBuf)> = Vec::new();
+    for f in FILES {
+        if home.join(f).is_file() {
+            files.push((f.to_string(), home.join(f)));
+        }
+    }
+    for folder in FOLDERS {
+        walk(home, &home.join(folder), &[], &mut files);
+    }
+    for world in worlds {
+        let dir = home.join("saves").join(world);
+        if world.contains(['/', '\\']) || !dir.join("level.dat").is_file() {
+            return Err(format!("{name} has no world {world}."));
+        }
+        walk(home, &dir, &PER_PLAYER, &mut files);
+    }
+    let linked: Vec<&Linked> = match format {
+        Format::Mrpack => linked.iter().collect(),
+        Format::Zip => Vec::new(),
+    };
+    files.retain(|(rel, _)| !linked.iter().any(|l| l.path == *rel));
+    if files.is_empty() && linked.is_empty() {
+        return Err(format!(
+            "{name} has nothing to share yet: no settings, packs, mods or worlds."
+        ));
+    }
+    if let Some(dir) = out.parent() {
+        fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    }
+    let part = out.with_extension("part");
+    let written = write(&part, name, format, &files, &linked);
+    let done = written.and_then(|()| fs::rename(&part, out).map_err(|e| e.to_string()));
+    if let Err(e) = done {
+        let _ = fs::remove_file(&part);
+        return Err(format!("Could not export {name}: {e}"));
+    }
+    Ok(Exported {
+        path: out.to_path_buf(),
+        copied: files.len(),
+        linked: linked.len(),
+        worlds: worlds.to_vec(),
+    })
+}
+
+fn write(
+    path: &Path,
+    name: &str,
+    format: Format,
+    files: &[(String, PathBuf)],
+    linked: &[&Linked],
+) -> Result<(), String> {
+    let mut zip = zip::ZipWriter::new(fs::File::create(path).map_err(|e| e.to_string())?);
+    let options = zip::write::SimpleFileOptions::default();
+    let prefix = match format {
+        Format::Mrpack => {
+            zip.start_file(INDEX, options).map_err(|e| e.to_string())?;
+            let index = serde_json::to_vec_pretty(&index(name, linked)).unwrap();
+            zip.write_all(&index).map_err(|e| e.to_string())?;
+            "overrides/"
+        }
+        Format::Zip => "",
+    };
+    for (rel, file) in files {
+        let bytes = match rel.ends_with("/level.dat") {
+            true => shareable_level(file)?,
+            false => fs::read(file).map_err(|e| format!("{}: {e}", file.display()))?,
+        };
+        zip.start_file(format!("{prefix}{rel}"), options)
+            .map_err(|e| e.to_string())?;
+        zip.write_all(&bytes).map_err(|e| e.to_string())?;
+    }
+    zip.finish().map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+/// `modrinth.index.json`: format 1, the files by their downloads, and the Minecraft version.
+fn index(name: &str, linked: &[&Linked]) -> serde_json::Value {
+    let files: Vec<serde_json::Value> = linked
+        .iter()
+        .map(|l| {
+            serde_json::json!({
+                "path": l.path,
+                "hashes": { "sha1": l.file.sha1, "sha512": l.file.sha512 },
+                "env": { "client": "required", "server": "unsupported" },
+                "downloads": [l.file.url],
+                "fileSize": l.file.size,
+            })
+        })
+        .collect();
+    serde_json::json!({
+        "formatVersion": 1,
+        "game": "minecraft",
+        "versionId": "1",
+        "name": name,
+        "summary": format!("{name}, exported from Horizon."),
+        "files": files,
+        "dependencies": { "minecraft": GAME },
+    })
+}
+
+/// Every file under `dir`, relative to `home` with `/`, leaving out the names in `skip` at
+/// `dir`'s top and dot files.
+fn walk(home: &Path, dir: &Path, skip: &[&str], out: &mut Vec<(String, PathBuf)>) {
+    let Ok(entries) = fs::read_dir(dir) else {
+        return;
+    };
+    let mut entries: Vec<_> = entries.flatten().collect();
+    entries.sort_by_key(|e| e.file_name());
+    for e in entries {
+        let name = e.file_name().to_string_lossy().into_owned();
+        if name.starts_with('.') || skip.contains(&name.as_str()) {
+            continue;
+        }
+        let path = e.path();
+        if path.is_dir() {
+            walk(home, &path, &[], out);
+        } else if let Ok(rel) = path.strip_prefix(home) {
+            out.push((rel.to_string_lossy().replace('\\', "/"), path));
+        }
+    }
+}
+
+/// A world's level.dat without the player's UUID; unreadable, it goes as it is.
+fn shareable_level(file: &Path) -> Result<Vec<u8>, String> {
+    let bytes = fs::read(file).map_err(|e| format!("{}: {e}", file.display()))?;
+    let mut raw = Vec::new();
+    if flate2::read::GzDecoder::new(&bytes[..])
+        .take(64 << 20)
+        .read_to_end(&mut raw)
+        .is_err()
+    {
+        return Ok(bytes);
+    }
+    let Ok((mut root, _)) = nbt::read_named(&raw, Limits::default()) else {
+        return Ok(bytes);
+    };
+    if let Some(Tag::Compound(data)) = root.tag.get_mut("Data") {
+        if let Some(Tag::Compound(player)) = data.get_mut(&"Player".into()) {
+            player.remove(&"UUID".into());
+        }
+    }
+    let raw = nbt::write_named(&root, Limits::default()).map_err(|e| e.to_string())?;
+    let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+    gz.write_all(&raw).map_err(|e| e.to_string())?;
+    gz.finish().map_err(|e| e.to_string())
+}
+
+/// The resource packs the browser installed from Modrinth that are still the file it checked:
+/// with `lookup` (the source's file for an entry), what a `.mrpack` can list by download.
+pub fn linkable(home: &Path, lookup: &dyn Fn(&Entry) -> Option<FileRef>) -> Vec<Linked> {
+    Installed::load(home)
+        .entries
+        .iter()
+        .filter(|e| e.source == SourceId::Modrinth && e.kind == Kind::ResourcePack)
+        .filter(|e| {
+            let Ok(bytes) = fs::read(home.join(&e.file)) else {
+                return false;
+            };
+            let sum: String = sha2::Sha512::digest(&bytes)
+                .iter()
+                .map(|b| format!("{b:02x}"))
+                .collect();
+            e.checksum.strip_prefix("SHA-512:") == Some(sum.as_str())
+        })
+        .filter_map(|e| {
+            let file = lookup(e)?;
+            let same = file.sha512.as_deref() == e.checksum.strip_prefix("SHA-512:");
+            (same && file.sha1.is_some()).then(|| Linked {
+                path: e.file.clone(),
+                file,
+            })
+        })
+        .collect()
+}
+
+/// An entry's file as Modrinth serves it (asks Modrinth: for [`linkable`]).
+pub fn from_modrinth(e: &Entry) -> Option<FileRef> {
+    let sum = e.checksum.strip_prefix("SHA-512:")?;
+    crate::browser::modrinth::version_files(&e.version)
+        .ok()?
+        .into_iter()
+        .find(|f| f.sha512.as_deref() == Some(sum))
+}
+
+/// A free path for `name.<extension>` in `dir`: "Name (2).mrpack" when taken.
+pub fn free_path(dir: &Path, name: &str, format: Format) -> PathBuf {
+    let ext = format.extension();
+    let clean: String = name
+        .chars()
+        .map(|c| match c {
+            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '-',
+            c => c,
+        })
+        .collect();
+    (1..)
+        .map(|n| match n {
+            1 => dir.join(format!("{clean}.{ext}")),
+            n => dir.join(format!("{clean} ({n}).{ext}")),
+        })
+        .find(|p| !p.exists())
+        .unwrap()
+}
+
+#[cfg(test)]
+#[path = "export/tests.rs"]
+mod tests;
diff --git a/launcher/src/export/tests.rs b/launcher/src/export/tests.rs
new file mode 100644
index 000000000..d58cb4c4e
--- /dev/null
+++ b/launcher/src/export/tests.rs
@@ -0,0 +1,211 @@
+use super::*;
+use std::collections::BTreeMap;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-export-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+fn put(path: &Path, bytes: &[u8]) {
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(path, bytes).unwrap();
+}
+
+/// A gzipped level.dat whose player has a UUID.
+fn level_dat() -> Vec<u8> {
+    let mut player = BTreeMap::new();
+    player.insert("UUID".into(), Tag::IntArray(vec![1, 2, 3, 4]));
+    player.insert("XpLevel".into(), Tag::Int(7));
+    let mut data = BTreeMap::new();
+    data.insert("LevelName".into(), Tag::String("Base".into()));
+    data.insert("Player".into(), Tag::Compound(player));
+    let mut root = BTreeMap::new();
+    root.insert("Data".into(), Tag::Compound(data));
+    let raw = nbt::write_named(
+        &nbt::NamedTag {
+            name: "".into(),
+            tag: Tag::Compound(root),
+        },
+        Limits::default(),
+    )
+    .unwrap();
+    let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+    gz.write_all(&raw).unwrap();
+    gz.finish().unwrap()
+}
+
+fn sha512(bytes: &[u8]) -> String {
+    sha2::Sha512::digest(bytes)
+        .iter()
+        .map(|b| format!("{b:02x}"))
+        .collect()
+}
+
+/// A game folder with settings, packs, a mod, two worlds, and what never goes out.
+fn home(name: &str) -> PathBuf {
+    let home = scratch(name);
+    put(&home.join("options.txt"), b"lang:fr_ch\n");
+    put(&home.join("horizon-graphics.txt"), b"preset:high\n");
+    put(&home.join("servers.dat"), b"\x0a\x00\x00\x00");
+    put(&home.join("resourcepacks/Glass.zip"), b"glass pack");
+    put(&home.join("resourcepacks/Own.zip"), b"own pack");
+    put(
+        &home.join("horizon-mods/coords/horizon-mod.toml"),
+        b"id = \"coords\"\n",
+    );
+    put(&home.join("saves/Base/level.dat"), &level_dat());
+    put(&home.join("saves/Base/region/r.0.0.mca"), b"region");
+    put(&home.join("saves/Base/playerdata/0001.dat"), b"me");
+    put(&home.join("saves/Base/stats/0001.json"), b"{}");
+    put(&home.join("saves/Base/session.lock"), b"");
+    put(&home.join("saves/Other/level.dat"), &level_dat());
+    for private in [
+        "logs/latest.log",
+        "screenshots/a.png",
+        "backups/b.zip",
+        "mod-browser/checks-1/x/check.json",
+        "horizon-player.txt",
+        "session.json",
+        "usercache.json",
+        "resourcepacks/.DS_Store",
+    ] {
+        put(&home.join(private), b"private");
+    }
+    let entry = serde_json::json!({ "entries": [{
+        "source": "modrinth", "project": "P1", "slug": "glass", "title": "Glass",
+        "kind": "resource-pack", "version": "V1", "number": "1.0",
+        "file": "resourcepacks/Glass.zip",
+        "checksum": format!("SHA-512:{}", sha512(b"glass pack")),
+        "page": "https://modrinth.com/resourcepack/glass",
+    }]});
+    put(
+        &home.join("mod-browser.json"),
+        &serde_json::to_vec(&entry).unwrap(),
+    );
+    home
+}
+
+fn names(zip: &Path) -> Vec<String> {
+    let zip = zip::ZipArchive::new(fs::File::open(zip).unwrap()).unwrap();
+    let mut names: Vec<String> = zip.file_names().map(str::to_string).collect();
+    names.sort();
+    names
+}
+
+fn read(zip: &Path, name: &str) -> Vec<u8> {
+    let mut zip = zip::ZipArchive::new(fs::File::open(zip).unwrap()).unwrap();
+    let mut out = Vec::new();
+    zip.by_name(name).unwrap().read_to_end(&mut out).unwrap();
+    out
+}
+
+fn served(e: &Entry) -> Option<FileRef> {
+    (e.version == "V1").then(|| FileRef {
+        url: "https://cdn.modrinth.com/data/P1/versions/V1/Glass.zip".into(),
+        name: "Glass.zip".into(),
+        size: 10,
+        sha512: Some(sha512(b"glass pack")),
+        sha256: None,
+        sha1: Some("ab".repeat(20)),
+        primary: true,
+    })
+}
+
+#[test]
+fn a_zip_has_the_instance_and_the_picked_world_and_nothing_private() {
+    let home = home("zip");
+    let out = home.join("out/Hardcore.zip");
+    let done = export(&home, "Hardcore", Format::Zip, &["Base".into()], &[], &out).unwrap();
+    assert_eq!((done.copied, done.linked), (8, 0));
+    // Settings, packs, the mod and the picked world, without its per-player files; no logs,
+    // screenshots, backups, caches, account files or the other world.
+    assert_eq!(
+        names(&out),
+        [
+            "horizon-graphics.txt",
+            "horizon-mods/coords/horizon-mod.toml",
+            "options.txt",
+            "resourcepacks/Glass.zip",
+            "resourcepacks/Own.zip",
+            "saves/Base/level.dat",
+            "saves/Base/region/r.0.0.mca",
+            "servers.dat",
+        ]
+    );
+    // The world's level.dat keeps the player, without the UUID.
+    let mut raw = Vec::new();
+    flate2::read::GzDecoder::new(&read(&out, "saves/Base/level.dat")[..])
+        .read_to_end(&mut raw)
+        .unwrap();
+    let (root, _) = nbt::read_named(&raw, Limits::default()).unwrap();
+    let Some(Tag::Compound(data)) = root.tag.get("Data") else {
+        panic!("no Data")
+    };
+    let Some(Tag::Compound(player)) = data.get(&"Player".into()) else {
+        panic!("no Player")
+    };
+    assert!(player.get(&"UUID".into()).is_none());
+    assert_eq!(player.get(&"XpLevel".into()), Some(&Tag::Int(7)));
+    assert!(!out.with_extension("part").exists());
+
+    assert!(export(&home, "Hardcore", Format::Zip, &["../x".into()], &[], &out).is_err());
+    let empty = scratch("empty");
+    let refused = export(&empty, "New", Format::Zip, &[], &[], &empty.join("New.zip"));
+    assert_eq!(
+        refused.unwrap_err(),
+        "New has nothing to share yet: no settings, packs, mods or worlds."
+    );
+    assert!(!empty.join("New.zip").exists());
+    fs::remove_dir_all(&empty).unwrap();
+    fs::remove_dir_all(&home).unwrap();
+}
+
+#[test]
+fn an_mrpack_lists_what_modrinth_serves_and_carries_the_rest() {
+    let home = home("mrpack");
+    let linked = linkable(&home, &served);
+    assert_eq!(linked.len(), 1);
+    let out = free_path(&home, "Hard: core", Format::Mrpack);
+    assert_eq!(out.file_name().unwrap(), "Hard- core.mrpack");
+    let done = export(&home, "Hardcore", Format::Mrpack, &[], &linked, &out).unwrap();
+    assert_eq!((done.copied, done.linked), (5, 1));
+    assert_eq!(
+        names(&out),
+        [
+            "modrinth.index.json",
+            "overrides/horizon-graphics.txt",
+            "overrides/horizon-mods/coords/horizon-mod.toml",
+            "overrides/options.txt",
+            "overrides/resourcepacks/Own.zip",
+            "overrides/servers.dat",
+        ]
+    );
+    let index: serde_json::Value =
+        serde_json::from_slice(&read(&out, "modrinth.index.json")).unwrap();
+    assert_eq!(index["formatVersion"], 1);
+    assert_eq!(index["game"], "minecraft");
+    assert_eq!(index["dependencies"]["minecraft"], GAME);
+    let file = &index["files"][0];
+    assert_eq!(file["path"], "resourcepacks/Glass.zip");
+    assert_eq!(
+        file["downloads"][0],
+        "https://cdn.modrinth.com/data/P1/versions/V1/Glass.zip"
+    );
+    assert_eq!(file["hashes"]["sha512"], sha512(b"glass pack"));
+    assert_eq!(
+        free_path(&home, "Hard: core", Format::Mrpack)
+            .file_name()
+            .unwrap(),
+        "Hard- core (2).mrpack"
+    );
+
+    // A pack changed since its install is carried, not linked.
+    put(&home.join("resourcepacks/Glass.zip"), b"edited");
+    assert!(linkable(&home, &served).is_empty());
+    fs::remove_dir_all(&home).unwrap();
+}
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index 466c9330d..b8ff41253 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -6,6 +6,7 @@ pub mod browser;
 pub mod datapacks;
 pub mod desktop;
 pub mod desktop_seams;
+pub mod export;
 #[cfg(unix)]
 pub mod game_app;
 pub mod heads;

From 4482ff63f3d0a335ffa5b82ae54ac743d6e5203d Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:25:19 +0100
Subject: [PATCH 419/475] =?UTF-8?q?launcher:=20Export=E2=80=A6=20on=20Home?=
 =?UTF-8?q?'s=20Instance=20row?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Instance row gets Export…, which opens a panel to pick .mrpack or
.zip and switch on the worlds to include. The file goes to exports/ in
the launcher's data folder under a free name, and the panel offers Show
in folder. The panel closes when another instance is picked.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 launcher/README.md             |   9 ++
 launcher/src/export_page.rs    | 213 +++++++++++++++++++++++++++++++++
 launcher/src/instances_page.rs |  19 ++-
 launcher/src/main.rs           |   4 +
 4 files changed, 244 insertions(+), 1 deletion(-)
 create mode 100644 launcher/src/export_page.rs

diff --git a/launcher/README.md b/launcher/README.md
index 0fa2a6aef..ea5cc449b 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -83,6 +83,15 @@ The opening, then Play ([clip](docs/opening.webm)):
   instance plays the launcher's version, which follows updates, unless the Play page's version
   picker keeps it on another installed one (to keep an old world on the version it was made
   with); picking the version marked "follows updates" lets it follow again.
+- **Export**: Home's Instance row has **Export…**: the selected instance (or a port) as a `.mrpack`
+  (Modrinth's modpack format: resource packs the browser installed from Modrinth are listed by
+  their download, the rest is in `overrides/`) or a `.zip` of the game folder's layout, with the
+  worlds switched on. It is written to `exports/` in the launcher's data folder (**Show in
+  folder**). Only settings (options.txt, horizon-*.txt, servers.dat), resource and shader packs,
+  `horizon-mods/` and `config/` go in: never logs, screenshots, backups, caches or account files;
+  a world goes without `playerdata/`, `stats/` and `advancements/`, and its level.dat without the
+  player's UUID. `horizon-launcher instance export [<instance>] [--format mrpack|zip] [--world
+  <w>]… [--out <file>]`.
 - **Worlds**: Home lists the selected instance's worlds (picture, mode, version, last played,
   size). **Back up** zips one into the instance's `backups/` as the game's Make Backup does
   (`<date>_<time>_<folder>.zip`); **Copy** puts "<name> (1)" beside it; **Delete** moves it to the
diff --git a/launcher/src/export_page.rs b/launcher/src/export_page.rs
new file mode 100644
index 000000000..d21a60d46
--- /dev/null
+++ b/launcher/src/export_page.rs
@@ -0,0 +1,213 @@
+//! Export… on Home's Instance row: the selected instance as a `.mrpack` or a `.zip`, with the
+//! worlds the player switches on, written to the launcher's `exports/` folder
+//! (`horizon_launcher::export`).
+use super::*;
+use horizon_launcher::export::{self, Format};
+use std::path::PathBuf;
+
+pub(super) struct ExportPanel {
+    /// The instance it is for: picking another closes it.
+    instance: String,
+    format: Format,
+    /// The instance's worlds (folder, name) and whether each goes in.
+    worlds: Vec<(String, String, bool)>,
+    busy: bool,
+    /// The file written, or why not.
+    done: Option<Result<(String, PathBuf), String>>,
+}
+
+impl Launcher {
+    pub(super) fn toggle_export(&mut self) {
+        if self.export.take().is_some() {
+            return;
+        }
+        let Some(i) = self.selected_instance() else {
+            return;
+        };
+        let worlds = horizon_launcher::worlds::list(&i.home)
+            .into_iter()
+            .map(|w| (w.folder, w.name, false))
+            .collect();
+        self.export = Some(ExportPanel {
+            instance: i.id.clone(),
+            format: Format::Mrpack,
+            worlds,
+            busy: false,
+            done: None,
+        });
+    }
+
+    fn run_export(&mut self, cx: &mut Context<Self>) {
+        let Some(i) = self.selected_instance().cloned() else {
+            return;
+        };
+        let Some(panel) = self.export.as_mut().filter(|p| !p.busy) else {
+            return;
+        };
+        panel.busy = true;
+        panel.done = None;
+        let format = panel.format;
+        let worlds: Vec<String> = panel
+            .worlds
+            .iter()
+            .filter(|w| w.2)
+            .map(|w| w.0.clone())
+            .collect();
+        let task = cx.background_executor().spawn(async move {
+            let linked = match format {
+                Format::Mrpack => export::linkable(&i.home, &export::from_modrinth),
+                Format::Zip => Vec::new(),
+            };
+            let out = export::free_path(&backend::data_dir().join("exports"), &i.name, format);
+            export::export(&i.home, &i.name, format, &worlds, &linked, &out).map(|done| {
+                let linked = match done.linked {
+                    0 => String::new(),
+                    n => format!(", {n} listed by their Modrinth download"),
+                };
+                let file = done.path.file_name().unwrap_or_default().to_string_lossy();
+                (
+                    format!("Exported {file}: {} files{linked}.", done.copied),
+                    done.path,
+                )
+            })
+        });
+        cx.spawn(async move |this, cx| {
+            let done = task.await;
+            let _ = this.update(cx, |this, cx| {
+                if let Some(panel) = &mut this.export {
+                    panel.busy = false;
+                    panel.done = Some(done);
+                }
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    /// The panel under the Instance row, while it is open.
+    pub(super) fn export_panel(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let selected = self.selected_instance()?.id.clone();
+        if self.export.as_ref()?.instance != selected {
+            self.export = None;
+            return None;
+        }
+        let panel = self.export.as_ref()?;
+        let formats = [(Format::Mrpack, ".mrpack"), (Format::Zip, ".zip")];
+        let mut pick = div().flex().items_center().gap(px(6.));
+        for (format, label) in formats {
+            let on = panel.format == format;
+            pick = pick.child(
+                button(
+                    SharedString::from(format!("export-{}", format.extension())),
+                    label,
+                    if on { Kind::Secondary } else { Kind::Ghost },
+                    &t,
+                )
+                .when(on, |b| b.border_color(t.accent))
+                .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                    if let Some(p) = &mut this.export {
+                        p.format = format;
+                    }
+                    cx.notify();
+                })),
+            );
+        }
+        let about = match panel.format {
+            Format::Mrpack => {
+                "Modrinth's modpack format: resource packs from Modrinth are listed by their \
+                 download, the rest is carried in it."
+            }
+            Format::Zip => "The game folder's own layout, zipped.",
+        };
+        let mut worlds = div().flex().flex_col().gap(px(6.));
+        if panel.worlds.is_empty() {
+            worlds = worlds.child(
+                text(theme::CAPTION)
+                    .text_color(t.muted)
+                    .child("No worlds to put in."),
+            );
+        }
+        for (n, (_, name, on)) in panel.worlds.iter().enumerate() {
+            worlds = worlds.child(
+                div()
+                    .id(SharedString::from(format!("export-world-{n}")))
+                    .flex()
+                    .items_center()
+                    .gap(px(10.))
+                    .cursor_pointer()
+                    .child(switch(
+                        SharedString::from(format!("export-world-switch-{n}")),
+                        *on,
+                        &t,
+                    ))
+                    .child(
+                        text(theme::LABEL)
+                            .text_color(t.ink_soft)
+                            .child(name.clone()),
+                    )
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        if let Some(w) = this.export.as_mut().and_then(|p| p.worlds.get_mut(n)) {
+                            w.2 = !w.2;
+                        }
+                        cx.notify();
+                    })),
+            );
+        }
+        let go = button("export-run", "Export", Kind::Secondary, &t);
+        let go = match panel.busy {
+            true => disabled(go),
+            false => go.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                this.run_export(cx);
+                cx.notify();
+            })),
+        };
+        let result = match &panel.done {
+            Some(Ok((said, path))) => {
+                let path = path.clone();
+                Some(
+                    div()
+                        .flex()
+                        .items_center()
+                        .gap(px(10.))
+                        .child(text(theme::CAPTION).text_color(t.muted).child(said.clone()))
+                        .child(
+                            button("export-show", "Show in folder", Kind::Ghost, &t)
+                                .on_click(move |_, _, cx| cx.reveal_path(&path)),
+                        ),
+                )
+            }
+            Some(Err(e)) => Some(div().child(notice(e.clone(), &t))),
+            None => None,
+        };
+        Some(
+            plate(&t)
+                .flex()
+                .flex_col()
+                .gap(px(12.))
+                .px(px(14.))
+                .py(px(12.))
+                .ml(px(40.))
+                .child(caps("Export to share").text_color(t.muted))
+                .child(pick)
+                .child(text(theme::CAPTION).text_color(t.muted).child(about))
+                .child(caps("Worlds").text_color(t.muted))
+                .child(worlds)
+                .child(text(theme::CAPTION).text_color(t.muted).child(
+                    "Settings, packs and Horizon mods go in; logs, screenshots, backups and \
+                         your account never do. Worlds go without their per-player files.",
+                ))
+                .child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .gap(px(10.))
+                        .child(go)
+                        .when(panel.busy, |d| {
+                            d.child(text(theme::CAPTION).text_color(t.muted).child("Exporting…"))
+                        }),
+                )
+                .children(result),
+        )
+    }
+}
diff --git a/launcher/src/instances_page.rs b/launcher/src/instances_page.rs
index 6a4cd5ad0..9b4273b98 100644
--- a/launcher/src/instances_page.rs
+++ b/launcher/src/instances_page.rs
@@ -541,7 +541,8 @@ impl Launcher {
         )
     }
 
-    /// The Play page's row for the selected instance: its folder, and changing or copying it.
+    /// The Play page's row for the selected instance: its folder, and changing, copying or
+    /// exporting it.
     pub(super) fn instance_row(&mut self, n: usize, cx: &mut Context<Self>) -> Option<Div> {
         let t = self.theme;
         let instance = self.selected_instance()?.clone();
@@ -573,6 +574,22 @@ impl Launcher {
                     },
                 )),
             )
+            .child(
+                button(
+                    "instance-export",
+                    if self.export.is_some() {
+                        "Close export"
+                    } else {
+                        "Export…"
+                    },
+                    Kind::Ghost,
+                    &t,
+                )
+                .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                    this.toggle_export();
+                    cx.notify();
+                })),
+            )
             .child(
                 button("instance-folder", "Open folder", Kind::Ghost, &t).on_click(
                     move |_, _, cx| {
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 7534a000d..d591249b1 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -12,6 +12,7 @@ mod collection;
 mod console;
 mod cull;
 mod datapacks_page;
+mod export_page;
 mod game_tools;
 mod instances_page;
 mod internet;
@@ -241,6 +242,7 @@ struct Launcher {
     screenshots: screenshots_page::Screenshots,
     game_packs: packs_page::Packs,
     world_packs: datapacks_page::WorldPacks,
+    export: Option<export_page::ExportPanel>,
     /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar.
     offline_name: Option<String>,
     /// The player's servers, for the sidebar until the Servers page has read them.
@@ -405,6 +407,7 @@ impl Launcher {
             screenshots: screenshots_page::Screenshots::default(),
             game_packs: packs_page::Packs::default(),
             world_packs: datapacks_page::WorldPacks::default(),
+            export: None,
             offline_name: offline_name(),
             side_servers: horizon_launcher::servers::list(),
             art: art::Art::default(),
@@ -2109,6 +2112,7 @@ impl Launcher {
             .flex_col()
             .child(section_title("Ready to play", "check", &t).mb(px(12.)))
             .children(self.instance_row(1, cx))
+            .children(self.export_panel(cx))
             .child(index_row(
                 2,
                 "Resources",

From e28bcba3d393fab57f1dc242ab1deb3e179d1225 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:31:52 +0100
Subject: [PATCH 420/475] launcher: import a shared instance, or route any
 dropped file

`horizon_launcher::import` works out what a file is from its contents:
- a shared instance: a .mrpack needing no mod loader (as `instance
  export` writes) or a game-folder zip;
- a Java modpack: a .mrpack with a loader, or a CurseForge zip;
- a resource or shader pack;
- a data pack.

A shared instance becomes a new instance named after the pack, with
"(2)" if the name is taken. Its overrides/ (or the zip's entries) are
copied in, but only the files an instance keeps, and only paths that
stay inside its folder. Its .mrpack files are downloaded from Modrinth
and checked against their SHA-512. If anything fails, the half-made
folder is removed.

CLI and MCP: `horizon-launcher instance import <file> [--instance <i>]`
does what dropping the file on the window will do.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md    |  11 ++
 launcher/src/cli.rs          |  55 +++++++++
 launcher/src/import.rs       | 232 +++++++++++++++++++++++++++++++++++
 launcher/src/import/tests.rs | 207 +++++++++++++++++++++++++++++++
 launcher/src/lib.rs          |   1 +
 5 files changed, 506 insertions(+)
 create mode 100644 launcher/src/import.rs
 create mode 100644 launcher/src/import/tests.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index dc4179468..63f168e38 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -344,6 +344,17 @@ Export an instance (or a port) to share: its settings, packs, Horizon mods and t
 
 MCP: `instance_export`.
 
+## `horizon-launcher instance import`
+
+Import what a file is, as dropping it on the window does: a shared instance (a .mrpack without mod loaders, such as `instance export` writes, or a game folder zip) becomes a new instance; a Java modpack goes to the Modpacks import; a resource or shader pack into the instance (default: the selected one).
+
+    horizon-launcher instance import <FILE>
+
+- `FILE`
+- `--instance`: The instance a pack goes into
+
+MCP: `instance_import`.
+
 ## `horizon-launcher worlds list`
 
 The worlds: name, mode, version, last played and size (the default).
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index a2be8f7ed..6139a082b 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -198,6 +198,16 @@ enum InstanceCmd {
         #[arg(long)]
         out: Option<PathBuf>,
     },
+    /// Import what a file is, as dropping it on the window does: a shared instance (a .mrpack
+    /// without mod loaders, such as `instance export` writes, or a game folder zip) becomes a
+    /// new instance; a Java modpack goes to the Modpacks import; a resource or shader pack into
+    /// the instance (default: the selected one)
+    Import {
+        file: PathBuf,
+        /// The instance a pack goes into
+        #[arg(long)]
+        instance: Option<String>,
+    },
 }
 
 #[derive(Clone, Copy, clap::ValueEnum)]
@@ -1765,6 +1775,51 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
             };
             changed(instances::edit(&instance, |m| m.version = pin)?)
         }
+        InstanceCmd::Import { file, instance } => {
+            use horizon_launcher::import::{self, Dropped};
+            use horizon_launcher::modpacks;
+            match import::what(&file)? {
+                Dropped::Instance => {
+                    let i = import::import_instance(&file, &|line, _| eprintln!("{line}"))?;
+                    if as_json {
+                        json(value(&i, false));
+                    } else {
+                        println!(
+                            "Made the instance {} in {}: horizon-launcher instance select \"{}\"",
+                            i.name,
+                            i.home.display(),
+                            i.name
+                        );
+                    }
+                }
+                Dropped::Modpack => {
+                    let pack = modpacks::import(&file, &|line: String| eprintln!("{line}"))?;
+                    println!("{} ({})", modpacks::outcome(&pack), pack.summary());
+                    println!(
+                        "Port and play it: horizon-launcher modpack port {}",
+                        pack.slug
+                    );
+                }
+                Dropped::Pack(_) => {
+                    let i = match instance {
+                        Some(name) => instances::find(&name)?,
+                        None => instances::selected(),
+                    };
+                    let p = horizon_launcher::packs::add(&i.home, &file)?;
+                    println!(
+                        "Added {} to {}: turn it on with horizon-launcher packs on",
+                        p.title, i.name
+                    );
+                }
+                Dropped::DataPack => {
+                    return Err(format!(
+                        "{} is a data pack: put it into a world with horizon-launcher worlds \
+                         datapack-add <world> <file>",
+                        file.display()
+                    ))
+                }
+            }
+        }
         InstanceCmd::Export {
             instance,
             format,
diff --git a/launcher/src/import.rs b/launcher/src/import.rs
new file mode 100644
index 000000000..1d8625748
--- /dev/null
+++ b/launcher/src/import.rs
@@ -0,0 +1,232 @@
+//! A file dropped on the window (or given to `instance import`): what it is, and an instance
+//! made from a shared one.
+//!
+//! - A `.mrpack` that needs no mod loader (only `minecraft` in its dependencies), such as
+//!   [`crate::export`] writes, or a `.zip` laid out as a game folder: a new instance. Its
+//!   `overrides/` (and `client-overrides/`) go into the instance's folder; each of its `files`
+//!   is downloaded from Modrinth and checked against its SHA-512 (`browser::download`).
+//! - A `.mrpack` for a mod loader, or a CurseForge modpack zip (`manifest.json`): a Java
+//!   modpack, for the Modpacks import (`modpacks::import`).
+//! - A zip with `pack.mcmeta`: a data pack (`data/`) or a resource pack; with `shaders/`, or a
+//!   `.hshader`: a shader pack.
+//!
+//! Only what an instance holds is taken from a shared zip ([`crate::export::FILES`],
+//! [`crate::export::FOLDERS`], `saves/`), and every path is checked to stay inside its folder.
+use crate::browser::{download, FileRef};
+use crate::export::{FILES, FOLDERS};
+use crate::instances::{self, Instance};
+use crate::packs;
+use std::fs;
+use std::io::Read;
+use std::path::{Component, Path, PathBuf};
+
+const INDEX: &str = "modrinth.index.json";
+/// The `.mrpack` folders copied into the game folder; `server-overrides/` is a server's.
+const OVERRIDES: [&str; 2] = ["overrides/", "client-overrides/"];
+
+/// What a dropped file is.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Dropped {
+    /// A shared instance: a new instance is made from it.
+    Instance,
+    /// A Java modpack, for the Modpacks import.
+    Modpack,
+    /// A resource or shader pack, for the selected instance.
+    Pack(packs::Kind),
+    /// A data pack: it goes into a world.
+    DataPack,
+}
+
+fn open(file: &Path) -> Result<zip::ZipArchive<fs::File>, String> {
+    fs::File::open(file)
+        .ok()
+        .and_then(|f| zip::ZipArchive::new(f).ok())
+        .ok_or_else(|| format!("{} is not a zip file that can be read.", name_of(file)))
+}
+
+fn name_of(file: &Path) -> String {
+    file.file_name()
+        .map(|n| n.to_string_lossy().into_owned())
+        .unwrap_or_default()
+}
+
+fn read_index(zip: &mut zip::ZipArchive<fs::File>) -> Result<serde_json::Value, String> {
+    let mut text = Vec::new();
+    zip.by_name(INDEX)
+        .map_err(|_| format!("It has no {INDEX}: not a .mrpack."))?
+        .take(16 << 20)
+        .read_to_end(&mut text)
+        .map_err(|e| e.to_string())?;
+    serde_json::from_slice(&text).map_err(|e| format!("{INDEX}: {e}"))
+}
+
+/// What `file` is, from its name and what is inside.
+pub fn what(file: &Path) -> Result<Dropped, String> {
+    let name = name_of(file);
+    let ext = file
+        .extension()
+        .map(|e| e.to_string_lossy().to_ascii_lowercase());
+    match ext.as_deref() {
+        Some("hshader") => return Ok(Dropped::Pack(packs::Kind::Shader)),
+        Some("mrpack") => {
+            let index = read_index(&mut open(file)?)?;
+            let loaders = index["dependencies"]
+                .as_object()
+                .is_some_and(|d| d.keys().any(|k| k != "minecraft"));
+            return Ok(match loaders {
+                true => Dropped::Modpack,
+                false => Dropped::Instance,
+            });
+        }
+        Some("zip") => {}
+        _ => {
+            return Err(format!(
+                "{name} can't be imported: drop a .mrpack, a .zip or a .hshader."
+            ))
+        }
+    }
+    let zip = open(file)?;
+    let has = |n: &str| zip.index_for_name(n).is_some();
+    let under = |p: &str| zip.file_names().any(|n| n.starts_with(p));
+    if has("manifest.json") && !has("pack.mcmeta") {
+        return Ok(Dropped::Modpack);
+    }
+    if has("pack.mcmeta") {
+        return Ok(match under("data/") {
+            true => Dropped::DataPack,
+            false => Dropped::Pack(packs::Kind::Resource),
+        });
+    }
+    if under("shaders/") {
+        return Ok(Dropped::Pack(packs::Kind::Shader));
+    }
+    if FILES.iter().any(|f| has(f))
+        || under("saves/")
+        || FOLDERS.iter().any(|f| under(&format!("{f}/")))
+    {
+        return Ok(Dropped::Instance);
+    }
+    Err(format!(
+        "{name} is neither a pack nor a shared instance: nothing in it that Horizon reads."
+    ))
+}
+
+/// Where an archive entry goes in the instance's folder, when it is one an instance holds and
+/// stays inside it.
+fn target(home: &Path, relative: &str) -> Option<PathBuf> {
+    let path = Path::new(relative);
+    if relative.ends_with('/') || !path.components().all(|c| matches!(c, Component::Normal(_))) {
+        return None;
+    }
+    let top = relative.split('/').next()?;
+    let kept = FILES.contains(&relative)
+        || (relative.contains('/') && (FOLDERS.contains(&top) || top == "saves"));
+    kept.then(|| home.join(path))
+}
+
+/// Makes a new instance from a shared one: `file` is a `.mrpack` without mod loaders or a game
+/// folder `.zip`. Named after the pack (or the file), with "(2)" when the name is taken.
+pub fn import_instance(file: &Path, progress: &dyn Fn(&str, f32)) -> Result<Instance, String> {
+    import_into(file, progress, &|name| instances::create(name, None))
+}
+
+/// [`import_instance`] with the instance made by `create`.
+pub fn import_into(
+    file: &Path,
+    progress: &dyn Fn(&str, f32),
+    create: &dyn Fn(&str) -> Result<Instance, String>,
+) -> Result<Instance, String> {
+    if what(file)? != Dropped::Instance {
+        return Err(format!("{} is not a shared instance.", name_of(file)));
+    }
+    let mut zip = open(file)?;
+    let mrpack = zip.index_for_name(INDEX).is_some();
+    let index = match mrpack {
+        true => Some(read_index(&mut zip)?),
+        false => None,
+    };
+    let stem = file
+        .file_stem()
+        .map(|s| s.to_string_lossy().into_owned())
+        .unwrap_or_else(|| "Imported".into());
+    let base = index
+        .as_ref()
+        .and_then(|i| i["name"].as_str())
+        .map(str::trim)
+        .filter(|n| !n.is_empty())
+        .map(str::to_string)
+        .unwrap_or(stem);
+    let instance = (1..20)
+        .map(|n| match n {
+            1 => base.clone(),
+            n => format!("{base} ({n})"),
+        })
+        .find_map(|name| create(&name).ok())
+        .ok_or_else(|| format!("Could not make an instance called {base}."))?;
+    let home = instance.home.clone();
+    let filled = fill(&mut zip, index.as_ref(), &home, progress);
+    if let Err(e) = filled {
+        let _ = fs::remove_dir_all(&home);
+        return Err(e);
+    }
+    Ok(instance)
+}
+
+fn fill(
+    zip: &mut zip::ZipArchive<fs::File>,
+    index: Option<&serde_json::Value>,
+    home: &Path,
+    progress: &dyn Fn(&str, f32),
+) -> Result<(), String> {
+    let count = zip.len();
+    for i in 0..count {
+        let mut entry = zip.by_index(i).map_err(|e| e.to_string())?;
+        let name = entry.name().to_string();
+        let relative = match index {
+            Some(_) => match OVERRIDES.iter().find_map(|o| name.strip_prefix(o)) {
+                Some(r) => r.to_string(),
+                None => continue,
+            },
+            None => name.clone(),
+        };
+        let Some(to) = target(home, &relative) else {
+            continue;
+        };
+        fs::create_dir_all(to.parent().expect("inside home")).map_err(|e| e.to_string())?;
+        let mut out = fs::File::create(&to).map_err(|e| format!("{}: {e}", to.display()))?;
+        std::io::copy(&mut entry, &mut out).map_err(|e| format!("{}: {e}", to.display()))?;
+        progress(
+            &format!("Copying {relative}"),
+            (i + 1) as f32 / count as f32,
+        );
+    }
+    let files = index
+        .and_then(|i| i["files"].as_array())
+        .cloned()
+        .unwrap_or_default();
+    for f in files {
+        if f["env"]["client"] == "unsupported" {
+            continue;
+        }
+        let relative = f["path"].as_str().unwrap_or_default();
+        let to = target(home, relative)
+            .ok_or_else(|| format!("{relative} isn't a place an instance keeps files."))?;
+        let file = FileRef {
+            url: f["downloads"][0].as_str().unwrap_or_default().to_string(),
+            name: to.file_name().unwrap().to_string_lossy().into_owned(),
+            size: f["fileSize"].as_u64().unwrap_or(0),
+            sha512: f["hashes"]["sha512"].as_str().map(str::to_ascii_lowercase),
+            sha256: None,
+            sha1: f["hashes"]["sha1"].as_str().map(str::to_ascii_lowercase),
+            primary: true,
+        };
+        let folder = to.parent().expect("inside home");
+        download::fetch(&file, folder, &|p| progress(&file.name, p))
+            .map_err(|e| format!("{relative}: {e}"))?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+#[path = "import/tests.rs"]
+mod tests;
diff --git a/launcher/src/import/tests.rs b/launcher/src/import/tests.rs
new file mode 100644
index 000000000..dcbe0e548
--- /dev/null
+++ b/launcher/src/import/tests.rs
@@ -0,0 +1,207 @@
+use super::*;
+use crate::export::{export, Format};
+use std::io::Write;
+use std::time::Duration;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-import-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+fn zip_file(path: &Path, files: &[(&str, &[u8])]) {
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    let mut zip = zip::ZipWriter::new(fs::File::create(path).unwrap());
+    for (name, bytes) in files {
+        zip.start_file(*name, zip::write::SimpleFileOptions::default())
+            .unwrap();
+        zip.write_all(bytes).unwrap();
+    }
+    zip.finish().unwrap();
+}
+
+fn put(path: &Path, bytes: &[u8]) {
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(path, bytes).unwrap();
+}
+
+/// Makes instances as folders of `root`, refusing a name already taken, as the launcher does.
+fn maker(root: &Path) -> impl Fn(&str) -> Result<Instance, String> + '_ {
+    move |name: &str| {
+        let home = root.join(crate::modpacks::slug(name));
+        if home.exists() {
+            return Err(format!("There is already an instance called {name}."));
+        }
+        fs::create_dir_all(&home).unwrap();
+        Ok(Instance {
+            id: crate::modpacks::slug(name),
+            name: name.into(),
+            kind: instances::Kind::Own,
+            work: home.clone(),
+            home,
+            icon: None,
+            group: None,
+            version: None,
+            played: Duration::ZERO,
+            last_played: None,
+        })
+    }
+}
+
+const NONE: &dyn Fn(&str, f32) = &|_, _| {};
+
+#[test]
+fn says_what_a_dropped_file_is() {
+    let dir = scratch("what");
+    let mrpack = |name: &str, deps: &str| {
+        let path = dir.join(name);
+        let index = format!(r#"{{"formatVersion":1,"name":"P","files":[],"dependencies":{deps}}}"#);
+        zip_file(&path, &[("modrinth.index.json", index.as_bytes())]);
+        path
+    };
+    let cases: Vec<(PathBuf, Result<Dropped, ()>)> = vec![
+        (
+            mrpack("shared.mrpack", r#"{"minecraft":"26.3"}"#),
+            Ok(Dropped::Instance),
+        ),
+        (
+            mrpack(
+                "java.mrpack",
+                r#"{"minecraft":"1.21.1","fabric-loader":"0.16"}"#,
+            ),
+            Ok(Dropped::Modpack),
+        ),
+        {
+            let p = dir.join("cf.zip");
+            zip_file(
+                &p,
+                &[("manifest.json", b"{}"), ("overrides/config/a.toml", b"")],
+            );
+            (p, Ok(Dropped::Modpack))
+        },
+        {
+            let p = dir.join("rp.zip");
+            zip_file(&p, &[("pack.mcmeta", b"{}"), ("assets/a.png", b"")]);
+            (p, Ok(Dropped::Pack(packs::Kind::Resource)))
+        },
+        {
+            let p = dir.join("dp.zip");
+            zip_file(
+                &p,
+                &[
+                    ("pack.mcmeta", b"{}"),
+                    ("data/a/function/f.mcfunction", b""),
+                ],
+            );
+            (p, Ok(Dropped::DataPack))
+        },
+        {
+            let p = dir.join("sp.zip");
+            zip_file(&p, &[("shaders/final.fsh", b"")]);
+            (p, Ok(Dropped::Pack(packs::Kind::Shader)))
+        },
+        {
+            let p = dir.join("glow.hshader");
+            put(&p, b"PK");
+            (p, Ok(Dropped::Pack(packs::Kind::Shader)))
+        },
+        {
+            let p = dir.join("folder.zip");
+            zip_file(
+                &p,
+                &[("options.txt", b"lang:fr_ch\n"), ("saves/W/level.dat", b"")],
+            );
+            (p, Ok(Dropped::Instance))
+        },
+        {
+            let p = dir.join("random.zip");
+            zip_file(&p, &[("readme.txt", b"")]);
+            (p, Err(()))
+        },
+        {
+            let p = dir.join("picture.png");
+            put(&p, b"png");
+            (p, Err(()))
+        },
+    ];
+    for (file, want) in cases {
+        assert_eq!(what(&file).map_err(|_| ()), want, "{}", file.display());
+    }
+    fs::remove_dir_all(&dir).unwrap();
+}
+
+#[test]
+fn an_export_comes_back_as_an_instance_and_nothing_escapes_its_folder() {
+    let dir = scratch("roundtrip");
+    let home = dir.join("from");
+    put(&home.join("options.txt"), b"lang:fr_ch\n");
+    put(&home.join("resourcepacks/Glass.zip"), b"glass");
+    put(
+        &home.join("horizon-mods/coords/horizon-mod.toml"),
+        b"id = \"coords\"\n",
+    );
+    put(&home.join("saves/Base/region/r.0.0.mca"), b"region");
+    put(&home.join("saves/Base/level.dat"), b"not nbt");
+    let made = dir.join("instances");
+    for format in [Format::Mrpack, Format::Zip] {
+        let out = dir.join(format!("Shared.{}", format.extension()));
+        export(&home, "Shared", format, &["Base".into()], &[], &out).unwrap();
+        let i = import_into(&out, NONE, &maker(&made)).unwrap();
+        for f in [
+            "options.txt",
+            "resourcepacks/Glass.zip",
+            "horizon-mods/coords/horizon-mod.toml",
+            "saves/Base/region/r.0.0.mca",
+        ] {
+            assert_eq!(
+                fs::read(i.home.join(f)).unwrap(),
+                fs::read(home.join(f)).unwrap(),
+                "{f}"
+            );
+        }
+    }
+    // The .mrpack took the pack's name; the zip came second and got "(2)".
+    assert!(made.join("shared").is_dir() && made.join("shared-2").is_dir());
+
+    // A zip that reaches out of its folder, or carries what an instance doesn't keep.
+    let evil = dir.join("evil.zip");
+    zip_file(
+        &evil,
+        &[
+            ("options.txt", b"ok"),
+            ("../outside.txt", b"no"),
+            ("saves/../../up.txt", b"no"),
+            ("logs/latest.log", b"no"),
+            ("session.json", b"no"),
+        ],
+    );
+    let i = import_into(&evil, NONE, &maker(&made)).unwrap();
+    assert!(i.home.join("options.txt").is_file());
+    assert!(!dir.join("outside.txt").exists() && !made.join("up.txt").exists());
+    assert!(!i.home.join("logs").exists() && !i.home.join("session.json").exists());
+
+    // A file to download from anywhere but Modrinth is refused, and the half-made folder goes.
+    let index = r#"{"formatVersion":1,"name":"Far","dependencies":{"minecraft":"26.3"},
+        "files":[{"path":"resourcepacks/x.zip","hashes":{"sha1":"00","sha512":"00"},
+        "downloads":["https://example.com/x.zip"],"fileSize":1}]}"#;
+    let far = dir.join("far.mrpack");
+    zip_file(&far, &[("modrinth.index.json", index.as_bytes())]);
+    let refused = import_into(&far, NONE, &maker(&made)).unwrap_err();
+    assert!(refused.contains("resourcepacks/x.zip"), "{refused}");
+    assert!(!made.join("far").exists());
+
+    let java = dir.join("java.mrpack");
+    zip_file(
+        &java,
+        &[(
+            "modrinth.index.json",
+            br#"{"name":"J","files":[],"dependencies":{"neoforge":"21"}}"#,
+        )],
+    );
+    assert!(import_into(&java, NONE, &maker(&made)).is_err());
+    fs::remove_dir_all(&dir).unwrap();
+}
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index b8ff41253..85238283d 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -10,6 +10,7 @@ pub mod export;
 #[cfg(unix)]
 pub mod game_app;
 pub mod heads;
+pub mod import;
 pub mod instances;
 pub mod modpacks;
 pub mod mojang;

From b8b353c92e06d1795b5b51ab7bd5a7e143dbe78b Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:35:07 +0100
Subject: [PATCH 421/475] launcher: import a file dropped anywhere on the
 window

A file dropped on the window goes where it belongs:
- a shared instance becomes a new instance, which gets selected on Home;
- a Java modpack goes to the Modpacks import;
- a resource or shader pack goes into the selected instance;
- a data pack points to the world rows.

A note in the corner says what happened, until it is closed. The Packs
section and the world rows still take their own drops, and now stop the
drop there so it isn't imported twice.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 launcher/README.md             |   8 ++
 launcher/src/datapacks_page.rs |   2 +
 launcher/src/import_page.rs    | 132 +++++++++++++++++++++++++++++++++
 launcher/src/instances_page.rs |   2 +-
 launcher/src/main.rs           |   5 ++
 launcher/src/modpacks_page.rs  |   2 +-
 launcher/src/packs_page.rs     |   2 +
 7 files changed, 151 insertions(+), 2 deletions(-)
 create mode 100644 launcher/src/import_page.rs

diff --git a/launcher/README.md b/launcher/README.md
index ea5cc449b..7ffcc210a 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -92,6 +92,14 @@ The opening, then Play ([clip](docs/opening.webm)):
   a world goes without `playerdata/`, `stats/` and `advancements/`, and its level.dat without the
   player's UUID. `horizon-launcher instance export [<instance>] [--format mrpack|zip] [--world
   <w>]… [--out <file>]`.
+- **Import by dropping a file**: a file dropped anywhere on the window is imported for what it is
+  (`horizon_launcher::import`). A shared instance (a `.mrpack` that needs no mod loader, such as
+  Export writes, or a game folder `.zip`) becomes a new instance, opened on Home. Its `.mrpack`
+  downloads come from Modrinth with their SHA-512 checked, and only what an instance keeps is
+  taken, inside its folder. A Java modpack goes to the Modpacks import, and a resource or shader
+  pack into the selected instance. A data pack is pointed at the world rows, and the Packs section
+  and the world rows keep taking their own drops. A note in the corner says what happened.
+  `horizon-launcher instance import <file>`.
 - **Worlds**: Home lists the selected instance's worlds (picture, mode, version, last played,
   size). **Back up** zips one into the instance's `backups/` as the game's Make Backup does
   (`<date>_<time>_<folder>.zip`); **Copy** puts "<name> (1)" beside it; **Delete** moves it to the
diff --git a/launcher/src/datapacks_page.rs b/launcher/src/datapacks_page.rs
index 452e2d2d5..29c5ed9ba 100644
--- a/launcher/src/datapacks_page.rs
+++ b/launcher/src/datapacks_page.rs
@@ -99,6 +99,8 @@ impl Launcher {
             .drag_over::<ExternalPaths>(move |s, _, _, _| s.border_color(t.accent))
             .on_drop(cx.listener(move |this, paths: &ExternalPaths, _, cx| {
                 this.add_world_packs(path.clone(), paths.paths().to_vec());
+                // Not the window's import as well.
+                cx.stop_propagation();
                 cx.notify();
             }))
             .child(row)
diff --git a/launcher/src/import_page.rs b/launcher/src/import_page.rs
new file mode 100644
index 000000000..c6aa9bb97
--- /dev/null
+++ b/launcher/src/import_page.rs
@@ -0,0 +1,132 @@
+//! Files dropped anywhere on the window (`horizon_launcher::import`): a shared instance becomes
+//! a new instance, a Java modpack goes to the Modpacks import, a resource or shader pack into
+//! the selected instance. The Packs section and the world rows take their own drops first.
+use super::*;
+use gpui::ExternalPaths;
+use horizon_launcher::import::{self, Dropped};
+use std::path::PathBuf;
+
+#[derive(Default)]
+pub(super) struct Importing {
+    /// Shared instances being made.
+    busy: usize,
+    /// What the last drop did, or why not.
+    note: Option<Result<String, String>>,
+}
+
+impl Launcher {
+    pub(super) fn import_dropped(&mut self, files: Vec<PathBuf>, cx: &mut Context<Self>) {
+        for file in files {
+            let name = file
+                .file_name()
+                .map(|n| n.to_string_lossy().into_owned())
+                .unwrap_or_default();
+            match import::what(&file) {
+                Err(e) => self.importing.note = Some(Err(e)),
+                Ok(Dropped::Instance) => self.import_instance(file, cx),
+                Ok(Dropped::Modpack) => {
+                    self.show_modpack(None);
+                    self.pack_job(move |log| horizon_launcher::modpacks::import(&file, log));
+                    self.importing.note = Some(Ok(format!(
+                        "{name} is a Java modpack: importing it on the Modpacks page."
+                    )));
+                }
+                Ok(Dropped::Pack(_)) => {
+                    let Some(i) = self.selected_instance().cloned() else {
+                        continue;
+                    };
+                    self.importing.note =
+                        Some(horizon_launcher::packs::add(&i.home, &file).map(|p| {
+                            format!(
+                                "Added {} to {}'s packs: switch it on under Packs.",
+                                p.title, i.name
+                            )
+                        }));
+                    self.game_packs.stale();
+                }
+                Ok(Dropped::DataPack) => {
+                    self.importing.note = Some(Err(format!(
+                        "{name} is a data pack: drop it on a world on Home, or install it into \
+                         one from there."
+                    )))
+                }
+            }
+        }
+    }
+
+    fn import_instance(&mut self, file: PathBuf, cx: &mut Context<Self>) {
+        self.importing.busy += 1;
+        self.importing.note = None;
+        let task = cx
+            .background_executor()
+            .spawn(async move { import::import_instance(&file, &|_, _| {}) });
+        cx.spawn(async move |this, cx| {
+            let made = task.await;
+            let _ = this.update(cx, |this, cx| {
+                this.importing.busy -= 1;
+                this.importing.note = Some(made.map(|i| {
+                    this.reload_instances();
+                    this.select_instance(&i);
+                    this.go(Page::Play);
+                    format!("Made the instance {} from the shared file.", i.name)
+                }));
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    /// The root's drop target: every drop the sections don't take.
+    pub(super) fn import_drop_target(
+        &self,
+        root: Stateful<Div>,
+        cx: &mut Context<Self>,
+    ) -> Stateful<Div> {
+        root.on_drop(cx.listener(|this, paths: &ExternalPaths, _, cx| {
+            this.import_dropped(paths.paths().to_vec(), cx);
+            cx.notify();
+        }))
+    }
+
+    /// What the last drop did, in a corner over the page until closed.
+    pub(super) fn import_note(&self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let line = match (&self.importing.note, self.importing.busy) {
+            (_, n) if n > 0 => text(theme::LABEL)
+                .text_color(t.ink_soft)
+                .child("Making the instance from the shared file…"),
+            (Some(Ok(said)), _) => text(theme::LABEL)
+                .text_color(t.ink_soft)
+                .child(said.clone()),
+            (Some(Err(e)), _) => text(theme::LABEL).text_color(t.danger).child(e.clone()),
+            (None, _) => return None,
+        };
+        Some(
+            div()
+                .absolute()
+                .bottom(px(24.))
+                .right(px(24.))
+                .w(px(440.))
+                .child(
+                    plate(&t)
+                        .w_full()
+                        .flex()
+                        .items_center()
+                        .gap(px(12.))
+                        .px(px(16.))
+                        .py(px(12.))
+                        .border_1()
+                        .border_color(t.rule)
+                        .bg(t.page)
+                        .child(blocks::icon("download", 18., t.accent))
+                        .child(div().flex_1().min_w_0().child(line))
+                        .child(button("import-close", "Close", Kind::Ghost, &t).on_click(
+                            cx.listener(|this, _: &ClickEvent, _, cx| {
+                                this.importing.note = None;
+                                cx.notify();
+                            }),
+                        )),
+                ),
+        )
+    }
+}
diff --git a/launcher/src/instances_page.rs b/launcher/src/instances_page.rs
index 9b4273b98..273f967df 100644
--- a/launcher/src/instances_page.rs
+++ b/launcher/src/instances_page.rs
@@ -96,7 +96,7 @@ impl Launcher {
         }
     }
 
-    fn select_instance(&mut self, instance: &Instance) {
+    pub(super) fn select_instance(&mut self, instance: &Instance) {
         self.settings.instance =
             (instance.kind != InstanceKind::Default).then(|| instance.id.clone());
         self.settings.save();
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index d591249b1..ab0dfb58b 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -14,6 +14,7 @@ mod cull;
 mod datapacks_page;
 mod export_page;
 mod game_tools;
+mod import_page;
 mod instances_page;
 mod internet;
 mod markdown;
@@ -243,6 +244,7 @@ struct Launcher {
     game_packs: packs_page::Packs,
     world_packs: datapacks_page::WorldPacks,
     export: Option<export_page::ExportPanel>,
+    importing: import_page::Importing,
     /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar.
     offline_name: Option<String>,
     /// The player's servers, for the sidebar until the Servers page has read them.
@@ -408,6 +410,7 @@ impl Launcher {
             game_packs: packs_page::Packs::default(),
             world_packs: datapacks_page::WorldPacks::default(),
             export: None,
+            importing: Default::default(),
             offline_name: offline_name(),
             side_servers: horizon_launcher::servers::list(),
             art: art::Art::default(),
@@ -3649,6 +3652,8 @@ impl Render for Launcher {
                 root = root.child(dialog);
             }
         }
+        root = self.import_drop_target(root, cx);
+        root = root.children(self.import_note(cx));
         if let Some(dialog) = self.instance_dialog(cx) {
             root = root.child(dialog);
         }
diff --git a/launcher/src/modpacks_page.rs b/launcher/src/modpacks_page.rs
index 7f1b95ad9..97ce17952 100644
--- a/launcher/src/modpacks_page.rs
+++ b/launcher/src/modpacks_page.rs
@@ -25,7 +25,7 @@ impl Launcher {
     }
 
     /// Runs a pipeline step on a thread; its lines and its end arrive as messages.
-    fn pack_job(
+    pub(super) fn pack_job(
         &mut self,
         job: impl FnOnce(&dyn Fn(String)) -> Result<Imported, String> + Send + 'static,
     ) {
diff --git a/launcher/src/packs_page.rs b/launcher/src/packs_page.rs
index b497afa44..d33b257dd 100644
--- a/launcher/src/packs_page.rs
+++ b/launcher/src/packs_page.rs
@@ -135,6 +135,8 @@ impl Launcher {
             .drag_over::<ExternalPaths>(move |s, _, _, _| s.border_color(t.accent).bg(t.well))
             .on_drop(cx.listener(|this, paths: &ExternalPaths, _, cx| {
                 this.add_packs(paths.paths().to_vec());
+                // Not the window's import as well.
+                cx.stop_propagation();
                 cx.notify();
             }))
             .child(header);

From 0ccf3e110bb5591695966075b8a6652ce1df8374 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:44:53 +0100
Subject: [PATCH 422/475] launcher: live game console with search, follow, copy
 and share log

Home's Console shows the game's output of this run as it comes, with a
search, Follow, Copy and Open logs folder. Share log uploads it to mclo.gs
only after the player confirms, with the home folder, user name and
account names taken out first, and can delete the paste again. CLI:
share-log and unshare-log (MCP tools, the second needs confirm).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md      |  20 +++
 launcher/README.md             |   7 +
 launcher/src/cli.rs            |  45 +++++
 launcher/src/cli_tools.rs      |   2 +
 launcher/src/console_page.rs   | 320 +++++++++++++++++++++++++++++++++
 launcher/src/game_log.rs       | 161 +++++++++++++++++
 launcher/src/game_log/tests.rs | 114 ++++++++++++
 launcher/src/lib.rs            |   1 +
 launcher/src/main.rs           |   6 +
 launcher/src/servers_page.rs   |   7 +-
 10 files changed, 681 insertions(+), 2 deletions(-)
 create mode 100644 launcher/src/console_page.rs
 create mode 100644 launcher/src/game_log.rs
 create mode 100644 launcher/src/game_log/tests.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 63f168e38..a5c7b17fb 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -153,6 +153,26 @@ Show or set the extra arguments the game starts with (for example --server-threa
 
 MCP: `game_args`.
 
+## `horizon-launcher share-log`
+
+Upload an instance's latest.log to mclo.gs (a paste service for Minecraft logs) and print its link, for a bug report: only when the player asks. The home folder, the user name and the account names are taken out first; the link expires after 90 days unread.
+
+    horizon-launcher share-log
+
+- `--instance`: The instance (default: the selected one)
+
+MCP: `share_log`, only when the player asks.
+
+## `horizon-launcher unshare-log`
+
+Delete a log shared with share-log: the "<id>:<token>" it printed.
+
+    horizon-launcher unshare-log <SHARED>
+
+- `SHARED`
+
+MCP: `unshare_log`, needs `confirm: true`.
+
 ## `horizon-launcher logs`
 
 Print the end of the game's log (logs/latest.log in the game folder), or its newest crash report.
diff --git a/launcher/README.md b/launcher/README.md
index 7ffcc210a..6077e6a80 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -100,6 +100,13 @@ The opening, then Play ([clip](docs/opening.webm)):
   pack into the selected instance. A data pack is pointed at the world rows, and the Packs section
   and the world rows keep taking their own drops. A note in the corner says what happened.
   `horizon-launcher instance import <file>`.
+- **Console**: Home's Console shows the game's output of this run as it comes: a search (every
+  word, any case), Follow to keep the newest line in view, Copy, and Open logs folder. Warnings
+  and errors stand out. **Share log…** uploads the log to [mclo.gs](https://mclo.gs), a paste
+  service for Minecraft logs, only after the player confirms; the home folder, the user name and
+  the account names are taken out first (`horizon_launcher::game_log`), and **Delete it** removes
+  the paste. `horizon-launcher share-log [--instance]` and `unshare-log <id:token>`;
+  `HORIZON_LAUNCHER_PASTE_URL` points it at a test server.
 - **Worlds**: Home lists the selected instance's worlds (picture, mode, version, last played,
   size). **Back up** zips one into the instance's `backups/` as the game's Make Backup does
   (`<date>_<time>_<folder>.zip`); **Copy** puts "<name> (1)" beside it; **Delete** moves it to the
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 6139a082b..60e46e8e1 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -564,6 +564,16 @@ enum Cmd {
         #[arg(allow_hyphen_values = true)]
         args: Option<String>,
     },
+    /// Upload an instance's latest.log to mclo.gs (a paste service for Minecraft logs) and print
+    /// its link, for a bug report: only when the player asks. The home folder, the user name and
+    /// the account names are taken out first; the link expires after 90 days unread
+    ShareLog {
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Delete a log shared with share-log: the "<id>:<token>" it printed
+    UnshareLog { shared: String },
     /// Print the end of the game's log (logs/latest.log in the game folder), or its newest crash
     /// report
     Logs {
@@ -1056,6 +1066,41 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
                 println!("Game arguments: {line}");
             }
         }
+        Cmd::ShareLog { instance } => {
+            use horizon_launcher::game_log;
+            let i = match instance {
+                Some(name) => instances::find(&name)?,
+                None => instances::selected(),
+            };
+            let path = i.home.join("logs/latest.log");
+            let text =
+                std::fs::read_to_string(&path).map_err(|e| format!("{}: {e}", path.display()))?;
+            let names = game_log::names(&[&i.home, &backend::game_home()]);
+            let text = game_log::private(&text, dirs::home_dir().as_deref(), &names);
+            let shared = game_log::share(&text)?;
+            if as_json {
+                json(serde_json::json!({
+                    "url": shared.url, "delete": format!("{}:{}", shared.id, shared.token),
+                }));
+            } else {
+                println!("{}", shared.url);
+                println!(
+                    "Delete it: horizon-launcher unshare-log {}:{}",
+                    shared.id, shared.token
+                );
+            }
+        }
+        Cmd::UnshareLog { shared } => {
+            let (id, token) = shared
+                .split_once(':')
+                .ok_or("Give the \"<id>:<token>\" share-log printed.")?;
+            horizon_launcher::game_log::unshare(&horizon_launcher::game_log::Shared {
+                url: String::new(),
+                id: id.into(),
+                token: token.into(),
+            })?;
+            println!("Deleted the shared log {id}.");
+        }
         Cmd::Logs { lines, crash } => {
             let (path, text) = backend::read_logs(lines, crash)?;
             if as_json {
diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs
index ddbfefab8..fad614d0f 100644
--- a/launcher/src/cli_tools.rs
+++ b/launcher/src/cli_tools.rs
@@ -31,6 +31,7 @@ pub const DESTRUCTIVE: &[&str] = &[
     "screenshots delete",
     "packs remove",
     "worlds datapack-remove",
+    "unshare-log",
 ];
 
 /// Commands that send something or reach other people: only when the player asks.
@@ -40,6 +41,7 @@ pub const OPEN_WORLD: &[&str] = &[
     "data bug",
     "data benchmark",
     "servers create",
+    "share-log",
 ];
 
 /// A generated tool: its name, the CLI words it runs and the clap command behind them.
diff --git a/launcher/src/console_page.rs b/launcher/src/console_page.rs
new file mode 100644
index 000000000..5e26a624e
--- /dev/null
+++ b/launcher/src/console_page.rs
@@ -0,0 +1,320 @@
+//! Home's Console: the game's output of this run as it comes, with a search, Follow (keep the
+//! newest line in view), Copy, and Share log (`horizon_launcher::game_log`): an upload to mclo.gs
+//! that happens only after the player confirms, without their home folder or names.
+use super::servers_page::Field;
+use super::*;
+use gpui::{ClipboardItem, ScrollHandle};
+use horizon_launcher::game_log::{self, Shared};
+
+pub(super) struct Console {
+    open: bool,
+    follow: bool,
+    scroll: ScrollHandle,
+    /// Lines and search at the last draw: a change means scroll down when following.
+    seen: (usize, String),
+    confirm_share: bool,
+    sharing: bool,
+    shared: Option<Result<Shared, String>>,
+}
+
+impl Default for Console {
+    fn default() -> Self {
+        Console {
+            open: std::env::var("HORIZON_LAUNCHER_CONSOLE").is_ok(),
+            follow: true,
+            scroll: ScrollHandle::new(),
+            seen: (0, String::new()),
+            confirm_share: false,
+            sharing: false,
+            shared: None,
+        }
+    }
+}
+
+impl Launcher {
+    /// What Share log sends: this run's lines, else the selected instance's latest.log.
+    fn log_to_share(&self) -> Result<(String, Vec<std::path::PathBuf>), String> {
+        let home = self
+            .client_home
+            .clone()
+            .or_else(|| self.selected_instance().map(|i| i.home.clone()))
+            .unwrap_or_else(backend::game_home);
+        let text = match self.prepare_log.is_empty() {
+            false => {
+                self.prepare_log
+                    .iter()
+                    .cloned()
+                    .collect::<Vec<_>>()
+                    .join("\n")
+                    + "\n"
+            }
+            true => {
+                let path = home.join("logs/latest.log");
+                std::fs::read_to_string(&path).map_err(|_| "There is no log to share yet.")?
+            }
+        };
+        Ok((text, vec![home, backend::game_home()]))
+    }
+
+    fn share_log(&mut self, cx: &mut Context<Self>) {
+        let shared = match self.log_to_share() {
+            Ok(log) => log,
+            Err(e) => {
+                self.console.shared = Some(Err(e));
+                return;
+            }
+        };
+        self.console.confirm_share = false;
+        self.console.sharing = true;
+        let task = cx.background_executor().spawn(async move {
+            let (text, homes) = shared;
+            let homes: Vec<&std::path::Path> = homes.iter().map(|h| h.as_path()).collect();
+            let names = game_log::names(&homes);
+            game_log::share(&game_log::private(
+                &text,
+                dirs::home_dir().as_deref(),
+                &names,
+            ))
+        });
+        cx.spawn(async move |this, cx| {
+            let done = task.await;
+            let _ = this.update(cx, |this, cx| {
+                this.console.sharing = false;
+                this.console.shared = Some(done);
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    fn unshare_log(&mut self, cx: &mut Context<Self>) {
+        let Some(Ok(shared)) = self.console.shared.clone() else {
+            return;
+        };
+        self.console.sharing = true;
+        let task = cx
+            .background_executor()
+            .spawn(async move { game_log::unshare(&shared) });
+        cx.spawn(async move |this, cx| {
+            let done = task.await;
+            let _ = this.update(cx, |this, cx| {
+                this.console.sharing = false;
+                this.console.shared = match done {
+                    Ok(()) => None,
+                    Err(e) => Some(Err(e)),
+                };
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    /// Home's Console section, once the game has said something (or is running).
+    pub(super) fn console_section(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        if self.prepare_log.is_empty() && self.client.is_none() {
+            return None;
+        }
+        let open = self.console.open;
+        let toggle = button(
+            "console-toggle",
+            if open { "Hide" } else { "Show" },
+            Kind::Ghost,
+            &t,
+        )
+        .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+            this.console.open = !this.console.open;
+            cx.notify();
+        }));
+        let count = self.prepare_log.len();
+        let header = div()
+            .flex()
+            .items_center()
+            .justify_between()
+            .child(section_title("Console", "terminal", &t))
+            .child(
+                div()
+                    .flex()
+                    .items_center()
+                    .gap(px(10.))
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .child(match self.client {
+                                Some(_) => format!("{count} lines, the game is running"),
+                                None => format!("{count} lines from the last run"),
+                            }),
+                    )
+                    .child(toggle),
+            );
+        let mut section = div().flex().flex_col().gap(px(10.)).child(header);
+        if !open {
+            return Some(section);
+        }
+        let search = self.servers.value(Field::ConsoleSearch).trim().to_string();
+        let lines: Vec<String> = self
+            .prepare_log
+            .iter()
+            .filter(|l| game_log::matches(l, &search))
+            .cloned()
+            .collect();
+        let now = (count, search);
+        if self.console.follow && now != self.console.seen {
+            self.console.scroll.scroll_to_bottom();
+        }
+        self.console.seen = now;
+        let follow = div()
+            .id("console-follow")
+            .flex()
+            .items_center()
+            .gap(px(8.))
+            .cursor_pointer()
+            .child(switch("console-follow-switch", self.console.follow, &t))
+            .child(text(theme::LABEL).text_color(t.ink_soft).child("Follow"))
+            .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                this.console.follow = !this.console.follow;
+                this.console.seen.0 = usize::MAX;
+                cx.notify();
+            }));
+        let copied = lines.join("\n");
+        let tools = div()
+            .flex()
+            .flex_wrap()
+            .items_center()
+            .gap(px(10.))
+            .child(self.field(Field::ConsoleSearch, "Search the log", 260., cx))
+            .child(follow)
+            .child(div().flex_1())
+            .child(
+                button("console-copy", "Copy", Kind::Ghost, &t).on_click(cx.listener(
+                    move |this, _: &ClickEvent, _, cx| {
+                        copy_to_clipboard(cx, ClipboardItem::new_string(copied.clone()));
+                        this.console.shared = None;
+                        cx.notify();
+                    },
+                )),
+            )
+            .child({
+                let b = button("console-share", "Share log…", Kind::Ghost, &t);
+                match self.console.sharing {
+                    true => disabled(b),
+                    false => b.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                        this.console.confirm_share = true;
+                        cx.notify();
+                    })),
+                }
+            })
+            .child({
+                let logs = self
+                    .client_home
+                    .clone()
+                    .or_else(|| self.selected_instance().map(|i| i.home.clone()))
+                    .unwrap_or_else(backend::game_home)
+                    .join("logs");
+                button("console-folder", "Open logs folder", Kind::Ghost, &t).on_click(
+                    move |_, _, cx| {
+                        let _ = std::fs::create_dir_all(&logs);
+                        cx.open_with_system(&logs);
+                    },
+                )
+            });
+        section = section.child(tools);
+        if self.console.confirm_share {
+            section = section.child(
+                plate(&t)
+                    .flex()
+                    .items_center()
+                    .gap(px(12.))
+                    .px(px(14.))
+                    .py(px(10.))
+                    .child(div().flex_1().min_w_0().child(
+                        text(theme::CAPTION).text_color(t.ink_soft).child(
+                            "Upload this log to mclo.gs, a paste service for Minecraft logs? \
+                             Anyone with the link can read it, until it is deleted or unread \
+                             for 90 days. Your home folder, user name and account names are \
+                             taken out first.",
+                        ),
+                    ))
+                    .child(
+                        button("console-share-no", "Cancel", Kind::Ghost, &t).on_click(
+                            cx.listener(|this, _: &ClickEvent, _, cx| {
+                                this.console.confirm_share = false;
+                                cx.notify();
+                            }),
+                        ),
+                    )
+                    .child(
+                        button("console-share-yes", "Upload", Kind::Secondary, &t).on_click(
+                            cx.listener(|this, _: &ClickEvent, _, cx| {
+                                this.share_log(cx);
+                                cx.notify();
+                            }),
+                        ),
+                    ),
+            );
+        }
+        match &self.console.shared {
+            _ if self.console.sharing => {
+                section = section.child(text(theme::CAPTION).text_color(t.muted).child("Sending…"))
+            }
+            Some(Ok(shared)) => {
+                let (url, open_url) = (shared.url.clone(), shared.url.clone());
+                section = section.child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .gap(px(10.))
+                        .child(
+                            text(theme::CAPTION)
+                                .text_color(t.ink_soft)
+                                .child(format!("Shared: {url}")),
+                        )
+                        .child(
+                            button("console-link-copy", "Copy link", Kind::Ghost, &t).on_click(
+                                move |_, _, cx| {
+                                    copy_to_clipboard(cx, ClipboardItem::new_string(url.clone()))
+                                },
+                            ),
+                        )
+                        .child(
+                            button("console-link-open", "Open", Kind::Ghost, &t)
+                                .on_click(move |_, _, cx| cx.open_url(&open_url)),
+                        )
+                        .child(
+                            button("console-unshare", "Delete it", Kind::Ghost, &t).on_click(
+                                cx.listener(|this, _: &ClickEvent, _, cx| {
+                                    this.unshare_log(cx);
+                                    cx.notify();
+                                }),
+                            ),
+                        ),
+                );
+            }
+            Some(Err(e)) => section = section.child(notice(e.clone(), &t)),
+            None => {}
+        }
+        let shown = lines.len().saturating_sub(LOG_LINES);
+        let body = div()
+            .id("console-lines")
+            .track_scroll(&self.console.scroll)
+            .h(px(320.))
+            .overflow_y_scroll()
+            .p(px(10.))
+            .border_2()
+            .border_color(t.outline)
+            .bg(t.well)
+            .font_family(theme::MONO)
+            .text_size(px(12.))
+            .children(lines.into_iter().skip(shown).map(|line| {
+                let color = if line.contains("/ERROR]") || line.contains("ERROR:") {
+                    t.danger
+                } else if line.contains("/WARN]") {
+                    t.warn
+                } else {
+                    t.ink_soft
+                };
+                div().text_color(color).child(line)
+            }));
+        Some(section.child(body))
+    }
+}
diff --git a/launcher/src/game_log.rs b/launcher/src/game_log.rs
new file mode 100644
index 000000000..a9c787544
--- /dev/null
+++ b/launcher/src/game_log.rs
@@ -0,0 +1,161 @@
+//! The game's log as the console shows it, and sharing it.
+//!
+//! Sharing uploads the log to mclo.gs, and only when the player asks (a click, or `logs share`).
+//! mclo.gs is a paste service made for Minecraft logs by Aternos: no account, links expire after
+//! 90 days unread, and the uploader gets a token that deletes the paste. Before anything leaves
+//! the computer, [`private`] takes out the player's home folder, their user name and their
+//! account names.
+use std::path::Path;
+
+/// mclo.gs's API; `HORIZON_LAUNCHER_PASTE_URL` points it elsewhere for tests.
+const API: &str = "https://api.mclo.gs/1";
+const PASTE_ENV: &str = "HORIZON_LAUNCHER_PASTE_URL";
+/// mclo.gs keeps at most 25,000 lines and 10 MiB: the end of a longer log is sent.
+const MAX_LINES: usize = 25_000;
+const MAX_BYTES: usize = 10 << 20;
+
+fn api() -> String {
+    std::env::var(PASTE_ENV)
+        .ok()
+        .filter(|u| !u.is_empty())
+        .unwrap_or_else(|| API.into())
+}
+
+/// Whether a console line matches the search: every word, in any case.
+pub fn matches(line: &str, search: &str) -> bool {
+    let line = line.to_lowercase();
+    search
+        .split_whitespace()
+        .all(|w| line.contains(&w.to_lowercase()))
+}
+
+/// The names to take out of a log: the account names, the offline player name kept in each
+/// game folder (`horizon-player.txt`), and the computer's user name.
+pub fn names(homes: &[&Path]) -> Vec<String> {
+    let mut names: Vec<String> = crate::account::Accounts::load()
+        .accounts
+        .into_iter()
+        .map(|a| a.name)
+        .collect();
+    for home in homes {
+        if let Ok(name) = std::fs::read_to_string(home.join("horizon-player.txt")) {
+            names.push(name.trim().to_string());
+        }
+    }
+    for var in ["USER", "USERNAME"] {
+        if let Ok(user) = std::env::var(var) {
+            names.push(user);
+        }
+    }
+    if let Some(user) =
+        dirs::home_dir().and_then(|h| h.file_name().map(|n| n.to_string_lossy().into_owned()))
+    {
+        names.push(user);
+    }
+    names.retain(|n| n.chars().count() >= 3);
+    names.sort_by_key(|n| std::cmp::Reverse(n.len()));
+    names.dedup();
+    names
+}
+
+/// The log without the home folder (`~` instead, with either slash) and without `names` (each
+/// becomes `<player>`), as whole words in any case.
+pub fn private(text: &str, home: Option<&Path>, names: &[String]) -> String {
+    let mut out = text.to_string();
+    if let Some(home) = home
+        .map(|h| h.to_string_lossy().into_owned())
+        .filter(|h| h.len() > 1)
+    {
+        out = out.replace(&home, "~");
+        out = out.replace(&home.replace('\\', "/"), "~");
+        out = out.replace(&home.replace('/', "\\"), "~");
+    }
+    for name in names {
+        out = replace_word(&out, name, "<player>");
+    }
+    out
+}
+
+/// Replaces `word` (any case) where it isn't part of a longer name.
+fn replace_word(text: &str, word: &str, with: &str) -> String {
+    let lower = text.to_lowercase();
+    let find = word.to_lowercase();
+    if find.is_empty() || lower.len() != text.len() {
+        // A case change that moves bytes (rare scripts): exact matches only.
+        return text.replace(word, with);
+    }
+    let part = |c: Option<char>| c.is_some_and(|c| c.is_alphanumeric() || c == '_');
+    let mut out = String::with_capacity(text.len());
+    let mut at = 0;
+    while let Some(i) = lower[at..].find(&find).map(|i| i + at) {
+        let end = i + find.len();
+        if part(text[..i].chars().next_back()) || part(text[end..].chars().next()) {
+            out.push_str(&text[at..end]);
+        } else {
+            out.push_str(&text[at..i]);
+            out.push_str(with);
+        }
+        at = end;
+    }
+    out.push_str(&text[at..]);
+    out
+}
+
+/// The end of the log that fits what mclo.gs keeps.
+pub fn fit(text: &str) -> &str {
+    let mut start = 0;
+    let lines: Vec<usize> = text.match_indices('\n').map(|(i, _)| i + 1).collect();
+    if lines.len() > MAX_LINES {
+        start = lines[lines.len() - MAX_LINES - 1];
+    }
+    while text.len() - start > MAX_BYTES {
+        start = text[start..]
+            .find('\n')
+            .map_or(text.len(), |i| start + i + 1);
+    }
+    &text[start..]
+}
+
+/// A shared log: its page, and what deletes it.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Shared {
+    pub url: String,
+    pub id: String,
+    pub token: String,
+}
+
+/// Uploads `text` (already [`private`]) and returns its link.
+pub fn share(text: &str) -> Result<Shared, String> {
+    let body = serde_json::json!({ "content": fit(text), "source": "Horizon launcher" });
+    let answer: serde_json::Value = ureq::post(&format!("{}/log", api()))
+        .send_json(body)
+        .map_err(|e| format!("mclo.gs didn't take the log: {e}"))?
+        .into_json()
+        .map_err(|e| format!("mclo.gs answered something unexpected: {e}"))?;
+    let field = |k: &str| answer[k].as_str().map(str::to_string);
+    match (
+        answer["success"].as_bool(),
+        field("url"),
+        field("id"),
+        field("token"),
+    ) {
+        (Some(true), Some(url), Some(id), Some(token)) => Ok(Shared { url, id, token }),
+        _ => Err(format!(
+            "mclo.gs didn't take the log: {}",
+            field("error").unwrap_or_else(|| "no reason given".into())
+        )),
+    }
+}
+
+/// Deletes a log shared from here.
+pub fn unshare(shared: &Shared) -> Result<(), String> {
+    ureq::delete(&format!("{}/log/{}", api(), shared.id))
+        .set("Authorization", &format!("Bearer {}", shared.token))
+        .call()
+        .map_err(|e| format!("mclo.gs didn't delete it: {e}"))?;
+    Ok(())
+}
+
+#[cfg(test)]
+#[path = "game_log/tests.rs"]
+mod tests;
diff --git a/launcher/src/game_log/tests.rs b/launcher/src/game_log/tests.rs
new file mode 100644
index 000000000..b353df173
--- /dev/null
+++ b/launcher/src/game_log/tests.rs
@@ -0,0 +1,114 @@
+use super::*;
+use std::io::{BufRead, BufReader, Read, Write};
+
+#[test]
+fn search_matches_every_word_in_any_case() {
+    assert!(matches(
+        "[12:00:01] [Render thread/WARN]: Missing texture",
+        "warn texture"
+    ));
+    assert!(!matches("[12:00:01] [Render thread/INFO]: Loaded", "warn"));
+    assert!(matches("anything", "  "));
+}
+
+#[test]
+fn the_shared_log_has_no_home_folder_or_names() {
+    let log = "Loading /Users/ludovicmarie/Library/Application Support/horizon/options.txt\n\
+               C:\\Users\\ludovicmarie\\AppData\\horizon too\n\
+               Ludo47 joined the game\n\
+               <ludo47> hi, Ludo470 is someone else\n\
+               user LUDOVICMARIE on ludovicmarie-mac\n";
+    let names = vec!["ludovicmarie".to_string(), "Ludo47".to_string()];
+    let out = private(log, Some(Path::new("/Users/ludovicmarie")), &names);
+    assert_eq!(
+        out,
+        "Loading ~/Library/Application Support/horizon/options.txt\n\
+         C:~\\AppData\\horizon too\n\
+         <player> joined the game\n\
+         <<player>> hi, Ludo470 is someone else\n\
+         user <player> on <player>-mac\n"
+    );
+}
+
+#[test]
+fn a_long_log_sends_its_end() {
+    let log: String = (0..30_000).map(|i| format!("line {i}\n")).collect();
+    let sent = fit(&log);
+    assert_eq!(sent.lines().count(), MAX_LINES);
+    assert!(sent.starts_with("line 5000\n") && sent.ends_with("line 29999\n"));
+    assert_eq!(fit("short\n"), "short\n");
+}
+
+/// A one-request HTTP server that answers `body` and hands back what it was sent.
+fn stub(body: &'static str) -> (String, std::thread::JoinHandle<String>) {
+    let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+    let url = format!("http://{}", listener.local_addr().unwrap());
+    let served = std::thread::spawn(move || {
+        let (stream, _) = listener.accept().unwrap();
+        let mut reader = BufReader::new(stream);
+        let mut head = String::new();
+        let mut length = 0;
+        loop {
+            let mut line = String::new();
+            reader.read_line(&mut line).unwrap();
+            if let Some(n) = line.to_ascii_lowercase().strip_prefix("content-length:") {
+                length = n.trim().parse().unwrap();
+            }
+            head.push_str(&line);
+            if line == "\r\n" {
+                break;
+            }
+        }
+        let mut sent = vec![0; length];
+        reader.read_exact(&mut sent).unwrap();
+        let reply = format!(
+            "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{body}",
+            body.len()
+        );
+        reader.get_mut().write_all(reply.as_bytes()).unwrap();
+        head + &String::from_utf8(sent).unwrap()
+    });
+    (url, served)
+}
+
+#[test]
+fn shares_and_deletes_through_the_paste_api() {
+    let (url, served) =
+        stub(r#"{"success":true,"id":"Ab12","url":"https://mclo.gs/Ab12","token":"t0k"}"#);
+    std::env::set_var(PASTE_ENV, &url);
+    let shared = share("[main/INFO]: hello\n").unwrap();
+    assert_eq!(
+        shared,
+        Shared {
+            url: "https://mclo.gs/Ab12".into(),
+            id: "Ab12".into(),
+            token: "t0k".into()
+        }
+    );
+    let request = served.join().unwrap();
+    assert!(request.starts_with("POST /log "), "{request}");
+    assert!(
+        request.ends_with(r#"{"content":"[main/INFO]: hello\n","source":"Horizon launcher"}"#),
+        "{request}"
+    );
+
+    let (url, served) = stub(r#"{"success":true}"#);
+    std::env::set_var(PASTE_ENV, &url);
+    unshare(&shared).unwrap();
+    let request = served.join().unwrap();
+    assert!(request.starts_with("DELETE /log/Ab12 "), "{request}");
+    assert!(
+        request
+            .to_ascii_lowercase()
+            .contains("authorization: bearer t0k"),
+        "{request}"
+    );
+
+    let (url, _served) = stub(r#"{"success":false,"error":"Required field 'content' not found."}"#);
+    std::env::set_var(PASTE_ENV, &url);
+    assert_eq!(
+        share("").unwrap_err(),
+        "mclo.gs didn't take the log: Required field 'content' not found."
+    );
+    std::env::remove_var(PASTE_ENV);
+}
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index 85238283d..28c6d21bd 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -9,6 +9,7 @@ pub mod desktop_seams;
 pub mod export;
 #[cfg(unix)]
 pub mod game_app;
+pub mod game_log;
 pub mod heads;
 pub mod import;
 pub mod instances;
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index ab0dfb58b..cb68372b6 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -10,6 +10,7 @@ mod cli;
 mod cli_tools;
 mod collection;
 mod console;
+mod console_page;
 mod cull;
 mod datapacks_page;
 mod export_page;
@@ -245,6 +246,7 @@ struct Launcher {
     world_packs: datapacks_page::WorldPacks,
     export: Option<export_page::ExportPanel>,
     importing: import_page::Importing,
+    console: console_page::Console,
     /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar.
     offline_name: Option<String>,
     /// The player's servers, for the sidebar until the Servers page has read them.
@@ -411,6 +413,7 @@ impl Launcher {
             world_packs: datapacks_page::WorldPacks::default(),
             export: None,
             importing: Default::default(),
+            console: Default::default(),
             offline_name: offline_name(),
             side_servers: horizon_launcher::servers::list(),
             art: art::Art::default(),
@@ -2229,6 +2232,9 @@ impl Launcher {
             page = page.child(notice(e, &t));
         }
         page = page.child(rows);
+        if let Some(console) = self.console_section(cx) {
+            page = page.child(console);
+        }
         if let Some(worlds) = self.worlds_section(cx) {
             page = page.child(worlds);
         }
diff --git a/launcher/src/servers_page.rs b/launcher/src/servers_page.rs
index 4c52893bc..b9a82b938 100644
--- a/launcher/src/servers_page.rs
+++ b/launcher/src/servers_page.rs
@@ -38,10 +38,12 @@ pub(super) enum Field {
     /// Home's Multiplayer section's (`multiplayer_page.rs`).
     ServerName,
     ServerAddress,
+    /// Home's Console's search (`console_page.rs`).
+    ConsoleSearch,
 }
 
 impl Field {
-    const ALL: [Field; 13] = [
+    const ALL: [Field; 14] = [
         Field::Name,
         Field::Seed,
         Field::Players,
@@ -55,6 +57,7 @@ impl Field {
         Field::InstanceGroup,
         Field::ServerName,
         Field::ServerAddress,
+        Field::ConsoleSearch,
     ];
 }
 
@@ -1031,7 +1034,7 @@ impl Launcher {
             Field::Port => self.save_port(),
             Field::Token => self.save_token(),
             Field::Email => self.invite_friend(),
-            Field::InstanceName | Field::InstanceGroup => {}
+            Field::InstanceName | Field::InstanceGroup | Field::ConsoleSearch => {}
             Field::ServerName | Field::ServerAddress => self.add_server(),
         }
     }

From cde33a8e42dfb58826ec35d8c2db35fb929a1a15 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:51:54 +0100
Subject: [PATCH 423/475] launcher: minimise or hide the window while the game
 runs

Settings > While playing: Stay (the default), Minimise, or Hide (macOS).
The window goes away when the game starts and comes back to the front
when it closes, with the run's play time, errors and log. CLI and MCP:
settings while-playing stay|minimize|hide.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md     |  4 +-
 launcher/README.md            |  6 ++-
 launcher/src/backend.rs       | 78 +++++++++++++++++++++++++++++
 launcher/src/cli.rs           | 11 ++++-
 launcher/src/main.rs          |  7 +++
 launcher/src/while_playing.rs | 92 +++++++++++++++++++++++++++++++++++
 6 files changed, 192 insertions(+), 6 deletions(-)
 create mode 100644 launcher/src/while_playing.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index a5c7b17fb..432b76e72 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -134,11 +134,11 @@ MCP: `account_offline`.
 
 ## `horizon-launcher settings`
 
-Show the launcher's settings, or set one (the Settings page): selected-version TAG, minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions on|off, opening-animation on|off, proxy http://host:port ("default" removes it).
+Show the launcher's settings, or set one (the Settings page): selected-version TAG, minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions on|off, opening-animation on|off, proxy http://host:port ("default" removes it), while-playing stay|minimize|hide (what the window does while the game runs).
 
     horizon-launcher settings [KEY] [VALUE]
 
-- `KEY` (selected-version, minecraft-dir, server-dir, install-new-versions, opening-animation, proxy)
+- `KEY` (selected-version, minecraft-dir, server-dir, install-new-versions, opening-animation, proxy, while-playing)
 - `VALUE`: The new value (with KEY)
 
 MCP: `settings`.
diff --git a/launcher/README.md b/launcher/README.md
index 6077e6a80..ad96eece1 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -147,8 +147,10 @@ page `servers.json` (the list), `servers/<name>/` (the servers created there) an
 
 - **Settings**: install new Horizon versions automatically (on unless you turn it off; the
   selected version only moves to the new one if you were on the newest), the opening animation,
-  the game's extra command-line arguments, an HTTP proxy for downloads, and the launcher's own
-  version and update state.
+  what the window does while you play (stays by default; Minimise, or Hide on macOS, puts it away
+  when the game starts and brings it back to the front when the game closes; `settings
+  while-playing stay|minimize|hide`), the game's extra command-line arguments, an HTTP proxy for
+  downloads, and the launcher's own version and update state.
 - **Updates**: there is one channel. Every release is published as the release, GitHub's latest,
   once its smoke test passed (docs/release-flow.md), and the launcher installs it. The game
   pre-releases of the old Alpha channel (v0.2.1 on) stay on the Versions page to install
diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs
index dbd54aeee..3d900bd87 100644
--- a/launcher/src/backend.rs
+++ b/launcher/src/backend.rs
@@ -2515,6 +2515,51 @@ pub enum Appearance {
     System,
 }
 
+/// What the launcher's window does while the game runs, as the player picks it in Settings.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum WhilePlaying {
+    /// The window stays where it is.
+    #[default]
+    Stay,
+    /// The window goes to the Dock or the taskbar, and comes back when the game closes.
+    Minimize,
+    /// The launcher hides (macOS only: elsewhere it minimises), and comes back when the game
+    /// closes.
+    Hide,
+}
+
+impl WhilePlaying {
+    pub const ALL: [WhilePlaying; 3] = [Self::Stay, Self::Minimize, Self::Hide];
+
+    /// Its name in `settings.json` and on the command line.
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Stay => "stay",
+            Self::Minimize => "minimize",
+            Self::Hide => "hide",
+        }
+    }
+
+    pub fn parse(name: &str) -> Option<Self> {
+        let name = name.trim().to_ascii_lowercase();
+        let name = match name.as_str() {
+            "minimise" => "minimize",
+            "keep" | "open" | "off" => "stay",
+            n => n,
+        };
+        Self::ALL.into_iter().find(|w| w.name() == name)
+    }
+
+    /// What this computer does for it: only macOS can hide a whole app.
+    pub fn here(self) -> Self {
+        match self {
+            Self::Hide if !cfg!(target_os = "macos") => Self::Minimize,
+            w => w,
+        }
+    }
+}
+
 #[derive(Default, serde::Serialize, serde::Deserialize)]
 pub struct Settings {
     pub selected: Option<String>,
@@ -2556,6 +2601,9 @@ pub struct Settings {
     /// The player hid the sidebar's partner banner. The Servers page keeps its own.
     #[serde(default)]
     pub partner_hidden: bool,
+    /// What the window does while the game runs. Stays by default.
+    #[serde(default)]
+    pub while_playing: WhilePlaying,
 }
 
 impl Settings {
@@ -2574,6 +2622,12 @@ impl Settings {
             {
                 fields.remove("appearance");
             }
+            if fields
+                .get("while_playing")
+                .is_some_and(|w| serde_json::from_value::<WhilePlaying>(w.clone()).is_err())
+            {
+                fields.remove("while_playing");
+            }
         }
         serde_json::from_value(value).unwrap_or_default()
     }
@@ -2887,6 +2941,30 @@ mod tests {
         assert_eq!(CHECK_EVERY.as_secs(), 30 * 60);
     }
 
+    #[test]
+    fn the_window_stays_while_playing_unless_picked() {
+        assert_eq!(Settings::parse("{}").while_playing, WhilePlaying::Stay);
+        let hide = Settings::parse(r#"{"while_playing": "hide", "game_args": "--x"}"#);
+        assert_eq!(hide.while_playing, WhilePlaying::Hide);
+        let future = Settings::parse(r#"{"while_playing": "fade", "game_args": "--x"}"#);
+        assert_eq!(
+            (future.while_playing, future.game_args.as_str()),
+            (WhilePlaying::Stay, "--x")
+        );
+        assert_eq!(
+            WhilePlaying::parse("Minimise"),
+            Some(WhilePlaying::Minimize)
+        );
+        assert_eq!(WhilePlaying::parse("off"), Some(WhilePlaying::Stay));
+        assert_eq!(WhilePlaying::parse("close"), None);
+        for w in WhilePlaying::ALL {
+            let text = serde_json::to_string(&w).unwrap();
+            assert_eq!(text, format!("\"{}\"", w.name()));
+        }
+        let here = WhilePlaying::Hide.here();
+        assert_eq!(here == WhilePlaying::Hide, cfg!(target_os = "macos"));
+    }
+
     #[test]
     fn the_appearance_is_dark_unless_picked_and_an_unknown_one_keeps_the_rest() {
         assert_eq!(Settings::parse("{}").appearance, Appearance::Dark);
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 60e46e8e1..246538b08 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -549,7 +549,8 @@ enum Cmd {
     },
     /// Show the launcher's settings, or set one (the Settings page): selected-version TAG,
     /// minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions
-    /// on|off, opening-animation on|off, proxy http://host:port ("default" removes it)
+    /// on|off, opening-animation on|off, proxy http://host:port ("default" removes it),
+    /// while-playing stay|minimize|hide (what the window does while the game runs)
     Settings {
         #[arg(value_parser = SETTING_KEYS)]
         key: Option<String>,
@@ -686,13 +687,14 @@ pub fn command() -> clap::Command {
 pub const AI_COMMANDS: [&str; 2] = ["mcp", "agent-config"];
 
 /// The keys `settings` sets.
-const SETTING_KEYS: [&str; 6] = [
+const SETTING_KEYS: [&str; 7] = [
     "selected-version",
     "minecraft-dir",
     "server-dir",
     "install-new-versions",
     "opening-animation",
     "proxy",
+    "while-playing",
 ];
 
 fn on_off(value: &str) -> Result<bool, String> {
@@ -711,6 +713,10 @@ fn set_setting(s: &mut backend::Settings, key: &str, value: &str) -> Result<(),
         "server-dir" => s.server_dir = folder(value),
         "install-new-versions" => s.install_new_versions = Some(on_off(value)?),
         "opening-animation" => s.skip_opening = !on_off(value)?,
+        "while-playing" => {
+            s.while_playing = backend::WhilePlaying::parse(value)
+                .ok_or_else(|| format!("{value}: say stay, minimize or hide"))?
+        }
         "proxy" => {
             if value == "default" || value.is_empty() {
                 s.proxy = None;
@@ -736,6 +742,7 @@ fn settings_json(s: &backend::Settings) -> serde_json::Value {
         "game_args": s.game_args,
         "proxy": s.proxy,
         "desktop_entry": s.desktop_entry.unwrap_or(true),
+        "while_playing": s.while_playing.name(),
         "no_ai": backend::no_ai(),
     })
 }
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index cb68372b6..352ae7e98 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -32,6 +32,7 @@ mod scrollbar;
 mod servers_page;
 mod theme;
 mod titlebar;
+mod while_playing;
 mod worlds_page;
 
 use gpui::{
@@ -247,6 +248,8 @@ struct Launcher {
     export: Option<export_page::ExportPanel>,
     importing: import_page::Importing,
     console: console_page::Console,
+    /// What the window did when the game started (`while_playing.rs`).
+    aside: while_playing::Aside,
     /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar.
     offline_name: Option<String>,
     /// The player's servers, for the sidebar until the Servers page has read them.
@@ -414,6 +417,7 @@ impl Launcher {
             export: None,
             importing: Default::default(),
             console: Default::default(),
+            aside: while_playing::Aside::new(window.window_handle()),
             offline_name: offline_name(),
             side_servers: horizon_launcher::servers::list(),
             art: art::Art::default(),
@@ -606,6 +610,7 @@ impl Launcher {
                             Ok(r) => {
                                 self.client = Some(r);
                                 self.client_run = run.map(|id| (id, Instant::now()));
+                                self.step_aside(cx);
                             }
                             Err(e) => self.client_error = Some(e),
                         }
@@ -723,6 +728,7 @@ impl Launcher {
                         }
                         Job::Client => {
                             self.client = None;
+                            self.come_back(cx);
                             // The game saved: last played, sizes and pictures changed.
                             self.worlds.stale();
                             self.multiplayer.stale();
@@ -2662,6 +2668,7 @@ impl Launcher {
                         Some(appearance.into_any_element()),
                         &t,
                     ))
+                    .child(self.while_playing_row(n + 3, cx))
                     .child(index_row(
                         n + 3,
                         "Show the opening",
diff --git a/launcher/src/while_playing.rs b/launcher/src/while_playing.rs
new file mode 100644
index 000000000..d39309f7c
--- /dev/null
+++ b/launcher/src/while_playing.rs
@@ -0,0 +1,92 @@
+//! What the window does while the game runs (`backend::WhilePlaying`): stay, minimise, or hide
+//! (macOS), and come back to the front when the game closes, with how the run ended.
+use super::*;
+use backend::WhilePlaying;
+use gpui::AnyWindowHandle;
+
+pub(super) struct Aside {
+    /// The launcher's window.
+    window: AnyWindowHandle,
+    /// What the window did when the game started, to undo when it closes.
+    stepped: Option<WhilePlaying>,
+}
+
+impl Aside {
+    pub(super) fn new(window: AnyWindowHandle) -> Self {
+        Aside {
+            window,
+            stepped: None,
+        }
+    }
+}
+
+impl Launcher {
+    /// The game started: get out of its way as the player asked. Read from `settings.json`, so
+    /// `horizon-launcher settings while-playing …` counts at once.
+    pub(super) fn step_aside(&mut self, cx: &mut Context<Self>) {
+        self.settings.while_playing = Settings::load().while_playing;
+        let how = self.settings.while_playing.here();
+        if how == WhilePlaying::Stay {
+            return;
+        }
+        let window = self.aside.window;
+        self.aside.stepped = Some(how);
+        cx.defer(move |cx| match how {
+            WhilePlaying::Hide => cx.hide(),
+            _ => {
+                let _ = window.update(cx, |_, window, _| window.minimize_window());
+            }
+        });
+    }
+
+    /// The game closed: back to the front, where its play time, errors and log are.
+    pub(super) fn come_back(&mut self, cx: &mut Context<Self>) {
+        if self.aside.stepped.take().is_none() {
+            return;
+        }
+        let window = self.aside.window;
+        cx.defer(move |cx| {
+            cx.activate(true);
+            let _ = window.update(cx, |_, window, _| window.activate_window());
+        });
+    }
+
+    /// Settings' row for it.
+    pub(super) fn while_playing_row(&self, n: usize, cx: &mut Context<Self>) -> Div {
+        let t = self.theme;
+        let mut options = vec![
+            (WhilePlaying::Stay, "Stay"),
+            (WhilePlaying::Minimize, "Minimise"),
+        ];
+        if cfg!(target_os = "macos") {
+            options.push((WhilePlaying::Hide, "Hide"));
+        }
+        let current = self.settings.while_playing.here();
+        let picker = segments("while-playing", &options, current, &t, {
+            let this = cx.entity().downgrade();
+            move |choice, _, cx| {
+                let _ = this.update(cx, |this, cx| {
+                    this.settings.while_playing = choice;
+                    this.settings.save();
+                    cx.notify();
+                });
+            }
+        });
+        let said = match current {
+            WhilePlaying::Stay => "The launcher stays open while you play.",
+            WhilePlaying::Minimize => {
+                "The launcher goes down when the game starts, and comes back when it closes."
+            }
+            WhilePlaying::Hide => {
+                "The launcher hides when the game starts, and comes back when it closes."
+            }
+        };
+        index_row(
+            n,
+            "While playing",
+            Some(div().child(said).into_any_element()),
+            Some(picker.into_any_element()),
+            &t,
+        )
+    }
+}

From 82c8398c6b3ba361e5f57342e927fb7c94956af3 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:02:20 +0100
Subject: [PATCH 424/475] launcher: desktop shortcut that plays an instance

Home's Instance row gets Shortcut / Remove shortcut, and the CLI and MCP
instance shortcut [instance] [--remove]. The shortcut runs
horizon-launcher play --instance <id>: a .desktop file on Linux (and in
the applications menu), a script app with Horizon's icon on macOS, and a
Shell Link written from Microsoft's published MS-SHLLINK layout on
Windows. HORIZON_LAUNCHER_DESKTOP points it at a scratch folder.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                      |   2 +-
 docs/launcher-commands.md      |  11 +
 launcher/README.md             |   7 +
 launcher/src/cli.rs            |  30 +++
 launcher/src/desktop.rs        |   4 +-
 launcher/src/desktop_seams.rs  |   6 +-
 launcher/src/instances_page.rs |  19 +-
 launcher/src/lib.rs            |   1 +
 launcher/src/main.rs           |   4 +
 launcher/src/shortcut.rs       | 427 +++++++++++++++++++++++++++++++++
 launcher/src/shortcut/tests.rs | 197 +++++++++++++++
 launcher/src/shortcut_page.rs  |  69 ++++++
 12 files changed, 766 insertions(+), 11 deletions(-)
 create mode 100644 launcher/src/shortcut.rs
 create mode 100644 launcher/src/shortcut/tests.rs
 create mode 100644 launcher/src/shortcut_page.rs

diff --git a/AGENTS.md b/AGENTS.md
index 932eb1067..9c702e8ee 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -11,7 +11,7 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
 - **Keep your runs away from real player data.** Any game or launcher you start gets fresh `mktemp -d`
   folders in `HORIZON_HOME` (the game's data), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
   `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`, and, for the
-  launcher, `HORIZON_LAUNCHER_TRASH` and `HORIZON_LAUNCHER_CLIPBOARD` pointing into the scratch home. Never write to
+  launcher, `HORIZON_LAUNCHER_TRASH`, `HORIZON_LAUNCHER_CLIPBOARD` and `HORIZON_LAUNCHER_DESKTOP` pointing into the scratch home. Never write to
   `~/.local/share/{applications,horizon,horizon-launcher}` or `~/.local/bin`.
 - **Mark what an agent posts.** A PR body starts with a line naming whose agent opened it and with what.
   Ludovic's agents write `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.`, and a
diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 432b76e72..03a631cf0 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -364,6 +364,17 @@ Export an instance (or a port) to share: its settings, packs, Horizon mods and t
 
 MCP: `instance_export`.
 
+## `horizon-launcher instance shortcut`
+
+Put a shortcut on the desktop that plays an instance (`play --instance`): a .desktop file (also in the applications menu) on Linux, an app on macOS, a .lnk on Windows.
+
+    horizon-launcher instance shortcut [INSTANCE]
+
+- `INSTANCE`: The instance (default: the selected one)
+- `--remove`: Move the instance's shortcuts to the trash instead
+
+MCP: `instance_shortcut`.
+
 ## `horizon-launcher instance import`
 
 Import what a file is, as dropping it on the window does: a shared instance (a .mrpack without mod loaders, such as `instance export` writes, or a game folder zip) becomes a new instance; a Java modpack goes to the Modpacks import; a resource or shader pack into the instance (default: the selected one).
diff --git a/launcher/README.md b/launcher/README.md
index ad96eece1..963ddd187 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -100,6 +100,13 @@ The opening, then Play ([clip](docs/opening.webm)):
   pack into the selected instance. A data pack is pointed at the world rows, and the Packs section
   and the world rows keep taking their own drops. A note in the corner says what happened.
   `horizon-launcher instance import <file>`.
+- **Desktop shortcut**: Home's Instance row has **Shortcut**: a shortcut on the desktop that plays
+  the selected instance without opening the launcher (`horizon-launcher play --instance <id>`).
+  A `.desktop` file on Linux (also put in the applications menu, and marked trusted with `gio`
+  where it exists), a small app with Horizon's icon on macOS, a `.lnk` on Windows
+  (`horizon_launcher::shortcut`). **Remove shortcut** moves it to the trash; it is found by the
+  instance id inside it, so a rename doesn't lose it. `horizon-launcher instance shortcut
+  [instance] [--remove]`; `HORIZON_LAUNCHER_DESKTOP` points it at another folder.
 - **Console**: Home's Console shows the game's output of this run as it comes: a search (every
   word, any case), Follow to keep the newest line in view, Copy, and Open logs folder. Warnings
   and errors stand out. **Share log…** uploads the log to [mclo.gs](https://mclo.gs), a paste
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 246538b08..00c21ec66 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -198,6 +198,15 @@ enum InstanceCmd {
         #[arg(long)]
         out: Option<PathBuf>,
     },
+    /// Put a shortcut on the desktop that plays an instance (`play --instance`): a .desktop
+    /// file (also in the applications menu) on Linux, an app on macOS, a .lnk on Windows
+    Shortcut {
+        /// The instance (default: the selected one)
+        instance: Option<String>,
+        /// Move the instance's shortcuts to the trash instead
+        #[arg(long)]
+        remove: bool,
+    },
     /// Import what a file is, as dropping it on the window does: a shared instance (a .mrpack
     /// without mod loaders, such as `instance export` writes, or a game folder zip) becomes a
     /// new instance; a Java modpack goes to the Modpacks import; a resource or shader pack into
@@ -1827,6 +1836,27 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
             };
             changed(instances::edit(&instance, |m| m.version = pin)?)
         }
+        InstanceCmd::Shortcut { instance, remove } => {
+            use horizon_launcher::shortcut;
+            let i = match instance {
+                Some(name) => instances::find(&name)?,
+                None => instances::selected(),
+            };
+            let paths = match remove {
+                false => shortcut::make(backend::exe_path(), &i.id, &i.name)?,
+                true => shortcut::remove(&i.id)?,
+            };
+            if as_json {
+                json(serde_json::json!({ "instance": i.id, "paths": paths }));
+            } else if remove && paths.is_empty() {
+                println!("{} has no shortcut.", i.name);
+            } else {
+                let did = if remove { "Moved to the trash" } else { "Made" };
+                for path in paths {
+                    println!("{did}: {}", path.display());
+                }
+            }
+        }
         InstanceCmd::Import { file, instance } => {
             use horizon_launcher::import::{self, Dropped};
             use horizon_launcher::modpacks;
diff --git a/launcher/src/desktop.rs b/launcher/src/desktop.rs
index 281850cb6..863923acb 100644
--- a/launcher/src/desktop.rs
+++ b/launcher/src/desktop.rs
@@ -65,7 +65,7 @@ pub fn data_home() -> Option<PathBuf> {
 }
 
 /// Quotes a path for an `Exec` key: inside double quotes, `"`, `` ` ``, `$` and `\` are escaped.
-fn quote(path: &Path) -> String {
+pub(crate) fn quote(path: &Path) -> String {
     let mut out = String::from("\"");
     for c in path.to_string_lossy().chars() {
         if matches!(c, '"' | '`' | '$' | '\\') {
@@ -215,7 +215,7 @@ pub fn needs_repair_in(data: &Path, path: Option<&OsStr>) -> bool {
 
 /// What the entry starts: a distributor's wrapper (`HORIZON_LAUNCHER_DESKTOP_EXEC`) when one is
 /// configured, else the binary at `exe`.
-fn target(exe: &Path) -> PathBuf {
+pub(crate) fn target(exe: &Path) -> PathBuf {
     std::env::var_os("HORIZON_LAUNCHER_DESKTOP_EXEC")
         .filter(|path| !path.is_empty())
         .map_or_else(|| exe.to_path_buf(), PathBuf::from)
diff --git a/launcher/src/desktop_seams.rs b/launcher/src/desktop_seams.rs
index edec7ab8d..2815748ea 100644
--- a/launcher/src/desktop_seams.rs
+++ b/launcher/src/desktop_seams.rs
@@ -7,7 +7,8 @@
 //!   (text as UTF-8, a picture as its PNG or JPEG bytes).
 //!
 //! Test runs point both into their scratch folders, beside `HORIZON_HOME` and
-//! `HORIZON_LAUNCHER_HOME`.
+//! `HORIZON_LAUNCHER_HOME`, and `HORIZON_LAUNCHER_DESKTOP` too (`shortcut`: where desktop
+//! shortcuts go).
 use std::path::{Path, PathBuf};
 
 pub const TRASH_ENV: &str = "HORIZON_LAUNCHER_TRASH";
@@ -22,7 +23,8 @@ pub fn to_trash(path: &Path) -> Result<(), String> {
     }
 }
 
-fn to_folder(path: &Path, dir: &Path) -> Result<(), String> {
+/// Moves `path` into `dir` under a free name: the trash of a test run.
+pub fn to_folder(path: &Path, dir: &Path) -> Result<(), String> {
     std::fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
     let name = path.file_name().ok_or("Nothing to move")?.to_string_lossy();
     let target = (1..)
diff --git a/launcher/src/instances_page.rs b/launcher/src/instances_page.rs
index 273f967df..9af5051fe 100644
--- a/launcher/src/instances_page.rs
+++ b/launcher/src/instances_page.rs
@@ -590,6 +590,7 @@ impl Launcher {
                     cx.notify();
                 })),
             )
+            .child(self.shortcut_button(&instance, cx))
             .child(
                 button("instance-folder", "Open folder", Kind::Ghost, &t).on_click(
                     move |_, _, cx| {
@@ -604,14 +605,20 @@ impl Launcher {
             Some(
                 div()
                     .flex()
-                    .items_baseline()
-                    .gap(px(10.))
-                    .child(instance.name.clone())
+                    .flex_col()
                     .child(
-                        text(theme::CAPTION)
-                            .text_color(t.muted)
-                            .child(played_line(&instance)),
+                        div()
+                            .flex()
+                            .items_baseline()
+                            .gap(px(10.))
+                            .child(instance.name.clone())
+                            .child(
+                                text(theme::CAPTION)
+                                    .text_color(t.muted)
+                                    .child(played_line(&instance)),
+                            ),
                     )
+                    .children(self.shortcut_note(&instance.id))
                     .into_any_element(),
             ),
             Some(actions.into_any_element()),
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index 28c6d21bd..ea896aa21 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -21,6 +21,7 @@ pub mod proxy;
 pub mod screenshots;
 pub mod server_list;
 pub mod servers;
+pub mod shortcut;
 pub mod signed;
 pub mod sources;
 pub mod tailscale;
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 352ae7e98..257b83226 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -30,6 +30,7 @@ mod perf;
 mod screenshots_page;
 mod scrollbar;
 mod servers_page;
+mod shortcut_page;
 mod theme;
 mod titlebar;
 mod while_playing;
@@ -250,6 +251,8 @@ struct Launcher {
     console: console_page::Console,
     /// What the window did when the game started (`while_playing.rs`).
     aside: while_playing::Aside,
+    /// The selected instance's desktop shortcut (`shortcut_page.rs`).
+    shortcuts: shortcut_page::Shortcuts,
     /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar.
     offline_name: Option<String>,
     /// The player's servers, for the sidebar until the Servers page has read them.
@@ -418,6 +421,7 @@ impl Launcher {
             importing: Default::default(),
             console: Default::default(),
             aside: while_playing::Aside::new(window.window_handle()),
+            shortcuts: Default::default(),
             offline_name: offline_name(),
             side_servers: horizon_launcher::servers::list(),
             art: art::Art::default(),
diff --git a/launcher/src/shortcut.rs b/launcher/src/shortcut.rs
new file mode 100644
index 000000000..b4e97abd4
--- /dev/null
+++ b/launcher/src/shortcut.rs
@@ -0,0 +1,427 @@
+//! A shortcut on the desktop that plays one instance: it runs
+//! `horizon-launcher play --instance <id>`, so the game starts without the launcher's window.
+//!
+//! - Linux: `<name> (Horizon).desktop` on the desktop (executable, and marked trusted with `gio`
+//!   where it exists, so GNOME starts it), and the same entry in the applications menu
+//!   (`applications/horizon-instance-<id>.desktop`, `desktop::data_home`).
+//! - macOS: `<name> (Horizon).app`, a small app whose program is a shell script, with Horizon's
+//!   icon. It has no Dock icon of its own (`LSUIElement`): the game's window is the one to see.
+//! - Windows: `<name> (Horizon).lnk`, a Shell Link as Microsoft's published [MS-SHLLINK] format
+//!   lays it out, to the launcher's `.exe` with Horizon's icon.
+//!
+//! Each shortcut names its instance's id inside it, so removing finds it after a rename.
+//! `HORIZON_LAUNCHER_DESKTOP` points the desktop folder elsewhere, for tests.
+//!
+//! [MS-SHLLINK]: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-shllink/
+use crate::desktop;
+use crate::desktop_seams;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+pub const DESKTOP_ENV: &str = "HORIZON_LAUNCHER_DESKTOP";
+const MAC_ICON: &[u8] = include_bytes!("../../packaging/icons/horizon.icns");
+/// The key a Linux shortcut names its instance with.
+const INSTANCE_KEY: &str = "X-Horizon-Instance";
+/// And a macOS one, in its Info.plist.
+const MAC_KEY: &str = "<key>HorizonInstance</key>";
+
+/// The kinds of shortcut, one per system: all of them can be written and tested anywhere.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum System {
+    Linux,
+    Mac,
+    Windows,
+}
+
+impl System {
+    pub fn here() -> Self {
+        if cfg!(target_os = "macos") {
+            Self::Mac
+        } else if cfg!(windows) {
+            Self::Windows
+        } else {
+            Self::Linux
+        }
+    }
+
+    fn extension(self) -> &'static str {
+        match self {
+            Self::Linux => "desktop",
+            Self::Mac => "app",
+            Self::Windows => "lnk",
+        }
+    }
+}
+
+/// The desktop folder: `HORIZON_LAUNCHER_DESKTOP`, else the system's.
+pub fn desktop_dir() -> Option<PathBuf> {
+    std::env::var_os(DESKTOP_ENV)
+        .filter(|v| !v.is_empty())
+        .map(PathBuf::from)
+        .or_else(dirs::desktop_dir)
+}
+
+/// The shortcut's file name: the instance's name without the characters a file name can't
+/// hold on any of the three systems.
+pub fn file_name(name: &str, system: System) -> String {
+    let clean: String = name
+        .chars()
+        .map(|c| match c {
+            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '-',
+            c if c.is_control() => '-',
+            c => c,
+        })
+        .collect();
+    let clean = clean.trim().trim_matches('.');
+    let clean = if clean.is_empty() { "Instance" } else { clean };
+    format!("{clean} (Horizon).{}", system.extension())
+}
+
+/// The id as a file name or bundle id part: letters, digits and `-`.
+fn slug(id: &str) -> String {
+    id.chars()
+        .map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
+        .collect()
+}
+
+/// A Linux `.desktop` entry that plays the instance.
+pub fn desktop_entry(exe: &Path, id: &str, name: &str) -> String {
+    let field = |s: &str| s.replace(['\n', '\r'], " ");
+    format!(
+        "[Desktop Entry]\n\
+         Type=Application\n\
+         Name={name}\n\
+         Comment=Play {name} in Horizon\n\
+         Exec={} play --instance {}\n\
+         TryExec={}\n\
+         Icon=horizon\n\
+         Terminal=false\n\
+         Categories=Game;\n\
+         StartupWMClass=horizon\n\
+         {INSTANCE_KEY}={id}\n",
+        desktop::quote(exe),
+        desktop::quote(Path::new(id)),
+        exe.display(),
+        name = field(name),
+        id = field(id),
+    )
+}
+
+/// `'text'` for a POSIX shell.
+fn sh_quote(text: &str) -> String {
+    format!("'{}'", text.replace('\'', r"'\''"))
+}
+
+fn xml(text: &str) -> String {
+    text.replace('&', "&amp;")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;")
+        .replace('"', "&quot;")
+}
+
+/// A macOS app's files, by path inside the `.app`, and whether each is a program.
+pub fn mac_app(exe: &Path, id: &str, name: &str) -> Vec<(&'static str, Vec<u8>, bool)> {
+    let plist = format!(
+        r#"<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleExecutable</key>
+	<string>play</string>
+	<key>CFBundleIdentifier</key>
+	<string>dev.horizon.instance.{}</string>
+	<key>CFBundleName</key>
+	<string>{}</string>
+	<key>CFBundleIconFile</key>
+	<string>horizon</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>LSUIElement</key>
+	<true/>
+	{MAC_KEY}
+	<string>{}</string>
+</dict>
+</plist>
+"#,
+        slug(id),
+        xml(name),
+        xml(id),
+    );
+    let script = format!(
+        "#!/bin/sh\n# Plays the Horizon instance {}.\nexec {} play --instance {}\n",
+        name.replace('\n', " "),
+        sh_quote(&exe.to_string_lossy()),
+        sh_quote(id),
+    );
+    vec![
+        ("Contents/Info.plist", plist.into_bytes(), false),
+        ("Contents/MacOS/play", script.into_bytes(), true),
+        ("Contents/Resources/horizon.icns", MAC_ICON.to_vec(), false),
+    ]
+}
+
+/// The arguments of a Windows shortcut: the id in quotes, with its own quotes escaped.
+fn windows_args(id: &str) -> String {
+    format!("play --instance \"{}\"", id.replace('"', "\\\""))
+}
+
+fn utf16(text: &str) -> Vec<u8> {
+    text.encode_utf16().flat_map(u16::to_le_bytes).collect()
+}
+
+/// A Windows Shell Link ([MS-SHLLINK]) to `exe` (a Windows path) with `args`: the header, a
+/// LinkInfo with the local path (ANSI and Unicode), then the name, working folder, arguments and
+/// icon as Unicode strings.
+pub fn lnk(exe: &str, args: &str, comment: &str) -> Vec<u8> {
+    const HAS_LINK_INFO: u32 = 0x02;
+    const HAS_NAME: u32 = 0x04;
+    const HAS_WORKING_DIR: u32 = 0x10;
+    const HAS_ARGUMENTS: u32 = 0x20;
+    const HAS_ICON_LOCATION: u32 = 0x40;
+    const IS_UNICODE: u32 = 0x80;
+    const FILE_ATTRIBUTE_NORMAL: u32 = 0x80;
+    const SW_SHOWNORMAL: u32 = 1;
+    let flags =
+        HAS_LINK_INFO | HAS_NAME | HAS_WORKING_DIR | HAS_ARGUMENTS | HAS_ICON_LOCATION | IS_UNICODE;
+    let mut out = Vec::new();
+    out.extend(0x4Cu32.to_le_bytes());
+    // CLSID 00021401-0000-0000-C000-000000000046.
+    out.extend([
+        0x01, 0x14, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x46,
+    ]);
+    out.extend(flags.to_le_bytes());
+    out.extend(FILE_ATTRIBUTE_NORMAL.to_le_bytes());
+    out.extend([0; 24]); // creation, access and write times: unknown
+    out.extend(0u32.to_le_bytes()); // file size
+    out.extend(0i32.to_le_bytes()); // icon index
+    out.extend(SW_SHOWNORMAL.to_le_bytes());
+    out.extend([0; 2 + 2 + 4 + 4]); // hot key, reserved
+
+    // LinkInfo: a header with the Unicode offsets (0x24 bytes), a VolumeID for a fixed drive
+    // with no label, the path in ANSI (anything else as '?') and in UTF-16, and empty suffixes.
+    let header = 0x24u32;
+    let volume: Vec<u8> = [0x11u32, 3, 0, 0x10]
+        .iter()
+        .flat_map(|v| v.to_le_bytes())
+        .chain([0])
+        .collect();
+    let ansi: Vec<u8> = exe
+        .chars()
+        .map(|c| if c.is_ascii() { c as u8 } else { b'?' })
+        .chain([0])
+        .collect();
+    let wide: Vec<u8> = utf16(exe).into_iter().chain([0, 0]).collect();
+    let volume_at = header;
+    let path_at = volume_at + volume.len() as u32;
+    let suffix_at = path_at + ansi.len() as u32;
+    let wide_at = suffix_at + 1;
+    let wide_suffix_at = wide_at + wide.len() as u32;
+    let size = wide_suffix_at + 2;
+    for v in [
+        size,
+        header,
+        1, // VolumeIDAndLocalBasePath
+        volume_at,
+        path_at,
+        0, // no network path
+        suffix_at,
+        wide_at,
+        wide_suffix_at,
+    ] {
+        out.extend(v.to_le_bytes());
+    }
+    out.extend(volume);
+    out.extend(ansi);
+    out.push(0);
+    out.extend(wide);
+    out.extend([0, 0]);
+
+    let folder = exe.rsplit_once('\\').map_or("", |(dir, _)| dir);
+    for text in [comment, folder, args, exe] {
+        out.extend((text.encode_utf16().count() as u16).to_le_bytes());
+        out.extend(utf16(text));
+    }
+    out.extend(0u32.to_le_bytes()); // no extra data
+    out
+}
+
+/// Whether the shortcut at `path` plays the instance `id`.
+fn plays(path: &Path, id: &str) -> bool {
+    let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+    match ext {
+        "desktop" => fs::read_to_string(path)
+            .is_ok_and(|t| t.lines().any(|l| l == format!("{INSTANCE_KEY}={id}"))),
+        "app" => fs::read_to_string(path.join("Contents/Info.plist"))
+            .is_ok_and(|t| t.contains(&format!("{MAC_KEY}\n\t<string>{}</string>", xml(id)))),
+        "lnk" => fs::read(path).is_ok_and(|b| {
+            let want = utf16(&windows_args(id));
+            b.windows(want.len()).any(|w| w == want)
+        }),
+        _ => false,
+    }
+}
+
+/// Writes `bytes` beside `path` and renames it in, so nothing reads half a file.
+fn write(path: &Path, bytes: &[u8], program: bool) -> Result<(), String> {
+    let fail = |e: std::io::Error| format!("{}: {e}", path.display());
+    if let Some(dir) = path.parent() {
+        fs::create_dir_all(dir).map_err(fail)?;
+    }
+    let temp = path.with_extension("horizon-tmp");
+    fs::write(&temp, bytes).map_err(fail)?;
+    #[cfg(unix)]
+    if program {
+        use std::os::unix::fs::PermissionsExt;
+        fs::set_permissions(&temp, fs::Permissions::from_mode(0o755)).map_err(fail)?;
+    }
+    #[cfg(not(unix))]
+    let _ = program;
+    fs::rename(&temp, path).map_err(fail)
+}
+
+/// Moves a file or folder out of the way, where the player can get it back.
+pub type Trash<'a> = &'a dyn Fn(&Path) -> Result<(), String>;
+
+/// Makes the shortcut for `system` in `desktop` (and, for Linux, the menu entry under
+/// `menu`, an `applications` folder). The instance's shortcut of the same name is rewritten;
+/// one under an older name goes to `trash`. Returns what it wrote.
+pub fn make_in(
+    system: System,
+    desktop: &Path,
+    menu: Option<&Path>,
+    exe: &Path,
+    id: &str,
+    name: &str,
+    trash: Trash,
+) -> Result<Vec<PathBuf>, String> {
+    let path = desktop.join(file_name(name, system));
+    let item = menu.map(|m| m.join(format!("horizon-instance-{}.desktop", slug(id))));
+    for old in find_in(desktop, menu, id) {
+        if old != path && Some(&old) != item.as_ref() {
+            trash(&old)?;
+        }
+    }
+    if path.exists() && !plays(&path, id) {
+        return Err(format!(
+            "{} is already on the desktop, and isn't this instance's shortcut.",
+            path.file_name().unwrap().to_string_lossy()
+        ));
+    }
+    let mut made = vec![path.clone()];
+    match system {
+        System::Linux => {
+            let entry = desktop_entry(exe, id, name);
+            write(&path, entry.as_bytes(), true)?;
+            if let Some(item) = item {
+                write(&item, entry.as_bytes(), false)?;
+                made.push(item);
+            }
+        }
+        System::Mac => {
+            for (inside, bytes, program) in mac_app(exe, id, name) {
+                write(&path.join(inside), &bytes, program)?;
+            }
+        }
+        System::Windows => write(
+            &path,
+            &lnk(
+                &exe.to_string_lossy(),
+                &windows_args(id),
+                &format!("Play {name} in Horizon"),
+            ),
+            false,
+        )?,
+    }
+    Ok(made)
+}
+
+/// The instance's shortcuts in `desktop` and the menu.
+pub fn find_in(desktop: &Path, menu: Option<&Path>, id: &str) -> Vec<PathBuf> {
+    let mut found: Vec<PathBuf> = fs::read_dir(desktop)
+        .into_iter()
+        .flatten()
+        .flatten()
+        .map(|e| e.path())
+        .filter(|p| plays(p, id))
+        .collect();
+    if let Some(item) = menu
+        .map(|m| m.join(format!("horizon-instance-{}.desktop", slug(id))))
+        .filter(|p| plays(p, id))
+    {
+        found.push(item);
+    }
+    found.sort();
+    found
+}
+
+/// Moves the instance's shortcuts to `trash`. Returns what it moved.
+pub fn remove_in(
+    desktop: &Path,
+    menu: Option<&Path>,
+    id: &str,
+    trash: Trash,
+) -> Result<Vec<PathBuf>, String> {
+    let found = find_in(desktop, menu, id);
+    for path in &found {
+        trash(path)?;
+    }
+    Ok(found)
+}
+
+fn menu() -> Option<PathBuf> {
+    (System::here() == System::Linux)
+        .then(desktop::data_home)
+        .flatten()
+        .map(|d| d.join("applications"))
+}
+
+fn desktop_or_err() -> Result<PathBuf, String> {
+    desktop_dir().ok_or_else(|| "This computer has no desktop folder.".into())
+}
+
+/// Makes the shortcut on this computer's desktop that plays `id`, starting `exe`.
+pub fn make(exe: &Path, id: &str, name: &str) -> Result<Vec<PathBuf>, String> {
+    let desktop = desktop_or_err()?;
+    let made = make_in(
+        System::here(),
+        &desktop,
+        menu().as_deref(),
+        &desktop::target(exe),
+        id,
+        name,
+        &desktop_seams::to_trash,
+    )?;
+    if System::here() == System::Linux {
+        // GNOME starts a desktop file only once it is trusted; elsewhere this does nothing.
+        let _ = std::process::Command::new("gio")
+            .args(["set", "-t", "string"])
+            .arg(&made[0])
+            .args(["metadata::trusted", "true"])
+            .stdout(std::process::Stdio::null())
+            .stderr(std::process::Stdio::null())
+            .status();
+    }
+    Ok(made)
+}
+
+/// The instance's shortcuts on this computer.
+pub fn find(id: &str) -> Vec<PathBuf> {
+    desktop_dir()
+        .map(|d| find_in(&d, menu().as_deref(), id))
+        .unwrap_or_default()
+}
+
+/// Moves the instance's shortcuts on this computer to the trash.
+pub fn remove(id: &str) -> Result<Vec<PathBuf>, String> {
+    remove_in(
+        &desktop_or_err()?,
+        menu().as_deref(),
+        id,
+        &desktop_seams::to_trash,
+    )
+}
+
+#[cfg(test)]
+#[path = "shortcut/tests.rs"]
+mod tests;
diff --git a/launcher/src/shortcut/tests.rs b/launcher/src/shortcut/tests.rs
new file mode 100644
index 000000000..ce49d5b20
--- /dev/null
+++ b/launcher/src/shortcut/tests.rs
@@ -0,0 +1,197 @@
+use super::*;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!("horizon-shortcut-{name}-{}", std::process::id()));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+#[test]
+fn names_fit_every_system() {
+    assert_eq!(
+        file_name("Hardcore", System::Linux),
+        "Hardcore (Horizon).desktop"
+    );
+    assert_eq!(
+        file_name("A/B: C?", System::Windows),
+        "A-B- C- (Horizon).lnk"
+    );
+    assert_eq!(file_name(" .. ", System::Mac), "Instance (Horizon).app");
+    assert_eq!(slug("port:all the mods"), "port-all-the-mods");
+}
+
+#[test]
+fn a_linux_entry_plays_its_instance() {
+    let entry = desktop_entry(
+        Path::new("/opt/My Horizon/horizon-launcher"),
+        "port:atm",
+        "ATM",
+    );
+    assert!(entry.starts_with("[Desktop Entry]\nType=Application\nName=ATM\n"));
+    assert!(entry
+        .contains("\nExec=\"/opt/My Horizon/horizon-launcher\" play --instance \"port:atm\"\n"));
+    assert!(entry.contains("\nTryExec=/opt/My Horizon/horizon-launcher\n"));
+    assert!(entry.ends_with("\nX-Horizon-Instance=port:atm\n"));
+    let odd = desktop_entry(Path::new("/x"), "a", "Two\nlines");
+    assert!(odd.contains("Name=Two lines\n"));
+}
+
+#[test]
+fn a_mac_app_runs_a_script_that_plays_its_instance() {
+    let files = mac_app(
+        Path::new("/Applications/Horizon Launcher.app/Contents/MacOS/horizon-launcher"),
+        "it's",
+        "Tom & Jerry",
+    );
+    let (_, plist, _) = &files[0];
+    let plist = String::from_utf8(plist.clone()).unwrap();
+    assert!(plist.contains("<string>Tom &amp; Jerry</string>"));
+    assert!(plist.contains("<string>dev.horizon.instance.it-s</string>"));
+    assert!(plist.contains("<key>LSUIElement</key>\n\t<true/>"));
+    let (path, script, program) = &files[1];
+    assert_eq!((*path, *program), ("Contents/MacOS/play", true));
+    assert!(String::from_utf8(script.clone()).unwrap().ends_with(
+        "exec '/Applications/Horizon Launcher.app/Contents/MacOS/horizon-launcher' play \
+         --instance 'it'\\''s'\n"
+    ));
+    assert_eq!(files[2].1, MAC_ICON);
+}
+
+/// Reads a Shell Link back by its spec: the header, the LinkInfo's paths, and the strings.
+fn read_lnk(b: &[u8]) -> (u32, String, String, Vec<String>) {
+    let u32_at = |at: usize| u32::from_le_bytes(b[at..at + 4].try_into().unwrap());
+    assert_eq!(u32_at(0), 0x4C);
+    assert_eq!(
+        &b[4..20],
+        &[1, 0x14, 2, 0, 0, 0, 0, 0, 0xC0, 0, 0, 0, 0, 0, 0, 0x46]
+    );
+    let flags = u32_at(20);
+    assert_eq!(u32_at(60), 1, "show normal");
+    let info = 76;
+    let size = u32_at(info) as usize;
+    assert_eq!(u32_at(info + 4), 0x24);
+    assert_eq!(u32_at(info + 8), 1);
+    let volume = info + u32_at(info + 12) as usize;
+    assert_eq!((u32_at(volume), u32_at(volume + 4)), (0x11, 3));
+    let cstr = |at: usize| {
+        let end = b[at..].iter().position(|&c| c == 0).unwrap();
+        String::from_utf8(b[at..at + end].to_vec()).unwrap()
+    };
+    let ansi = cstr(info + u32_at(info + 16) as usize);
+    assert_eq!(cstr(info + u32_at(info + 24) as usize), "");
+    let wide_at = info + u32_at(info + 28) as usize;
+    let wide: Vec<u16> = b[wide_at..]
+        .chunks(2)
+        .map(|c| u16::from_le_bytes([c[0], c[1]]))
+        .take_while(|&c| c != 0)
+        .collect();
+    let wide = String::from_utf16(&wide).unwrap();
+    assert_eq!(
+        ansi.replace('?', ""),
+        wide.replace(|c: char| !c.is_ascii(), "")
+    );
+    let mut at = info + size;
+    let mut strings = Vec::new();
+    for _ in 0..4 {
+        let n = u16::from_le_bytes([b[at], b[at + 1]]) as usize;
+        let units: Vec<u16> = b[at + 2..at + 2 + 2 * n]
+            .chunks(2)
+            .map(|c| u16::from_le_bytes([c[0], c[1]]))
+            .collect();
+        strings.push(String::from_utf16(&units).unwrap());
+        at += 2 + 2 * n;
+    }
+    assert_eq!(&b[at..], &[0, 0, 0, 0], "the terminal block ends it");
+    (flags, ansi, wide, strings)
+}
+
+#[test]
+fn a_windows_shortcut_is_a_shell_link_to_the_launcher() {
+    let exe = r"C:\Users\Zoé\AppData\Local\Horizon\horizon-launcher.exe";
+    let b = lnk(exe, &windows_args("port:atm"), "Play ATM in Horizon");
+    let (flags, ansi, wide, strings) = read_lnk(&b);
+    assert_eq!(flags, 0x02 | 0x04 | 0x10 | 0x20 | 0x40 | 0x80);
+    assert_eq!(
+        ansi,
+        r"C:\Users\Zo?\AppData\Local\Horizon\horizon-launcher.exe"
+    );
+    assert_eq!(wide, exe);
+    assert_eq!(
+        strings,
+        [
+            "Play ATM in Horizon",
+            r"C:\Users\Zoé\AppData\Local\Horizon",
+            "play --instance \"port:atm\"",
+            exe,
+        ]
+    );
+}
+
+#[test]
+fn shortcuts_are_made_found_renamed_and_removed() {
+    let root = scratch("make");
+    let (desktop, menu, trash) = (
+        root.join("Desktop"),
+        root.join("applications"),
+        root.join("trash"),
+    );
+    let bin = trash.clone();
+    let trash_fn = move |p: &Path| desktop_seams::to_folder(p, &bin);
+    let t: Trash = &trash_fn;
+    let exe = Path::new("/opt/horizon-launcher");
+    for system in [System::Linux, System::Mac, System::Windows] {
+        let made = make_in(
+            system,
+            &desktop,
+            Some(&menu),
+            exe,
+            "hardcore",
+            "Hardcore",
+            t,
+        )
+        .unwrap();
+        assert_eq!(made[0], desktop.join(file_name("Hardcore", system)));
+        assert_eq!(find_in(&desktop, Some(&menu), "hardcore"), {
+            let mut m = made.clone();
+            m.sort();
+            m
+        });
+        // Again: rewritten in place, nothing in the trash.
+        make_in(
+            system,
+            &desktop,
+            Some(&menu),
+            exe,
+            "hardcore",
+            "Hardcore",
+            t,
+        )
+        .unwrap();
+        assert!(!trash.exists());
+        // Renamed: the old one goes, the new one is there.
+        let made = make_in(system, &desktop, Some(&menu), exe, "hardcore", "Hard", t).unwrap();
+        assert!(made[0].ends_with(file_name("Hard", system)));
+        assert!(!desktop.join(file_name("Hardcore", system)).exists());
+        assert!(find_in(&desktop, Some(&menu), "skyblock").is_empty());
+        let gone = remove_in(&desktop, Some(&menu), "hardcore", t).unwrap();
+        assert_eq!(gone.len(), made.len());
+        assert!(find_in(&desktop, Some(&menu), "hardcore").is_empty());
+        fs::remove_dir_all(&trash).unwrap();
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let made = make_in(System::Mac, &desktop, None, exe, "a", "A", t).unwrap();
+        let mode = fs::metadata(made[0].join("Contents/MacOS/play"))
+            .unwrap()
+            .permissions()
+            .mode();
+        assert_eq!(mode & 0o111, 0o111);
+    }
+    // Someone else's file of that name stays.
+    fs::write(desktop.join("Mine (Horizon).desktop"), "not ours").unwrap();
+    let err = make_in(System::Linux, &desktop, None, exe, "mine", "Mine", t).unwrap_err();
+    assert!(err.contains("isn't this instance's shortcut"), "{err}");
+    fs::remove_dir_all(&root).unwrap();
+}
diff --git a/launcher/src/shortcut_page.rs b/launcher/src/shortcut_page.rs
new file mode 100644
index 000000000..68eb9ca2d
--- /dev/null
+++ b/launcher/src/shortcut_page.rs
@@ -0,0 +1,69 @@
+//! The Instance row's desktop shortcut (`horizon_launcher::shortcut`): make one that plays the
+//! selected instance, or take it away.
+use super::*;
+use horizon_launcher::shortcut;
+
+#[derive(Default)]
+pub(super) struct Shortcuts {
+    /// The instance last looked at, and whether it has a shortcut: read again only when the
+    /// selection changes or a button is pressed, not on every frame.
+    seen: Option<(String, bool)>,
+    /// What the last press did, for that instance.
+    note: Option<(String, Result<String, String>)>,
+}
+
+impl Launcher {
+    fn has_shortcut(&mut self, id: &str) -> bool {
+        match &self.shortcuts.seen {
+            Some((seen, has)) if seen == id => *has,
+            _ => {
+                let has = !shortcut::find(id).is_empty();
+                self.shortcuts.seen = Some((id.to_string(), has));
+                has
+            }
+        }
+    }
+
+    fn toggle_shortcut(&mut self, id: String, name: String) {
+        let has = self.has_shortcut(&id);
+        let done = match has {
+            false => shortcut::make(backend::exe_path(), &id, &name).map(|made| {
+                let file = made[0].file_name().unwrap_or_default().to_string_lossy();
+                format!("{file} is on your desktop: it plays {name}.")
+            }),
+            true => shortcut::remove(&id).map(|_| format!("{name}'s shortcut is in the trash.")),
+        };
+        self.shortcuts.seen = None;
+        self.shortcuts.note = Some((id, done));
+    }
+
+    /// The row's button.
+    pub(super) fn shortcut_button(
+        &mut self,
+        instance: &instances::Instance,
+        cx: &mut Context<Self>,
+    ) -> Stateful<Div> {
+        let t = self.theme;
+        let label = match self.has_shortcut(&instance.id) {
+            true => "Remove shortcut",
+            false => "Shortcut",
+        };
+        let (id, name) = (instance.id.clone(), instance.name.clone());
+        button("instance-shortcut", label, Kind::Ghost, &t).on_click(cx.listener(
+            move |this, _: &ClickEvent, _, cx| {
+                this.toggle_shortcut(id.clone(), name.clone());
+                cx.notify();
+            },
+        ))
+    }
+
+    /// What the last press did, under the row, while that instance is selected.
+    pub(super) fn shortcut_note(&self, id: &str) -> Option<Div> {
+        let t = self.theme;
+        let (_, said) = self.shortcuts.note.as_ref().filter(|(n, _)| n == id)?;
+        Some(match said {
+            Ok(said) => text(theme::CAPTION).text_color(t.muted).child(said.clone()),
+            Err(e) => text(theme::CAPTION).text_color(t.danger).child(e.clone()),
+        })
+    }
+}

From 8b87d128e6a3b7fd6966e46b8489065f53c444a3 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:08:32 +0100
Subject: [PATCH 425/475] parity: world_reopen and server_player_sculk count
 ticks, not request round trips

On playhorizon (frames drawn on the CPU, control requests answered slowly)
world_reopen read the minecarts before the mineshaft's last one arrived (3
then 4 on every reopen), and the sculk walk polled the sensor with separate
requests that missed its 30-tick active window. The minecart list is read
once it stops changing; both clients sample the sensor every tick from one
ctl script, alongside the walk.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tools/test_server_player_sculk_parity.py | 23 ++++++++++++++++++-----
 tools/test_world_reopen_parity.py        | 12 ++++++++++--
 2 files changed, 28 insertions(+), 7 deletions(-)

diff --git a/tools/test_server_player_sculk_parity.py b/tools/test_server_player_sculk_parity.py
index 33489ad5a..75c89ea44 100644
--- a/tools/test_server_player_sculk_parity.py
+++ b/tools/test_server_player_sculk_parity.py
@@ -8,6 +8,7 @@ hosts: the guest always uses the server-player path.
 import json
 import math
 import subprocess
+import threading
 
 import lab
 import lan_e2e as lan
@@ -43,17 +44,29 @@ def check_walk(host, guest, out, role):
         until(host, lambda: phase(host), lambda s: 'sculk_sensor_phase=inactive' in s)
         player.wait(10)
         assert 'sculk_sensor_phase=inactive' in phase(host), 'setup activated the sensor'
-        player.raw('key', 'w', 'down')
+        # The sensor stays active 30 ticks. Each client samples it every tick from inside one ctl script, so a
+        # runner that answers control requests slowly (frames drawn on the CPU) can't miss that window between
+        # separate requests; the other client samples alongside the walk.
+        probe = f'getblock {sensor[0]} {sensor[1]} {sensor[2]}'
+        other = guest if player is host else host
+        seen = {}
+
+        def watch(viewer, lines):
+            seen[viewer.name] = [r['block'] for r in viewer.script(lines, every=True) if 'block' in r]
+        watcher = threading.Thread(target=watch, args=(other, ['wait 1', probe] * 100))
+        watcher.start()
         try:
-            player.wait(15)
+            watch(player, ['key w down', *['wait 1', probe] * 15, 'key w up', *['wait 1', probe] * 85])
         finally:
             player.raw('key', 'w', 'up')
+            watcher.join()
         moved = {'client': math.dist(lan.pos_of(player), start),
                  'server': math.dist(lan.server_player(host, player)['position'], start)}
         assert all(d > 1 for d in moved.values()), moved
-        for viewer in (host, guest):
-            until(viewer, lambda: phase(viewer), lambda s: 'sculk_sensor_phase=active' in s, ticks=85)
-        return {'moved': moved, 'phase': phase(host)}
+        active = {name: next((i for i, s in enumerate(states) if 'sculk_sensor_phase=active' in s), None)
+                  for name, states in seen.items()}
+        assert len(active) == 2 and all(i is not None for i in active.values()), f'sensor never active: {seen}'
+        return {'moved': moved, 'first_active_sample': active}
     finally:
         player.raw('key', 'w', 'up')
         host('command', command=f'fill {x - 2} {y} {z - 2} {x + 5} {y + 3} {z + 5} minecraft:air')
diff --git a/tools/test_world_reopen_parity.py b/tools/test_world_reopen_parity.py
index 4ef9a5e87..d3e9c1da6 100644
--- a/tools/test_world_reopen_parity.py
+++ b/tools/test_world_reopen_parity.py
@@ -68,8 +68,16 @@ def main():
         return json.loads(result.stdout) if result.stdout.strip().startswith('{') else result.stdout
 
     def carts():
-        found = ctl('status')['carts']
-        return sorted((c['kind'], *(round(v, 1) for v in c['position'])) for c in found)
+        """The loaded minecarts once their list stops changing: on a loaded runner the mineshaft's chunks and their
+        entities keep arriving after the world counts as loaded, so one reading can be short of a cart."""
+        last = None
+        for _ in range(30):
+            found = sorted((c['kind'], *(round(v, 1) for v in c['position'])) for c in ctl('status')['carts'])
+            if found == last:
+                return found
+            last = found
+            ctl('wait', '40')
+        return last
 
     ctl('launch', '--resources', str(RESOURCES), '--world', 'reopen', '--seed', '7', '--creative',
         '--render-distance', '4', *extra)

From 7115c708e110e7077f8c4ca037295ad52e3db267 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:22:34 +0100
Subject: [PATCH 426/475] launcher: pre-launch command, wrapper and environment
 per instance

Home's Instance row gets Launch...: a shell command run in the instance's
folder before the game (which starts only if it succeeds), a wrapper the
game runs through, and environment variables, kept in instances.json.
The game stays one process: /bin/sh runs the command and execs the
wrapper and game through "$@" on Unix, cmd /C on Windows. The window's
Play and `play` both use them. CLI and MCP: instance launch (confirm
needed over MCP). The Instance row's actions move under its name, and
editing an instance that shares its name with an import works again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md       |  13 ++
 launcher/README.md              |   8 ++
 launcher/src/cli.rs             |  53 +++++++-
 launcher/src/cli_tools.rs       |   2 +
 launcher/src/import/tests.rs    |   1 +
 launcher/src/instances.rs       |  17 ++-
 launcher/src/instances/tests.rs |  12 ++
 launcher/src/instances_page.rs  |  23 +++-
 launcher/src/launch.rs          | 220 ++++++++++++++++++++++++++++++++
 launcher/src/launch/tests.rs    | 143 +++++++++++++++++++++
 launcher/src/launch_page.rs     | 137 ++++++++++++++++++++
 launcher/src/lib.rs             |   1 +
 launcher/src/main.rs            |  12 ++
 launcher/src/servers_page.rs    |  10 +-
 14 files changed, 646 insertions(+), 6 deletions(-)
 create mode 100644 launcher/src/launch.rs
 create mode 100644 launcher/src/launch/tests.rs
 create mode 100644 launcher/src/launch_page.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 03a631cf0..41108a86e 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -364,6 +364,19 @@ Export an instance (or a port) to share: its settings, packs, Horizon mods and t
 
 MCP: `instance_export`.
 
+## `horizon-launcher instance launch`
+
+Show or set what runs around an instance's game: a shell command before it (the game starts only if it succeeds), a wrapper it runs through (`nice -n 5`), and environment variables ("NAME=value NAME2=value"). An empty value clears one.
+
+    horizon-launcher instance launch <INSTANCE>
+
+- `INSTANCE`
+- `--pre-launch`
+- `--wrapper`
+- `--env`
+
+MCP: `instance_launch`, needs `confirm: true`.
+
 ## `horizon-launcher instance shortcut`
 
 Put a shortcut on the desktop that plays an instance (`play --instance`): a .desktop file (also in the applications menu) on Linux, an app on macOS, a .lnk on Windows.
diff --git a/launcher/README.md b/launcher/README.md
index 963ddd187..41ff3c915 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -100,6 +100,14 @@ The opening, then Play ([clip](docs/opening.webm)):
   pack into the selected instance. A data pack is pointed at the world rows, and the Packs section
   and the world rows keep taking their own drops. A note in the corner says what happened.
   `horizon-launcher instance import <file>`.
+- **Launch options**: Home's Instance row has **Launch…**: per instance, a shell command run in its
+  folder before the game (the game starts only if it succeeds), a wrapper the game runs through
+  (`nice -n 5`), and environment variables (`NAME=value OTHER="two words"`), kept in
+  `instances.json` (`horizon_launcher::launch`). The game stays one process the launcher follows:
+  on Unix `/bin/sh` runs the command and then `exec`s the wrapper and the game, whose words pass
+  through `"$@"` untouched; on Windows `cmd /C` runs `<command> && <game>`. Both the window's Play
+  and `play` use them. `horizon-launcher instance launch <instance> [--pre-launch …]
+  [--wrapper …] [--env …]` (an MCP agent needs `confirm: true`: it sets commands Play runs).
 - **Desktop shortcut**: Home's Instance row has **Shortcut**: a shortcut on the desktop that plays
   the selected instance without opening the launcher (`horizon-launcher play --instance <id>`).
   A `.desktop` file on Linux (also put in the applications menu, and marked trusted with `gio`
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 00c21ec66..38150917f 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -198,6 +198,18 @@ enum InstanceCmd {
         #[arg(long)]
         out: Option<PathBuf>,
     },
+    /// Show or set what runs around an instance's game: a shell command before it (the game
+    /// starts only if it succeeds), a wrapper it runs through (`nice -n 5`), and environment
+    /// variables ("NAME=value NAME2=value"). An empty value clears one
+    Launch {
+        instance: String,
+        #[arg(long)]
+        pre_launch: Option<String>,
+        #[arg(long)]
+        wrapper: Option<String>,
+        #[arg(long)]
+        env: Option<String>,
+    },
     /// Put a shortcut on the desktop that plays an instance (`play --instance`): a .desktop
     /// file (also in the applications menu) on Linux, an app on macOS, a .lnk on Windows
     Shortcut {
@@ -938,7 +950,7 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
             }
             cmd.args(arg);
             let started = std::time::Instant::now();
-            let played = attached(cmd);
+            let played = attached(horizon_launcher::launch::wrap(cmd, &instance.launch));
             if let Err(e) = instances::record_play(&instance.id, started.elapsed()) {
                 eprintln!("Play time not saved: {e}");
             }
@@ -1836,6 +1848,45 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
             };
             changed(instances::edit(&instance, |m| m.version = pin)?)
         }
+        InstanceCmd::Launch {
+            instance,
+            pre_launch,
+            wrapper,
+            env,
+        } => {
+            use horizon_launcher::launch;
+            let env = env.as_deref().map(launch::parse_env).transpose()?;
+            let changing = pre_launch.is_some() || wrapper.is_some() || env.is_some();
+            let i = match changing {
+                false => instances::find(&instance)?,
+                true => instances::edit(&instance, |m| {
+                    if let Some(p) = pre_launch {
+                        m.launch.pre_launch = p.trim().to_string();
+                    }
+                    if let Some(w) = wrapper {
+                        m.launch.wrapper = w.trim().to_string();
+                    }
+                    if let Some(e) = env {
+                        m.launch.env = e;
+                    }
+                })?,
+            };
+            let l = &i.launch;
+            if as_json {
+                json(serde_json::json!({
+                    "instance": i.id, "pre_launch": l.pre_launch, "wrapper": l.wrapper, "env": l.env,
+                }));
+            } else {
+                println!(
+                    "{}: {}",
+                    i.name,
+                    l.summary().unwrap_or("nothing around the game".into())
+                );
+                println!("  pre-launch: {}", l.pre_launch);
+                println!("  wrapper:    {}", l.wrapper);
+                println!("  env:        {}", launch::env_line(&l.env));
+            }
+        }
         InstanceCmd::Shortcut { instance, remove } => {
             use horizon_launcher::shortcut;
             let i = match instance {
diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs
index fad614d0f..a6ddbfa34 100644
--- a/launcher/src/cli_tools.rs
+++ b/launcher/src/cli_tools.rs
@@ -32,6 +32,8 @@ pub const DESTRUCTIVE: &[&str] = &[
     "packs remove",
     "worlds datapack-remove",
     "unshare-log",
+    // It sets shell commands the next Play runs: the player says yes first.
+    "instance launch",
 ];
 
 /// Commands that send something or reach other people: only when the player asks.
diff --git a/launcher/src/import/tests.rs b/launcher/src/import/tests.rs
index dcbe0e548..1287b475e 100644
--- a/launcher/src/import/tests.rs
+++ b/launcher/src/import/tests.rs
@@ -48,6 +48,7 @@ fn maker(root: &Path) -> impl Fn(&str) -> Result<Instance, String> + '_ {
             version: None,
             played: Duration::ZERO,
             last_played: None,
+            launch: Default::default(),
         })
     }
 }
diff --git a/launcher/src/instances.rs b/launcher/src/instances.rs
index 34d9bb408..38951bf02 100644
--- a/launcher/src/instances.rs
+++ b/launcher/src/instances.rs
@@ -8,6 +8,7 @@
 //! launcher's data folder, so renaming one never moves a folder.
 use crate::backend;
 use crate::browser::horizon::pack as registry_pack;
+use crate::launch::Launch;
 use crate::modpacks;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
@@ -97,6 +98,9 @@ pub struct Meta {
     /// When its last run ended, in seconds since 1970.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub last_played: Option<u64>,
+    /// What runs around the game: a pre-launch command, a wrapper, variables (`launch`).
+    #[serde(default, skip_serializing_if = "Launch::is_empty")]
+    pub launch: Launch,
 }
 
 fn is_zero(n: &u64) -> bool {
@@ -140,6 +144,8 @@ pub struct Instance {
     pub version: Option<String>,
     pub played: Duration,
     pub last_played: Option<SystemTime>,
+    /// What runs around the game (`launch::wrap`).
+    pub launch: Launch,
 }
 
 impl Instance {
@@ -213,6 +219,7 @@ fn list_in(game_home: &Path, data: &Path) -> Vec<Instance> {
                 last_played: meta
                     .last_played
                     .map(|s| UNIX_EPOCH + Duration::from_secs(s)),
+                launch: meta.launch,
                 id,
                 kind,
                 work,
@@ -403,9 +410,13 @@ fn edit_in(
         if name.is_empty() {
             return Err("An instance needs a name.".into());
         }
-        if all
-            .iter()
-            .any(|i| i.id != instance.id && i.name.eq_ignore_ascii_case(name))
+        // Only a new name is checked: an import can share a name, and changing anything
+        // else about it must still work.
+        let renamed = !name.eq_ignore_ascii_case(&instance.name);
+        if renamed
+            && all
+                .iter()
+                .any(|i| i.id != instance.id && i.name.eq_ignore_ascii_case(name))
         {
             return Err(format!("There is already an instance called {name}."));
         }
diff --git a/launcher/src/instances/tests.rs b/launcher/src/instances/tests.rs
index 22f8f2b00..b2e2fe6fe 100644
--- a/launcher/src/instances/tests.rs
+++ b/launcher/src/instances/tests.rs
@@ -149,6 +149,18 @@ fn names_stay_unique_and_packs_are_not_copied() {
     // An empty group is no group.
     let grouped = edit_in(&home, &data, "Survival", |m| m.group = Some(" ".into())).unwrap();
     assert_eq!(grouped.group, None);
+    // An import named like an instance: both can still change everything but their names.
+    let mut store = Store::load(&data);
+    store.instances.entry(port.id.clone()).or_default().name = Some("Survival".into());
+    store.save(&data).unwrap();
+    let launched = edit_in(&home, &data, "survival", |m| {
+        m.launch.wrapper = "nice".into()
+    })
+    .unwrap();
+    assert_eq!(launched.launch.wrapper, "nice");
+    assert!(edit_in(&home, &data, "survival-2", |m| m.name =
+        Some("survival".into()))
+    .is_err());
     fs::remove_dir_all(&root).unwrap();
 }
 
diff --git a/launcher/src/instances_page.rs b/launcher/src/instances_page.rs
index 9af5051fe..b0777e9ba 100644
--- a/launcher/src/instances_page.rs
+++ b/launcher/src/instances_page.rs
@@ -551,9 +551,13 @@ impl Launcher {
             instance.clone(),
             instance.name.clone(),
         );
+        // Under the name, wrapping: six actions don't fit beside it at the window's narrowest.
         let actions = div()
             .flex()
+            .flex_wrap()
             .gap(px(8.))
+            .mt(px(6.))
+            .ml(px(-14.))
             .child(
                 button("instance-edit", "Edit…", Kind::Ghost, &t).on_click(cx.listener(
                     move |this, _: &ClickEvent, _, cx| {
@@ -590,6 +594,22 @@ impl Launcher {
                     cx.notify();
                 })),
             )
+            .child(
+                button(
+                    "instance-launch",
+                    if self.launch.is_some() {
+                        "Close launch"
+                    } else {
+                        "Launch…"
+                    },
+                    Kind::Ghost,
+                    &t,
+                )
+                .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                    this.toggle_launch();
+                    cx.notify();
+                })),
+            )
             .child(self.shortcut_button(&instance, cx))
             .child(
                 button("instance-folder", "Open folder", Kind::Ghost, &t).on_click(
@@ -619,9 +639,10 @@ impl Launcher {
                             ),
                     )
                     .children(self.shortcut_note(&instance.id))
+                    .child(actions)
                     .into_any_element(),
             ),
-            Some(actions.into_any_element()),
+            None,
             &t,
         ))
     }
diff --git a/launcher/src/launch.rs b/launcher/src/launch.rs
new file mode 100644
index 000000000..486f5f469
--- /dev/null
+++ b/launcher/src/launch.rs
@@ -0,0 +1,220 @@
+//! What runs around the game for one instance (`instances::Meta::launch`): a command run before
+//! it, a wrapper it runs through, and environment variables. All empty by default.
+//!
+//! [`wrap`] turns the game's command into one process that does all three, so the launcher still
+//! follows one program (its output, its exit, Stop):
+//!
+//! - Unix: `/bin/sh -c '(<pre-launch>) || exit; exec "$@"' horizon <wrapper…> <game> <args…>`.
+//!   The pre-launch command is the player's own shell line, run in the instance's folder; the
+//!   game's words go through `"$@"`, so they are never parsed by the shell. `exec` makes the
+//!   shell become the wrapper (or the game).
+//! - Windows: `cmd /D /S /C "<pre-launch> && <wrapper…> <game> <args…>"`, each word quoted.
+//!
+//! Without a pre-launch command the wrapper is the program itself, and no shell runs.
+use crate::backend::split_args;
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::ffi::{OsStr, OsString};
+use std::process::Command;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Launch {
+    /// A shell command run in the instance's folder before the game; the game starts only if it
+    /// succeeds.
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub pre_launch: String,
+    /// A command line the game runs through, such as `nice -n 5` (quotes group a word).
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub wrapper: String,
+    /// Environment variables for the game (and the two commands above).
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub env: BTreeMap<String, String>,
+}
+
+impl Launch {
+    pub fn is_empty(&self) -> bool {
+        self == &Launch::default()
+    }
+
+    /// What it does, in one line, or None when nothing.
+    pub fn summary(&self) -> Option<String> {
+        let mut parts = Vec::new();
+        if !self.pre_launch.trim().is_empty() {
+            parts.push(format!("runs {} first", self.pre_launch.trim()));
+        }
+        if !self.wrapper.trim().is_empty() {
+            parts.push(format!("through {}", self.wrapper.trim()));
+        }
+        match self.env.len() {
+            0 => {}
+            1 => parts.push("with 1 variable".into()),
+            n => parts.push(format!("with {n} variables")),
+        }
+        (!parts.is_empty()).then(|| parts.join(", "))
+    }
+}
+
+fn valid_key(key: &str) -> bool {
+    let mut chars = key.chars();
+    chars
+        .next()
+        .is_some_and(|c| c.is_ascii_alphabetic() || c == '_')
+        && chars.all(|c| c.is_ascii_alphanumeric() || c == '_')
+}
+
+/// `KEY=value KEY2="two words"` (one line, or one per line) as variables.
+pub fn parse_env(text: &str) -> Result<BTreeMap<String, String>, String> {
+    let mut env = BTreeMap::new();
+    for word in split_args(text) {
+        let (key, value) = word
+            .split_once('=')
+            .ok_or_else(|| format!("{word}: write it as NAME=value"))?;
+        if !valid_key(key) {
+            return Err(format!(
+                "{key}: a variable's name is letters, digits and _, not starting with a digit"
+            ));
+        }
+        env.insert(key.to_string(), value.to_string());
+    }
+    Ok(env)
+}
+
+/// The variables as [`parse_env`] reads them back.
+pub fn env_line(env: &BTreeMap<String, String>) -> String {
+    env.iter()
+        .map(
+            |(k, v)| match v.is_empty() || v.contains([' ', '"', '\'', '\\']) {
+                true => format!("{k}=\"{}\"", v.replace('\\', "\\\\").replace('"', "\\\"")),
+                false => format!("{k}={v}"),
+            },
+        )
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+/// The Unix script: the pre-launch command (in a subshell, so its `exit` doesn't end the script
+/// before the message), then the rest of the arguments as the program.
+fn script(pre_launch: &str) -> String {
+    format!(
+        "(\n{pre_launch}\n) || {{ s=$?; echo \"The pre-launch command failed (exit $s), so the \
+         game did not start.\" >&2; exit $s; }}\nexec \"$@\""
+    )
+}
+
+/// A word quoted for a Windows command line, as programs built with the C runtime read it back.
+fn windows_quote(word: &OsStr) -> String {
+    let word = word.to_string_lossy();
+    if !word.is_empty() && !word.contains([' ', '\t', '"']) {
+        return word.into_owned();
+    }
+    let mut out = String::from("\"");
+    let mut slashes = 0;
+    for c in word.chars() {
+        match c {
+            '\\' => slashes += 1,
+            '"' => {
+                out.extend(std::iter::repeat_n('\\', slashes * 2 + 1));
+                out.push('"');
+                slashes = 0;
+            }
+            c => {
+                out.extend(std::iter::repeat_n('\\', slashes));
+                out.push(c);
+                slashes = 0;
+            }
+        }
+    }
+    out.extend(std::iter::repeat_n('\\', slashes * 2));
+    out.push('"');
+    out
+}
+
+/// How [`wrap`] runs a command on each system, apart from the variables and the folder: the
+/// program and its arguments.
+#[derive(Debug, PartialEq, Eq)]
+pub enum Plan {
+    /// Run as given (`words[0]` is the program).
+    Direct(Vec<OsString>),
+    /// `/bin/sh -c <script> horizon <words…>`.
+    Shell {
+        script: String,
+        words: Vec<OsString>,
+    },
+    /// `cmd /D /S /C "<line>"`: the line as cmd reads it.
+    Cmd { line: String },
+}
+
+/// The plan for `words` (the game's program and arguments) with `launch`, on Windows or not.
+pub fn plan(launch: &Launch, words: Vec<OsString>, windows: bool) -> Plan {
+    let mut all: Vec<OsString> = split_args(&launch.wrapper)
+        .into_iter()
+        .map(OsString::from)
+        .collect();
+    all.extend(words);
+    let pre = launch.pre_launch.trim();
+    match (pre.is_empty(), windows) {
+        (true, _) => Plan::Direct(all),
+        (false, false) => Plan::Shell {
+            script: script(pre),
+            words: all,
+        },
+        (false, true) => Plan::Cmd {
+            line: format!(
+                "{pre} && {}",
+                all.iter()
+                    .map(|w| windows_quote(w))
+                    .collect::<Vec<_>>()
+                    .join(" ")
+            ),
+        },
+    }
+}
+
+/// The game's command run with `launch`: a new command with the same folder and variables,
+/// plus the instance's variables. Call it last, after every argument is added.
+pub fn wrap(cmd: Command, launch: &Launch) -> Command {
+    if launch.is_empty() {
+        return cmd;
+    }
+    let words: Vec<OsString> = std::iter::once(cmd.get_program().to_owned())
+        .chain(cmd.get_args().map(OsStr::to_owned))
+        .collect();
+    let mut out = match plan(launch, words, cfg!(windows)) {
+        Plan::Direct(words) => {
+            let mut c = Command::new(&words[0]);
+            c.args(&words[1..]);
+            c
+        }
+        Plan::Shell { script, words } => {
+            let mut c = Command::new("/bin/sh");
+            c.arg("-c").arg(script).arg("horizon").args(words);
+            c
+        }
+        Plan::Cmd { line } => {
+            let mut c = Command::new("cmd.exe");
+            #[cfg(windows)]
+            {
+                use std::os::windows::process::CommandExt;
+                c.raw_arg(format!("/D /S /C \"{line}\""));
+            }
+            #[cfg(not(windows))]
+            c.args(["/D", "/S", "/C", &line]);
+            c
+        }
+    };
+    if let Some(dir) = cmd.get_current_dir() {
+        out.current_dir(dir);
+    }
+    for (key, value) in cmd.get_envs() {
+        match value {
+            Some(value) => out.env(key, value),
+            None => out.env_remove(key),
+        };
+    }
+    out.envs(&launch.env);
+    out
+}
+
+#[cfg(test)]
+#[path = "launch/tests.rs"]
+mod tests;
diff --git a/launcher/src/launch/tests.rs b/launcher/src/launch/tests.rs
new file mode 100644
index 000000000..32d29cdec
--- /dev/null
+++ b/launcher/src/launch/tests.rs
@@ -0,0 +1,143 @@
+use super::*;
+
+fn os(words: &[&str]) -> Vec<OsString> {
+    words.iter().map(OsString::from).collect()
+}
+
+#[test]
+fn variables_are_read_and_written_back() {
+    let env = parse_env("MANGOHUD=1  DRI_PRIME=1\nNAME=\"two words\" EMPTY=").unwrap();
+    assert_eq!(env["MANGOHUD"], "1");
+    assert_eq!(env["NAME"], "two words");
+    assert_eq!(env["EMPTY"], "");
+    assert_eq!(parse_env(&env_line(&env)).unwrap(), env);
+    assert_eq!(
+        env_line(&env),
+        "DRI_PRIME=1 EMPTY=\"\" MANGOHUD=1 NAME=\"two words\""
+    );
+    assert!(parse_env("JUSTANAME").unwrap_err().contains("NAME=value"));
+    assert!(parse_env("1X=2")
+        .unwrap_err()
+        .contains("letters, digits and _"));
+    assert!(parse_env("").unwrap().is_empty());
+}
+
+#[test]
+fn a_summary_says_what_runs() {
+    assert_eq!(Launch::default().summary(), None);
+    let launch = Launch {
+        pre_launch: "./sync.sh".into(),
+        wrapper: "nice -n 5".into(),
+        env: parse_env("A=1 B=2").unwrap(),
+    };
+    assert_eq!(
+        launch.summary().unwrap(),
+        "runs ./sync.sh first, through nice -n 5, with 2 variables"
+    );
+}
+
+#[test]
+fn each_system_gets_its_plan() {
+    let game = os(&["/opt/horizon-client", "--world", "My World"]);
+    let wrapper = Launch {
+        wrapper: "nice -n 5".into(),
+        ..Launch::default()
+    };
+    assert_eq!(
+        plan(&wrapper, game.clone(), false),
+        Plan::Direct(os(&[
+            "nice",
+            "-n",
+            "5",
+            "/opt/horizon-client",
+            "--world",
+            "My World"
+        ]))
+    );
+    let both = Launch {
+        pre_launch: "echo hi".into(),
+        ..wrapper.clone()
+    };
+    let Plan::Shell { script, words } = plan(&both, game.clone(), false) else {
+        panic!()
+    };
+    assert!(script.starts_with("(\necho hi\n) || "));
+    assert!(script.ends_with("\nexec \"$@\""));
+    assert_eq!(words[0], "nice");
+    assert_eq!(
+        plan(
+            &both,
+            os(&[r"C:\Horizon\horizon-client.exe", "--world", "My World"]),
+            true
+        ),
+        Plan::Cmd {
+            line: r#"echo hi && nice -n 5 C:\Horizon\horizon-client.exe --world "My World""#.into()
+        }
+    );
+}
+
+#[test]
+fn windows_words_are_quoted_as_the_c_runtime_reads_them() {
+    let q = |w: &str| windows_quote(OsStr::new(w));
+    assert_eq!(q("plain"), "plain");
+    assert_eq!(q("two words"), "\"two words\"");
+    assert_eq!(q(""), "\"\"");
+    assert_eq!(q(r#"say "hi""#), r#""say \"hi\"""#);
+    assert_eq!(q(r"C:\My Folder\"), r#""C:\My Folder\\""#);
+}
+
+#[test]
+fn nothing_to_add_leaves_the_command_as_it_is() {
+    let mut cmd = Command::new("/opt/game");
+    cmd.arg("--x").env("A", "1");
+    let out = wrap(cmd, &Launch::default());
+    assert_eq!(out.get_program(), "/opt/game");
+    assert_eq!(out.get_args().collect::<Vec<_>>(), ["--x"]);
+}
+
+#[cfg(unix)]
+#[test]
+fn the_wrapped_game_runs_after_its_pre_launch_command_in_its_folder() {
+    let dir = std::env::temp_dir().join(format!("horizon-launch-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let mut game = Command::new("/bin/sh");
+    // The "game" prints its words and two variables: one from the launcher, one the instance's.
+    game.args([
+        "-c",
+        "echo \"$1|$2|$FROM_LAUNCHER|$FROM_INSTANCE\"",
+        "game",
+        "a b",
+        "$HOME",
+    ])
+    .current_dir(&dir)
+    .env("FROM_LAUNCHER", "yes");
+    let launch = Launch {
+        pre_launch: "echo ran > pre.txt".into(),
+        wrapper: "/usr/bin/env WRAPPED=1".into(),
+        env: parse_env("FROM_INSTANCE=\"it works\"").unwrap(),
+    };
+    let out = wrap(game, &launch).output().unwrap();
+    assert!(out.status.success(), "{out:?}");
+    assert_eq!(
+        String::from_utf8_lossy(&out.stdout),
+        "a b|$HOME|yes|it works\n"
+    );
+    assert_eq!(
+        std::fs::read_to_string(dir.join("pre.txt")).unwrap(),
+        "ran\n"
+    );
+
+    let failing = Launch {
+        pre_launch: "exit 3".into(),
+        ..Launch::default()
+    };
+    let mut game = Command::new("/bin/sh");
+    game.args(["-c", "echo started > started.txt"])
+        .current_dir(&dir);
+    let out = wrap(game, &failing).output().unwrap();
+    assert_eq!(out.status.code(), Some(3));
+    assert!(String::from_utf8_lossy(&out.stderr).contains("pre-launch command failed (exit 3)"));
+    assert!(!dir.join("started.txt").exists());
+    std::fs::remove_dir_all(&dir).unwrap();
+}
diff --git a/launcher/src/launch_page.rs b/launcher/src/launch_page.rs
new file mode 100644
index 000000000..fa8311873
--- /dev/null
+++ b/launcher/src/launch_page.rs
@@ -0,0 +1,137 @@
+//! Launch… on Home's Instance row: what runs around the selected instance's game
+//! (`horizon_launcher::launch`): a command before it, a wrapper, and environment variables.
+use super::servers_page::Field;
+use super::*;
+use horizon_launcher::launch;
+
+pub(super) struct LaunchPanel {
+    /// The instance it is for: picking another closes it.
+    instance: String,
+    /// What Save did, or why not.
+    saved: Option<Result<String, String>>,
+}
+
+impl Launcher {
+    pub(super) fn toggle_launch(&mut self) {
+        if self.launch.take().is_some() {
+            return;
+        }
+        let Some(i) = self.selected_instance().cloned() else {
+            return;
+        };
+        *self.servers.text(Field::PreLaunch) = i.launch.pre_launch.clone();
+        *self.servers.text(Field::Wrapper) = i.launch.wrapper.clone();
+        *self.servers.text(Field::LaunchEnv) = launch::env_line(&i.launch.env);
+        self.launch = Some(LaunchPanel {
+            instance: i.id,
+            saved: None,
+        });
+    }
+
+    pub(super) fn save_launch(&mut self) {
+        let Some(id) = self.launch.as_ref().map(|p| p.instance.clone()) else {
+            return;
+        };
+        let pre = self.servers.value(Field::PreLaunch).trim().to_string();
+        let wrapper = self.servers.value(Field::Wrapper).trim().to_string();
+        let saved = launch::parse_env(self.servers.value(Field::LaunchEnv)).and_then(|env| {
+            instances::edit(&id, |m| {
+                m.launch = launch::Launch {
+                    pre_launch: pre,
+                    wrapper,
+                    env,
+                }
+            })
+        });
+        let saved = saved.map(|i| {
+            let said = match i.launch.summary() {
+                Some(what) => format!("Saved: the next Play {what}."),
+                None => "Saved: nothing runs around the game.".to_string(),
+            };
+            self.reload_instances();
+            said
+        });
+        if let Some(p) = &mut self.launch {
+            p.saved = Some(saved);
+        }
+    }
+
+    /// The panel under the Instance row, while open for the selected instance.
+    pub(super) fn launch_panel(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let selected = self.selected_instance().map(|i| i.id.clone());
+        if self.launch.as_ref().map(|p| &p.instance) != selected.as_ref() {
+            self.launch = None;
+        }
+        let saved = self.launch.as_ref()?.saved.clone();
+        let row = |this: &mut Self,
+                   cx: &mut Context<Self>,
+                   label: &'static str,
+                   field: Field,
+                   placeholder: &'static str,
+                   about: &'static str| {
+            div()
+                .flex()
+                .flex_col()
+                .gap(px(6.))
+                .child(caps(label).text_color(t.muted))
+                .child(this.field(field, placeholder, 520., cx))
+                .child(text(theme::CAPTION).text_color(t.muted).child(about))
+        };
+        let pre = row(
+            self,
+            cx,
+            "Before the game",
+            Field::PreLaunch,
+            "For example ./backup.sh",
+            "A shell command, run in the instance's folder. The game starts only if it succeeds.",
+        );
+        let wrapper = row(
+            self,
+            cx,
+            "Run the game through",
+            Field::Wrapper,
+            "For example nice -n 5",
+            "A program and its arguments; the game's command line goes after them.",
+        );
+        let env = row(
+            self,
+            cx,
+            "Environment variables",
+            Field::LaunchEnv,
+            "For example NAME=value OTHER=\"two words\"",
+            "For the game and both commands above.",
+        );
+        let save = button("launch-save", "Save", Kind::Secondary, &t).on_click(cx.listener(
+            |this, _: &ClickEvent, _, cx| {
+                this.save_launch();
+                cx.notify();
+            },
+        ));
+        let result = saved.map(|s| match s {
+            Ok(said) => text(theme::CAPTION).text_color(t.muted).child(said),
+            Err(e) => text(theme::CAPTION).text_color(t.danger).child(e),
+        });
+        Some(
+            plate(&t)
+                .flex()
+                .flex_col()
+                .gap(px(14.))
+                .px(px(14.))
+                .py(px(12.))
+                .ml(px(40.))
+                .child(caps("When it starts").text_color(t.muted))
+                .child(pre)
+                .child(wrapper)
+                .child(env)
+                .child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .gap(px(12.))
+                        .child(save)
+                        .children(result),
+                ),
+        )
+    }
+}
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index ea896aa21..96951905f 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -13,6 +13,7 @@ pub mod game_log;
 pub mod heads;
 pub mod import;
 pub mod instances;
+pub mod launch;
 pub mod modpacks;
 pub mod mojang;
 pub mod packs;
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 257b83226..90475305b 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -18,6 +18,7 @@ mod game_tools;
 mod import_page;
 mod instances_page;
 mod internet;
+mod launch_page;
 mod markdown;
 mod mcp;
 mod modpacks_page;
@@ -247,6 +248,7 @@ struct Launcher {
     game_packs: packs_page::Packs,
     world_packs: datapacks_page::WorldPacks,
     export: Option<export_page::ExportPanel>,
+    launch: Option<launch_page::LaunchPanel>,
     importing: import_page::Importing,
     console: console_page::Console,
     /// What the window did when the game started (`while_playing.rs`).
@@ -418,6 +420,7 @@ impl Launcher {
             game_packs: packs_page::Packs::default(),
             world_packs: datapacks_page::WorldPacks::default(),
             export: None,
+            launch: None,
             importing: Default::default(),
             console: Default::default(),
             aside: while_playing::Aside::new(window.window_handle()),
@@ -609,6 +612,14 @@ impl Launcher {
                             cmd.arg(flag).arg(value);
                         }
                         backend::append_game_args(&mut cmd);
+                        // Last, around every argument: the instance's pre-launch command,
+                        // wrapper and variables.
+                        let launch = run
+                            .as_ref()
+                            .and_then(|id| instances::list().into_iter().find(|i| &i.id == id))
+                            .map(|i| i.launch)
+                            .unwrap_or_default();
+                        let cmd = horizon_launcher::launch::wrap(cmd, &launch);
                         self.client_home = cmd.get_current_dir().map(|d| d.to_path_buf());
                         match backend::spawn(Job::Client, cmd, self.tx.clone()) {
                             Ok(r) => {
@@ -2129,6 +2140,7 @@ impl Launcher {
             .child(section_title("Ready to play", "check", &t).mb(px(12.)))
             .children(self.instance_row(1, cx))
             .children(self.export_panel(cx))
+            .children(self.launch_panel(cx))
             .child(index_row(
                 2,
                 "Resources",
diff --git a/launcher/src/servers_page.rs b/launcher/src/servers_page.rs
index b9a82b938..ae33e6cc0 100644
--- a/launcher/src/servers_page.rs
+++ b/launcher/src/servers_page.rs
@@ -40,10 +40,14 @@ pub(super) enum Field {
     ServerAddress,
     /// Home's Console's search (`console_page.rs`).
     ConsoleSearch,
+    /// The Launch panel's (`launch_page.rs`).
+    PreLaunch,
+    Wrapper,
+    LaunchEnv,
 }
 
 impl Field {
-    const ALL: [Field; 14] = [
+    const ALL: [Field; 17] = [
         Field::Name,
         Field::Seed,
         Field::Players,
@@ -58,6 +62,9 @@ impl Field {
         Field::ServerName,
         Field::ServerAddress,
         Field::ConsoleSearch,
+        Field::PreLaunch,
+        Field::Wrapper,
+        Field::LaunchEnv,
     ];
 }
 
@@ -1035,6 +1042,7 @@ impl Launcher {
             Field::Token => self.save_token(),
             Field::Email => self.invite_friend(),
             Field::InstanceName | Field::InstanceGroup | Field::ConsoleSearch => {}
+            Field::PreLaunch | Field::Wrapper | Field::LaunchEnv => self.save_launch(),
             Field::ServerName | Field::ServerAddress => self.add_server(),
         }
     }

From 9bc8e12ad147356b16213045c643c6becf7983fd Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:28:42 +0100
Subject: [PATCH 427/475] launcher: GameMode, MangoHud and dedicated GPU
 switches on Linux

The Launch panel shows, per instance, a switch for each one this computer
has: GameMode when gamemoderun is on the PATH, MangoHud when mangohud is,
and the dedicated graphics card with two cards (DRI_PRIME, or NVIDIA's
render offload variables with its driver). They wrap the game like the
wrapper does, outermost first, and do nothing where the tool is gone.
CLI and MCP: instance launch --gamemode/--mangohud/--dedicated-gpu.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md    |   5 +-
 launcher/README.md           |   7 ++
 launcher/src/cli.rs          |  64 +++++++++++++++-
 launcher/src/launch.rs       | 140 +++++++++++++++++++++++++++++++++--
 launcher/src/launch/tests.rs |  58 ++++++++++++++-
 launcher/src/launch_page.rs  | 100 +++++++++++++++++++++++++
 6 files changed, 361 insertions(+), 13 deletions(-)

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 41108a86e..35de188f9 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -366,7 +366,7 @@ MCP: `instance_export`.
 
 ## `horizon-launcher instance launch`
 
-Show or set what runs around an instance's game: a shell command before it (the game starts only if it succeeds), a wrapper it runs through (`nice -n 5`), and environment variables ("NAME=value NAME2=value"). An empty value clears one.
+Show or set what runs around an instance's game: a shell command before it (the game starts only if it succeeds), a wrapper it runs through (`nice -n 5`), and environment variables ("NAME=value NAME2=value"). An empty value clears one. On Linux, also GameMode, MangoHud and the dedicated graphics card, when the computer has them.
 
     horizon-launcher instance launch <INSTANCE>
 
@@ -374,6 +374,9 @@ Show or set what runs around an instance's game: a shell command before it (the
 - `--pre-launch`
 - `--wrapper`
 - `--env`
+- `--gamemode`: Linux: run it through GameMode (gamemoderun), on or off
+- `--mangohud`: Linux: MangoHud's overlay, on or off
+- `--dedicated-gpu`: Linux: the dedicated graphics card (DRI_PRIME, or NVIDIA's offload), on or off
 
 MCP: `instance_launch`, needs `confirm: true`.
 
diff --git a/launcher/README.md b/launcher/README.md
index 41ff3c915..104285c5a 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -108,6 +108,13 @@ The opening, then Play ([clip](docs/opening.webm)):
   through `"$@"` untouched; on Windows `cmd /C` runs `<command> && <game>`. Both the window's Play
   and `play` use them. `horizon-launcher instance launch <instance> [--pre-launch …]
   [--wrapper …] [--env …]` (an MCP agent needs `confirm: true`: it sets commands Play runs).
+  On Linux the panel also has switches for what the computer has: **GameMode** (`gamemoderun`
+  on the PATH), **MangoHud** (`mangohud`), and, with two graphics cards under
+  `/sys/class/drm`, the **dedicated graphics card** (`DRI_PRIME=1`, or NVIDIA's
+  `__NV_PRIME_RENDER_OFFLOAD`, `__VK_LAYER_NV_optimus` and `__GLX_VENDOR_LIBRARY_NAME` when its
+  driver is loaded). A switch whose tool is gone does nothing. `instance launch --gamemode
+  on|off --mangohud on|off --dedicated-gpu on|off`; `HORIZON_LAUNCHER_LINUX_TOOLS` makes any
+  system show them, for tests.
 - **Desktop shortcut**: Home's Instance row has **Shortcut**: a shortcut on the desktop that plays
   the selected instance without opening the launcher (`horizon-launcher play --instance <id>`).
   A `.desktop` file on Linux (also put in the applications menu, and marked trusted with `gio`
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 38150917f..e88144fe3 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -200,7 +200,8 @@ enum InstanceCmd {
     },
     /// Show or set what runs around an instance's game: a shell command before it (the game
     /// starts only if it succeeds), a wrapper it runs through (`nice -n 5`), and environment
-    /// variables ("NAME=value NAME2=value"). An empty value clears one
+    /// variables ("NAME=value NAME2=value"). An empty value clears one. On Linux, also GameMode,
+    /// MangoHud and the dedicated graphics card, when the computer has them
     Launch {
         instance: String,
         #[arg(long)]
@@ -209,6 +210,15 @@ enum InstanceCmd {
         wrapper: Option<String>,
         #[arg(long)]
         env: Option<String>,
+        /// Linux: run it through GameMode (gamemoderun), on or off
+        #[arg(long)]
+        gamemode: Option<String>,
+        /// Linux: MangoHud's overlay, on or off
+        #[arg(long)]
+        mangohud: Option<String>,
+        /// Linux: the dedicated graphics card (DRI_PRIME, or NVIDIA's offload), on or off
+        #[arg(long)]
+        dedicated_gpu: Option<String>,
     },
     /// Put a shortcut on the desktop that plays an instance (`play --instance`): a .desktop
     /// file (also in the applications menu) on Linux, an app on macOS, a .lnk on Windows
@@ -1853,10 +1863,37 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
             pre_launch,
             wrapper,
             env,
+            gamemode,
+            mangohud,
+            dedicated_gpu,
         } => {
             use horizon_launcher::launch;
             let env = env.as_deref().map(launch::parse_env).transpose()?;
-            let changing = pre_launch.is_some() || wrapper.is_some() || env.is_some();
+            let [gamemode, mangohud, dedicated_gpu] =
+                [gamemode, mangohud, dedicated_gpu].map(|v| v.as_deref().map(on_off));
+            let [gamemode, mangohud, dedicated_gpu] = [
+                gamemode.transpose()?,
+                mangohud.transpose()?,
+                dedicated_gpu.transpose()?,
+            ];
+            let found = launch::Found::here();
+            for (on, has, name) in [
+                (gamemode, found.gamemode, "GameMode (gamemoderun)"),
+                (mangohud, found.mangohud, "MangoHud"),
+                (dedicated_gpu, found.two_gpus, "A second graphics card"),
+            ] {
+                if on == Some(true) && !has {
+                    eprintln!(
+                        "{name} isn't on this computer: the switch does nothing until it is."
+                    );
+                }
+            }
+            let changing = pre_launch.is_some()
+                || wrapper.is_some()
+                || env.is_some()
+                || gamemode.is_some()
+                || mangohud.is_some()
+                || dedicated_gpu.is_some();
             let i = match changing {
                 false => instances::find(&instance)?,
                 true => instances::edit(&instance, |m| {
@@ -1869,12 +1906,26 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
                     if let Some(e) = env {
                         m.launch.env = e;
                     }
+                    if let Some(on) = gamemode {
+                        m.launch.gamemode = on;
+                    }
+                    if let Some(on) = mangohud {
+                        m.launch.mangohud = on;
+                    }
+                    if let Some(on) = dedicated_gpu {
+                        m.launch.dedicated_gpu = on;
+                    }
                 })?,
             };
             let l = &i.launch;
             if as_json {
                 json(serde_json::json!({
                     "instance": i.id, "pre_launch": l.pre_launch, "wrapper": l.wrapper, "env": l.env,
+                    "gamemode": l.gamemode, "mangohud": l.mangohud, "dedicated_gpu": l.dedicated_gpu,
+                    "found": {
+                        "gamemode": found.gamemode, "mangohud": found.mangohud,
+                        "two_gpus": found.two_gpus, "nvidia": found.nvidia,
+                    },
                 }));
             } else {
                 println!(
@@ -1885,6 +1936,15 @@ fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
                 println!("  pre-launch: {}", l.pre_launch);
                 println!("  wrapper:    {}", l.wrapper);
                 println!("  env:        {}", launch::env_line(&l.env));
+                let yes = |b: bool| if b { "on" } else { "off" };
+                for (name, on, has) in [
+                    ("gamemode:", l.gamemode, found.gamemode),
+                    ("mangohud:", l.mangohud, found.mangohud),
+                    ("gpu:", l.dedicated_gpu, found.two_gpus),
+                ] {
+                    let note = if has { "" } else { " (not on this computer)" };
+                    println!("  {name:<11} {}{note}", yes(on));
+                }
             }
         }
         InstanceCmd::Shortcut { instance, remove } => {
diff --git a/launcher/src/launch.rs b/launcher/src/launch.rs
index 486f5f469..0219c88ba 100644
--- a/launcher/src/launch.rs
+++ b/launcher/src/launch.rs
@@ -29,6 +29,118 @@ pub struct Launch {
     /// Environment variables for the game (and the two commands above).
     #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
     pub env: BTreeMap<String, String>,
+    /// Linux: run the game through Feral's GameMode (`gamemoderun`), when it is installed.
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub gamemode: bool,
+    /// Linux: MangoHud's overlay (`mangohud`), when it is installed.
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub mangohud: bool,
+    /// Linux: the dedicated graphics card of a computer with two (PRIME render offload).
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub dedicated_gpu: bool,
+}
+
+fn is_false(b: &bool) -> bool {
+    !*b
+}
+
+/// What this Linux computer has for the three switches. Elsewhere, nothing.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct Found {
+    pub gamemode: bool,
+    pub mangohud: bool,
+    /// More than one graphics card.
+    pub two_gpus: bool,
+    /// NVIDIA's own driver is loaded: offload asks for it, not Mesa.
+    pub nvidia: bool,
+}
+
+/// `HORIZON_LAUNCHER_LINUX_TOOLS=gamemode,mangohud,gpu,nvidia`: what [`Found::here`] says is
+/// installed, on any system (for tests and screenshots).
+pub const TOOLS_ENV: &str = "HORIZON_LAUNCHER_LINUX_TOOLS";
+
+fn on_path(program: &str) -> bool {
+    std::env::var_os("PATH").is_some_and(|path| {
+        std::env::split_paths(&path).any(|dir| {
+            let file = dir.join(program);
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::PermissionsExt;
+                file.metadata()
+                    .is_ok_and(|m| m.is_file() && m.permissions().mode() & 0o111 != 0)
+            }
+            #[cfg(not(unix))]
+            file.is_file()
+        })
+    })
+}
+
+impl Found {
+    /// What is installed here: on Linux, `gamemoderun` and `mangohud` on the PATH, the cards
+    /// under `/sys/class/drm`, and `/proc/driver/nvidia`.
+    pub fn here() -> Found {
+        if let Some(list) = std::env::var_os(TOOLS_ENV) {
+            let list = list.to_string_lossy();
+            let has = |n: &str| list.split(',').any(|w| w.trim() == n);
+            return Found {
+                gamemode: has("gamemode"),
+                mangohud: has("mangohud"),
+                two_gpus: has("gpu"),
+                nvidia: has("nvidia"),
+            };
+        }
+        if !cfg!(target_os = "linux") {
+            return Found::default();
+        }
+        let cards = std::fs::read_dir("/sys/class/drm")
+            .into_iter()
+            .flatten()
+            .flatten()
+            .filter(|e| {
+                let name = e.file_name();
+                let name = name.to_string_lossy();
+                name.strip_prefix("card")
+                    .is_some_and(|n| !n.is_empty() && n.chars().all(|c| c.is_ascii_digit()))
+            })
+            .count();
+        Found {
+            gamemode: on_path("gamemoderun"),
+            mangohud: on_path("mangohud"),
+            two_gpus: cards >= 2,
+            nvidia: std::path::Path::new("/proc/driver/nvidia/gpus").is_dir(),
+        }
+    }
+
+    /// Whether any switch can be shown.
+    pub fn any(&self) -> bool {
+        self.gamemode || self.mangohud || self.two_gpus
+    }
+}
+
+/// The programs the switches put before the game (and the player's wrapper), outermost first.
+fn switch_programs(launch: &Launch, found: &Found) -> Vec<OsString> {
+    let mut out = Vec::new();
+    if launch.gamemode && found.gamemode {
+        out.push("gamemoderun".into());
+    }
+    if launch.mangohud && found.mangohud {
+        out.push("mangohud".into());
+    }
+    out
+}
+
+/// The variables the dedicated GPU switch sets: NVIDIA's offload variables with its driver,
+/// else Mesa's `DRI_PRIME`. The player's own variables come after and win.
+pub fn switch_env(launch: &Launch, found: &Found) -> Vec<(&'static str, &'static str)> {
+    match (launch.dedicated_gpu && found.two_gpus, found.nvidia) {
+        (false, _) => vec![],
+        (true, true) => vec![
+            ("__NV_PRIME_RENDER_OFFLOAD", "1"),
+            ("__VK_LAYER_NV_optimus", "NVIDIA_only"),
+            ("__GLX_VENDOR_LIBRARY_NAME", "nvidia"),
+        ],
+        (true, false) => vec![("DRI_PRIME", "1")],
+    }
 }
 
 impl Launch {
@@ -45,6 +157,15 @@ impl Launch {
         if !self.wrapper.trim().is_empty() {
             parts.push(format!("through {}", self.wrapper.trim()));
         }
+        if self.gamemode {
+            parts.push("with GameMode".into());
+        }
+        if self.mangohud {
+            parts.push("with MangoHud".into());
+        }
+        if self.dedicated_gpu {
+            parts.push("on the dedicated GPU".into());
+        }
         match self.env.len() {
             0 => {}
             1 => parts.push("with 1 variable".into()),
@@ -144,12 +265,11 @@ pub enum Plan {
     Cmd { line: String },
 }
 
-/// The plan for `words` (the game's program and arguments) with `launch`, on Windows or not.
-pub fn plan(launch: &Launch, words: Vec<OsString>, windows: bool) -> Plan {
-    let mut all: Vec<OsString> = split_args(&launch.wrapper)
-        .into_iter()
-        .map(OsString::from)
-        .collect();
+/// The plan for `words` (the game's program and arguments) with `launch`, on Windows or not,
+/// with what the computer has for the switches.
+pub fn plan(launch: &Launch, words: Vec<OsString>, windows: bool, found: &Found) -> Plan {
+    let mut all = switch_programs(launch, found);
+    all.extend(split_args(&launch.wrapper).into_iter().map(OsString::from));
     all.extend(words);
     let pre = launch.pre_launch.trim();
     match (pre.is_empty(), windows) {
@@ -179,7 +299,12 @@ pub fn wrap(cmd: Command, launch: &Launch) -> Command {
     let words: Vec<OsString> = std::iter::once(cmd.get_program().to_owned())
         .chain(cmd.get_args().map(OsStr::to_owned))
         .collect();
-    let mut out = match plan(launch, words, cfg!(windows)) {
+    // The override only shows the switches: they act on Linux.
+    let found = match cfg!(target_os = "linux") {
+        true => Found::here(),
+        false => Found::default(),
+    };
+    let mut out = match plan(launch, words, cfg!(windows), &found) {
         Plan::Direct(words) => {
             let mut c = Command::new(&words[0]);
             c.args(&words[1..]);
@@ -211,6 +336,7 @@ pub fn wrap(cmd: Command, launch: &Launch) -> Command {
             None => out.env_remove(key),
         };
     }
+    out.envs(switch_env(launch, &found));
     out.envs(&launch.env);
     out
 }
diff --git a/launcher/src/launch/tests.rs b/launcher/src/launch/tests.rs
index 32d29cdec..3940488b6 100644
--- a/launcher/src/launch/tests.rs
+++ b/launcher/src/launch/tests.rs
@@ -29,6 +29,7 @@ fn a_summary_says_what_runs() {
         pre_launch: "./sync.sh".into(),
         wrapper: "nice -n 5".into(),
         env: parse_env("A=1 B=2").unwrap(),
+        ..Launch::default()
     };
     assert_eq!(
         launch.summary().unwrap(),
@@ -44,7 +45,7 @@ fn each_system_gets_its_plan() {
         ..Launch::default()
     };
     assert_eq!(
-        plan(&wrapper, game.clone(), false),
+        plan(&wrapper, game.clone(), false, &Found::default()),
         Plan::Direct(os(&[
             "nice",
             "-n",
@@ -58,7 +59,7 @@ fn each_system_gets_its_plan() {
         pre_launch: "echo hi".into(),
         ..wrapper.clone()
     };
-    let Plan::Shell { script, words } = plan(&both, game.clone(), false) else {
+    let Plan::Shell { script, words } = plan(&both, game.clone(), false, &Found::default()) else {
         panic!()
     };
     assert!(script.starts_with("(\necho hi\n) || "));
@@ -68,7 +69,8 @@ fn each_system_gets_its_plan() {
         plan(
             &both,
             os(&[r"C:\Horizon\horizon-client.exe", "--world", "My World"]),
-            true
+            true,
+            &Found::default()
         ),
         Plan::Cmd {
             line: r#"echo hi && nice -n 5 C:\Horizon\horizon-client.exe --world "My World""#.into()
@@ -116,6 +118,7 @@ fn the_wrapped_game_runs_after_its_pre_launch_command_in_its_folder() {
         pre_launch: "echo ran > pre.txt".into(),
         wrapper: "/usr/bin/env WRAPPED=1".into(),
         env: parse_env("FROM_INSTANCE=\"it works\"").unwrap(),
+        ..Launch::default()
     };
     let out = wrap(game, &launch).output().unwrap();
     assert!(out.status.success(), "{out:?}");
@@ -141,3 +144,52 @@ fn the_wrapped_game_runs_after_its_pre_launch_command_in_its_folder() {
     assert!(!dir.join("started.txt").exists());
     std::fs::remove_dir_all(&dir).unwrap();
 }
+
+#[test]
+fn the_linux_switches_act_only_where_their_tools_are() {
+    let all = Found {
+        gamemode: true,
+        mangohud: true,
+        two_gpus: true,
+        nvidia: false,
+    };
+    let launch = Launch {
+        wrapper: "nice".into(),
+        gamemode: true,
+        mangohud: true,
+        dedicated_gpu: true,
+        ..Launch::default()
+    };
+    assert_eq!(
+        plan(&launch, os(&["game"]), false, &all),
+        Plan::Direct(os(&["gamemoderun", "mangohud", "nice", "game"]))
+    );
+    assert_eq!(switch_env(&launch, &all), [("DRI_PRIME", "1")]);
+    let nvidia = Found {
+        nvidia: true,
+        ..all
+    };
+    assert_eq!(
+        switch_env(&launch, &nvidia),
+        [
+            ("__NV_PRIME_RENDER_OFFLOAD", "1"),
+            ("__VK_LAYER_NV_optimus", "NVIDIA_only"),
+            ("__GLX_VENDOR_LIBRARY_NAME", "nvidia")
+        ]
+    );
+    // Not installed (or not Linux): switched on, but nothing is added.
+    let none = Found::default();
+    assert_eq!(
+        plan(&launch, os(&["game"]), false, &none),
+        Plan::Direct(os(&["nice", "game"]))
+    );
+    assert!(switch_env(&launch, &none).is_empty());
+    assert!(!none.any() && all.any());
+    assert_eq!(
+        launch.summary().unwrap(),
+        "through nice, with GameMode, with MangoHud, on the dedicated GPU"
+    );
+    // Off switches aren't written.
+    let text = serde_json::to_string(&Launch::default()).unwrap();
+    assert_eq!(text, "{}");
+}
diff --git a/launcher/src/launch_page.rs b/launcher/src/launch_page.rs
index fa8311873..4cfad986a 100644
--- a/launcher/src/launch_page.rs
+++ b/launcher/src/launch_page.rs
@@ -9,6 +9,16 @@ pub(super) struct LaunchPanel {
     instance: String,
     /// What Save did, or why not.
     saved: Option<Result<String, String>>,
+    /// What this computer has for the Linux switches, looked at when the panel opens.
+    found: launch::Found,
+}
+
+/// A Linux switch: which one, its label, and what it does.
+#[derive(Clone, Copy)]
+enum Toggle {
+    GameMode,
+    MangoHud,
+    Gpu,
 }
 
 impl Launcher {
@@ -25,6 +35,7 @@ impl Launcher {
         self.launch = Some(LaunchPanel {
             instance: i.id,
             saved: None,
+            found: launch::Found::here(),
         });
     }
 
@@ -40,6 +51,7 @@ impl Launcher {
                     pre_launch: pre,
                     wrapper,
                     env,
+                    ..m.launch.clone()
                 }
             })
         });
@@ -56,6 +68,93 @@ impl Launcher {
         }
     }
 
+    /// Flips a Linux switch, saved at once.
+    fn flip(&mut self, toggle: Toggle) {
+        let Some(panel) = &mut self.launch else {
+            return;
+        };
+        let saved = instances::edit(&panel.instance, |m| {
+            let on = match toggle {
+                Toggle::GameMode => &mut m.launch.gamemode,
+                Toggle::MangoHud => &mut m.launch.mangohud,
+                Toggle::Gpu => &mut m.launch.dedicated_gpu,
+            };
+            *on = !*on;
+        });
+        panel.saved = Some(saved.map(|i| match i.launch.summary() {
+            Some(what) => format!("Saved: the next Play {what}."),
+            None => "Saved: nothing runs around the game.".to_string(),
+        }));
+        self.reload_instances();
+    }
+
+    /// The Linux switches this computer can use: GameMode and MangoHud when installed, the
+    /// dedicated GPU with two cards.
+    fn linux_switches(&self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let found = self.launch.as_ref()?.found;
+        let now = self.selected_instance()?.launch.clone();
+        let gpu_about = match found.nvidia {
+            true => "NVIDIA render offload: __NV_PRIME_RENDER_OFFLOAD and its Vulkan layer.",
+            false => "Mesa's DRI_PRIME=1, so Vulkan picks the other card.",
+        };
+        let mut list = div().flex().flex_col().gap(px(10.));
+        for (toggle, shown, on, label, about) in [
+            (
+                Toggle::GameMode,
+                found.gamemode,
+                now.gamemode,
+                "GameMode",
+                "Feral's gamemoderun: CPU and scheduler tuned while you play.",
+            ),
+            (
+                Toggle::MangoHud,
+                found.mangohud,
+                now.mangohud,
+                "MangoHud",
+                "The frame time, CPU and GPU overlay.",
+            ),
+            (
+                Toggle::Gpu,
+                found.two_gpus,
+                now.dedicated_gpu,
+                "Dedicated graphics card",
+                gpu_about,
+            ),
+        ] {
+            if !shown {
+                continue;
+            }
+            list = list.child(
+                div()
+                    .id(SharedString::from(format!("launch-switch-{label}")))
+                    .flex()
+                    .items_center()
+                    .gap(px(10.))
+                    .cursor_pointer()
+                    .child(switch(
+                        SharedString::from(format!("launch-switch-{label}-s")),
+                        on,
+                        &t,
+                    ))
+                    .child(text(theme::LABEL).text_color(t.ink_soft).child(label))
+                    .child(text(theme::CAPTION).text_color(t.muted).child(about))
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        this.flip(toggle);
+                        cx.notify();
+                    })),
+            );
+        }
+        found.any().then(|| {
+            div()
+                .flex()
+                .flex_col()
+                .gap(px(8.))
+                .child(caps("On this computer").text_color(t.muted))
+                .child(list)
+        })
+    }
+
     /// The panel under the Instance row, while open for the selected instance.
     pub(super) fn launch_panel(&mut self, cx: &mut Context<Self>) -> Option<Div> {
         let t = self.theme;
@@ -124,6 +223,7 @@ impl Launcher {
                 .child(pre)
                 .child(wrapper)
                 .child(env)
+                .children(self.linux_switches(cx))
                 .child(
                     div()
                         .flex()

From cb20bb508bec1083f48073519ff5f5e835f40a6a Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:31:40 +0100
Subject: [PATCH 428/475] remote.sh: runs get CPUs 0-3 by default; benchmarks
 hold them with --exclusive

playhorizon's CI runner has CPUs 4-7, and remote.sh pinned agents' runs there
too: CPUs 4-7 sat at 100% while 0-3 idled, and window harnesses in pull
requests' parity jobs lost ticks. Runs share a lock per CPU set; an
--exclusive run (a benchmark) holds it alone. world_reopen also waits for
the world to load before its first count, as after each reopen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/parity-workflow.md           |  2 +-
 docs/release-flow.md              |  4 ++--
 tools/remote.sh                   | 37 ++++++++++++++++++++++---------
 tools/test_world_reopen_parity.py |  1 +
 4 files changed, 30 insertions(+), 14 deletions(-)

diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md
index 6cb235c3c..a18f84de9 100644
--- a/docs/parity-workflow.md
+++ b/docs/parity-workflow.md
@@ -46,7 +46,7 @@ Harnesses a host can't run are listed in the file: `local_only` (`save_roundtrip
 
 ### Any command on playhorizon: `tools/remote.sh`
 
-For Linux work that doesn't need a whole parity run (a crate's tests, a few harnesses, a server build), `tools/remote.sh <worktree> <command...>` runs the command on playhorizon at the worktree's commit and streams its output back; its exit status is the command's. Commit and push first: the host fetches the commit from GitHub, and nothing else leaves this machine (no files, no credentials, no environment). Each worktree keeps one checkout there, `~/remote-work/<name>` with its own `target/`, so the next run only rebuilds what changed, and one run per name goes at a time. The command runs niced in the host's CI slice, pinned to CPUs 4-7 (`--cpus`; 0-3 stay free for benchmarks), with scratch game and launcher homes and the vanilla data linked as CI links it; a command naming `parity`, `lan_e2e` or `horizon-prepare` also gets `.local/horizon-client`, prepared as CI prepares it. Whatever the command leaves running (a game, a daemon) is stopped when it ends, and stopping `remote.sh` (or losing the connection) stops the command on the host. Logs stay in `~/remote-work/<name>.logs/`; `--list` shows the checkouts, `--gc [DAYS]` removes old ones.
+For Linux work that doesn't need a whole parity run (a crate's tests, a few harnesses, a server build), `tools/remote.sh <worktree> <command...>` runs the command on playhorizon at the worktree's commit and streams its output back; its exit status is the command's. Commit and push first: the host fetches the commit from GitHub, and nothing else leaves this machine (no files, no credentials, no environment). Each worktree keeps one checkout there, `~/remote-work/<name>` with its own `target/`, so the next run only rebuilds what changed, and one run per name goes at a time. The command runs niced in the host's CI slice, pinned to CPUs 0-3 (`--cpus`): the CI runner has 4-7, so these runs never slow a pull request's parity job. A benchmark asks for its CPUs with `--cpus 0-3 --exclusive` (and says so in its pull request): it starts only when no other run uses them, and later runs wait for it to end. The command gets scratch game and launcher homes and the vanilla data linked as CI links it; a command naming `parity`, `lan_e2e` or `horizon-prepare` also gets `.local/horizon-client`, prepared as CI prepares it. Whatever the command leaves running (a game, a daemon) is stopped when it ends, and stopping `remote.sh` (or losing the connection) stops the command on the host. Logs stay in `~/remote-work/<name>.logs/`; `--list` shows the checkouts, `--gc [DAYS]` removes old ones.
 
 ```sh
 tools/remote.sh .claude/worktrees/my-fix cargo test -p horizon-world --lib   # 33 s, warm
diff --git a/docs/release-flow.md b/docs/release-flow.md
index e6a0a3856..1917fddd4 100644
--- a/docs/release-flow.md
+++ b/docs/release-flow.md
@@ -108,8 +108,8 @@ and its failures bisect and comment on merges.
 AMD EPYC threads, 30 GB, in Detroit; reachable only through the maintainer's tailnet). Nobody sits at it, so the
 watcher never pauses it except by hand. It gets half the machine: `RUNNER_MEMORY=24`, `CARGO_BUILD_JOBS` and the
 harness slots at 4, and a drop-in (`~/.config/systemd/user/horizon-runner.service.d/cpus.conf`) that starts it under
-`taskset -c 4-7`, so CPUs 0-3 stay free for benchmarks pinned there (the user slice can't set `AllowedCPUs`: systemd
-doesn't delegate the cpuset controller to it).
+`taskset -c 4-7` (the user slice can't set `AllowedCPUs`: systemd doesn't delegate the cpuset controller to it).
+Agents' `tools/remote.sh` runs and benchmarks share CPUs 0-3, so they never slow a pull request's job.
 Without Nix, `linux-runner.sh` takes the build libraries, the JDK, sccache, Xvfb and Mesa's software Vulkan
 (lavapipe; there is no GPU) from apt, and Python 3.13 from uv. The partner can reach the machine, so gh is not
 logged in there: the registration token comes from another machine (`RUNNER_TOKEN`), and no job with secrets may
diff --git a/tools/remote.sh b/tools/remote.sh
index 0955666cb..fa913e7cc 100755
--- a/tools/remote.sh
+++ b/tools/remote.sh
@@ -1,9 +1,10 @@
 #!/usr/bin/env bash
 # Run a command on a Linux build host (default playhorizon) at a worktree's commit, and get its output back.
 #
-#   tools/remote.sh [--host H] [--name N] [--cpus LIST] [--jobs J] <worktree> <command...>
+#   tools/remote.sh [--host H] [--name N] [--cpus LIST] [--exclusive] [--jobs J] <worktree> <command...>
 #   tools/remote.sh .claude/worktrees/my-fix cargo test -p horizon-world --lib
 #   tools/remote.sh . python3 tools/parity.py food light
+#   tools/remote.sh --cpus 0-3 --exclusive . python3 tools/perf_bench.py   # a benchmark: CPUs 0-3 to itself
 #   tools/remote.sh --list                          # checkouts on the host, their size and last use
 #   tools/remote.sh --gc [DAYS]                     # remove checkouts unused for DAYS (default 2)
 #
@@ -18,19 +19,24 @@
 # What the command leaves running is stopped when it ends; stopping this script stops the command on the host.
 # The exit status is the command's.
 #
+# CPUs: playhorizon's CI runner has CPUs 4-7 (a systemd drop-in pins it, docs/release-flow.md), so runs here get
+# 0-3 by default and never slow a pull request's parity job. A run holds its CPU set's lock shared; --exclusive (a
+# benchmark: name it with --cpus and say so in its pull request) holds it alone, so it starts only when no other run
+# uses those CPUs, and the others wait for it to end. --cpus 4-7 or all compete with CI: only when it is idle.
+#
 # The host is lent by a partner who keeps hypervisor access: never send secrets, tokens or credentials there,
 # and never treat a result from it as a CI result.
 set -euo pipefail
 
-# CPUs 0-3 stay free for benchmarks (perf-world-entry measures on playhorizon pinned to them); --cpus all for every one.
-host=playhorizon name="" jobs="" cpus=4-7
-usage() { sed -n '2,8s/^# \{0,1\}//p' "$0" >&2; exit 2; }
+host=playhorizon name="" jobs="" cpus=0-3 exclusive=0
+usage() { sed -n '2,9s/^# \{0,1\}//p' "$0" >&2; exit 2; }
 while [ $# -gt 0 ]; do
   case $1 in
     --host) host=$2; shift 2;;
     --name) name=$2; shift 2;;
     --jobs) jobs=$2; shift 2;;
     --cpus) cpus=$2; shift 2;;
+    --exclusive) exclusive=1; shift;;
     --list) exec ssh "ludovic@$host" 'cd ~/remote-work 2>/dev/null && for d in */; do d=${d%/};
       printf "%-32s %8s  last used %s\n" "$d" "$(du -sh "$d" 2>/dev/null | cut -f1)" "$(stat -c %y "$d.logs" 2>/dev/null | cut -c1-16)"; done';;
     --gc) days=${2:-2}; exec ssh "ludovic@$host" "cd ~/remote-work 2>/dev/null || exit 0
@@ -58,7 +64,8 @@ command=$(printf '%q ' "$@")
 # The host side reads its script and these four values on stdin (nothing is re-split by a remote shell); its
 # own environment comes from the runner's files there.
 {
-printf 'name=%q sha=%q jobs=%q cpus=%q command=%q\n' "$name" "$sha" "$jobs" "$cpus" "$command"
+[[ $cpus =~ ^[0-9,-]+$|^all$ ]] || { echo "remote.sh: --cpus takes a list such as 0-3, or all" >&2; exit 2; }
+printf 'name=%q sha=%q jobs=%q cpus=%q exclusive=%q command=%q\n' "$name" "$sha" "$jobs" "$cpus" "$exclusive" "$command"
 cat <<'REMOTE'
 set -euo pipefail
 if [ "$cpus" = all ]; then pin=(); jobs=${jobs:-$(nproc)}; else pin=(taskset -c "$cpus"); jobs=${jobs:-$(taskset -c "$cpus" nproc)}; fi
@@ -71,19 +78,27 @@ unset WAYLAND_DISPLAY
 mkdir -p ~/remote-work && cd ~/remote-work
 exec 9> "$name.lock"
 flock -n 9 || { echo "remote.sh: $name is busy with another run" >&2; exit 75; }
+# The CPU set's lock: shared by ordinary runs, held alone by an --exclusive one (a benchmark).
+exec 8> ".cpus-$cpus.lock"
+if [ "$exclusive" = 1 ]; then
+  flock -x -n 8 || { echo "remote.sh: other runs use CPUs $cpus; try again when they are done (--list)" >&2; exit 75; }
+elif ! flock -s -n 8; then
+  echo "remote.sh: an exclusive run (a benchmark) has CPUs $cpus; waiting for it to end" >&2
+  flock -s 8
+fi
 if [ ! -d "$name/.git" ]; then
-  git clone -q --filter=blob:none --no-checkout https://github.com/ludovic111/horizon "$name" 9>&-
+  git clone -q --filter=blob:none --no-checkout https://github.com/ludovic111/horizon "$name" 8>&- 9>&-
 fi
 cd "$name"
-# The lock's descriptor stays out of everything started here (9>&-): a daemon one of them starts (sccache's server,
+# The lock's descriptor stays out of everything started here (8>&- 9>&-): a daemon one of them starts (sccache's server,
 # from the preparer's build or the command's) would hold the lock after the run.
-git fetch -q --no-tags origin "$sha" 9>&-
+git fetch -q --no-tags origin "$sha" 8>&- 9>&-
 git checkout -q --force --detach "$sha"
 git clean -qfd -e /target -e /.local
 # The host's vanilla data, linked as CI's runner links it; for harnesses also .local/horizon-client, prepared by
 # this commit's own preparer (once per preparer version, kept beside the data and shared by every name).
 if [[ $command =~ parity|lan_e2e|horizon-prepare ]]; then
-  RUNNER_WORKSPACE=$(dirname "$HORIZON_SHARED_SOURCE") RUNNER_TEMP=$(mktemp -d) bash tools/ci/vanilla-data.sh >&2 9>&-
+  RUNNER_WORKSPACE=$(dirname "$HORIZON_SHARED_SOURCE") RUNNER_TEMP=$(mktemp -d) bash tools/ci/vanilla-data.sh >&2 8>&- 9>&-
 else
   mkdir -p .local
   for d in minecraft tools datagen; do
@@ -103,11 +118,11 @@ unit=remote-$name.scope
 systemctl --user stop "$unit" 2>/dev/null || true
 session=$PPID
 ( while kill -0 "$session" 2>/dev/null; do sleep 2; done; systemctl --user stop "$unit" 2>/dev/null ) \
-  < /dev/null > /dev/null 2>&1 9>&- &
+  < /dev/null > /dev/null 2>&1 8>&- 9>&- &
 watcher=$!
 status=0
 systemd-run --user --scope --quiet --slice=horizon-ci.slice --unit="$unit" \
-  "${pin[@]}" nice -n 10 bash -c "$command" 2>&1 < /dev/null 9>&- | tee "$log" || status=${PIPESTATUS[0]}
+  "${pin[@]}" nice -n 10 bash -c "$command" 2>&1 < /dev/null 8>&- 9>&- | tee "$log" || status=${PIPESTATUS[0]}
 kill "$watcher" 2>/dev/null || true
 systemctl --user stop "$unit" 2>/dev/null || true
 exit "$status"
diff --git a/tools/test_world_reopen_parity.py b/tools/test_world_reopen_parity.py
index d3e9c1da6..9487fd1b7 100644
--- a/tools/test_world_reopen_parity.py
+++ b/tools/test_world_reopen_parity.py
@@ -84,6 +84,7 @@ def main():
     failures = 0
     try:
         ctl('wait-ready', '300')
+        ctl('wait-for', 'loaded', '--timeout', '300')  # as after each reopen below
         ctl('command', 'summon minecraft:minecart ~2 ~ ~2')
         ctl('wait', '20')
         expected = carts()

From f1f34edb807607202f74c7af1aa705927fb6dcc8 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:37:07 +0100
Subject: [PATCH 429/475] launcher: offline names and a quick switch of who
 plays

The top bar's account chip opens a menu of every Microsoft account, the
offline names the player keeps and the game's own name; picking one plays
as it. Settings > Account adds and forgets offline names, which reach the
game as --name. CLI and MCP: account offline [NAME], account select
(accounts or offline names), account forget-offline. Share log strips the
offline names too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md     |  18 ++-
 launcher/README.md            |   7 ++
 launcher/src/account.rs       |  95 ++++++++++++++
 launcher/src/account/tests.rs |  40 ++++++
 launcher/src/cli.rs           |  64 ++++++++--
 launcher/src/game_log.rs      |  12 +-
 launcher/src/main.rs          |  28 +++--
 launcher/src/servers_page.rs  |   6 +-
 launcher/src/switch_page.rs   | 231 ++++++++++++++++++++++++++++++++++
 9 files changed, 469 insertions(+), 32 deletions(-)
 create mode 100644 launcher/src/switch_page.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 35de188f9..842a3c3c2 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -116,7 +116,7 @@ MCP: `account_sign_out`, needs `confirm: true`.
 
 ## `horizon-launcher account select`
 
-Play as this account.
+Play as this account, or as one of your offline names.
 
     horizon-launcher account select <WHO>
 
@@ -126,12 +126,24 @@ MCP: `account_select`.
 
 ## `horizon-launcher account offline`
 
-Play offline, without an account.
+Play offline, without an account: as NAME (kept to switch back to; 3 to 16 letters, digits or _), or as the name the game made up.
 
-    horizon-launcher account offline
+    horizon-launcher account offline [NAME]
+
+- `NAME`
 
 MCP: `account_offline`.
 
+## `horizon-launcher account forget-offline`
+
+Forget one of your offline names.
+
+    horizon-launcher account forget-offline <NAME>
+
+- `NAME`
+
+MCP: `account_forget_offline`.
+
 ## `horizon-launcher settings`
 
 Show the launcher's settings, or set one (the Settings page): selected-version TAG, minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions on|off, opening-animation on|off, proxy http://host:port ("default" removes it), while-playing stay|minimize|hide (what the window does while the game runs).
diff --git a/launcher/README.md b/launcher/README.md
index 104285c5a..93115c479 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -122,6 +122,13 @@ The opening, then Play ([clip](docs/opening.webm)):
   (`horizon_launcher::shortcut`). **Remove shortcut** moves it to the trash; it is found by the
   instance id inside it, so a rename doesn't lose it. `horizon-launcher instance shortcut
   [instance] [--remove]`; `HORIZON_LAUNCHER_DESKTOP` points it at another folder.
+- **Accounts and quick switch**: the top bar's account chip opens a menu of everyone who can play:
+  each signed-in Microsoft account, the offline names the player keeps, and the name the game
+  made up (`horizon-player.txt`). Picking one plays as it from the next Play. Settings > Account
+  adds offline names (3 to 16 letters, digits or `_`; the game gets `--name`) and forgets them;
+  the Console's Share log takes them out of the log too. `horizon-launcher account offline
+  [NAME]`, `account select <name>` (an account or an offline name), `account forget-offline
+  <name>`.
 - **Console**: Home's Console shows the game's output of this run as it comes: a search (every
   word, any case), Follow to keep the newest line in view, Copy, and Open logs folder. Warnings
   and errors stand out. **Share log…** uploads the log to [mclo.gs](https://mclo.gs), a paste
diff --git a/launcher/src/account.rs b/launcher/src/account.rs
index 1416424ce..f402fe5ce 100644
--- a/launcher/src/account.rs
+++ b/launcher/src/account.rs
@@ -638,6 +638,30 @@ pub struct Accounts {
     pub accounts: Vec<Account>,
     /// The UUID of the account the game starts with; none plays offline.
     pub selected: Option<String>,
+    /// Offline names the player keeps, to switch between (`--name`): no account, no skin.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub offline: Vec<String>,
+    /// The offline name that plays when no account is selected; none: the name the game made up
+    /// (`horizon-player.txt`).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offline_selected: Option<String>,
+}
+
+/// Who plays, as the quick switch lists them.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Player {
+    /// A Microsoft account, by UUID.
+    Microsoft(String),
+    /// An offline name.
+    Offline(String),
+    /// Offline as the name the game made up.
+    GameName,
+}
+
+/// Whether `name` can be an offline name: 3 to 16 letters, digits or `_`, as account names are.
+pub fn valid_offline_name(name: &str) -> bool {
+    (3..=16).contains(&name.chars().count())
+        && name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_')
 }
 
 impl Accounts {
@@ -687,6 +711,77 @@ impl Accounts {
         }
         Ok(())
     }
+    /// Who plays now.
+    pub fn player(&self) -> Player {
+        match (self.selected(), &self.offline_selected) {
+            (Some(a), _) => Player::Microsoft(a.uuid.clone()),
+            (None, Some(name)) => Player::Offline(name.clone()),
+            (None, None) => Player::GameName,
+        }
+    }
+
+    /// Plays as `who`: an account, an offline name (kept), or the game's own name.
+    pub fn play_as(&mut self, who: Player) -> Result<(), String> {
+        match who {
+            Player::Microsoft(uuid) => {
+                if !self.accounts.iter().any(|a| a.uuid == uuid) {
+                    return Err("That account isn't signed in.".into());
+                }
+                self.selected = Some(uuid);
+            }
+            Player::Offline(name) => {
+                let name = self.add_offline(&name)?;
+                self.selected = None;
+                self.offline_selected = Some(name);
+            }
+            Player::GameName => {
+                self.selected = None;
+                self.offline_selected = None;
+            }
+        }
+        Ok(())
+    }
+
+    /// Keeps an offline name (once, in any case); returns it as kept.
+    pub fn add_offline(&mut self, name: &str) -> Result<String, String> {
+        let name = name.trim();
+        if !valid_offline_name(name) {
+            return Err(format!(
+                "{name}: an offline name is 3 to 16 letters, digits or _"
+            ));
+        }
+        if let Some(kept) = self.offline.iter().find(|n| n.eq_ignore_ascii_case(name)) {
+            return Ok(kept.clone());
+        }
+        self.offline.push(name.to_string());
+        Ok(name.to_string())
+    }
+
+    /// Forgets an offline name; if it was playing, the game's own name plays.
+    pub fn remove_offline(&mut self, name: &str) -> Result<(), String> {
+        let before = self.offline.len();
+        self.offline.retain(|n| !n.eq_ignore_ascii_case(name));
+        if self.offline.len() == before {
+            return Err(format!("No offline name {name}."));
+        }
+        if self
+            .offline_selected
+            .as_ref()
+            .is_some_and(|n| n.eq_ignore_ascii_case(name))
+        {
+            self.offline_selected = None;
+        }
+        Ok(())
+    }
+
+    /// The game's `--name` for this run: the offline name, when one plays.
+    pub fn name_arg(&self) -> Option<&str> {
+        match self.selected() {
+            Some(_) => None,
+            None => self.offline_selected.as_deref(),
+        }
+    }
+
     /// Sign out: the secrets leave the keychain, the account the list.
     pub fn remove(&mut self, store: &dyn SecretStore, uuid: &str) -> Result<(), String> {
         store.delete(uuid)?;
diff --git a/launcher/src/account/tests.rs b/launcher/src/account/tests.rs
index 5aea5dd12..ec3766c7e 100644
--- a/launcher/src/account/tests.rs
+++ b/launcher/src/account/tests.rs
@@ -423,3 +423,43 @@ fn client_id_is_configuration() {
     );
     std::env::remove_var("HORIZON_MSA_CLIENT_ID");
 }
+
+#[test]
+fn offline_names_switch_with_accounts() {
+    let mut a = Accounts {
+        accounts: vec![Account {
+            uuid: "abc".into(),
+            name: "Ludo".into(),
+            skin: None,
+            cape: None,
+        }],
+        selected: Some("abc".into()),
+        ..Accounts::default()
+    };
+    assert_eq!(a.player(), Player::Microsoft("abc".into()));
+    assert_eq!(a.name_arg(), None);
+    a.play_as(Player::Offline("Builder_1".into())).unwrap();
+    assert_eq!(a.player(), Player::Offline("Builder_1".into()));
+    assert_eq!(a.name_arg(), Some("Builder_1"));
+    // Kept once, as first written, whatever the case.
+    a.play_as(Player::Offline("builder_1".into())).unwrap();
+    assert_eq!(a.offline, ["Builder_1"]);
+    assert_eq!(a.name_arg(), Some("Builder_1"));
+    assert!(a.add_offline("no spaces").is_err());
+    assert!(a.add_offline("ab").is_err());
+    assert!(a.add_offline("seventeen_letters").is_err());
+    a.play_as(Player::Microsoft("abc".into())).unwrap();
+    assert_eq!(a.name_arg(), None, "an account plays with its own name");
+    assert!(a.play_as(Player::Microsoft("zzz".into())).is_err());
+    a.play_as(Player::Offline("Builder_1".into())).unwrap();
+    a.remove_offline("BUILDER_1").unwrap();
+    assert_eq!(a.player(), Player::GameName);
+    assert!(a.remove_offline("Builder_1").is_err());
+    // An accounts.json from before offline names reads as it was, and writes nothing new.
+    let old: Accounts = serde_json::from_str(r#"{"accounts":[],"selected":null}"#).unwrap();
+    assert_eq!(old.player(), Player::GameName);
+    assert_eq!(
+        serde_json::to_string(&old).unwrap(),
+        r#"{"accounts":[],"selected":null}"#
+    );
+}
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index e88144fe3..8153c7968 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -86,10 +86,13 @@ enum AccountCmd {
         /// Its name or UUID
         who: String,
     },
-    /// Play as this account
+    /// Play as this account, or as one of your offline names
     Select { who: String },
-    /// Play offline, without an account
-    Offline,
+    /// Play offline, without an account: as NAME (kept to switch back to; 3 to 16 letters,
+    /// digits or _), or as the name the game made up
+    Offline { name: Option<String> },
+    /// Forget one of your offline names
+    ForgetOffline { name: String },
 }
 
 #[derive(Subcommand)]
@@ -960,6 +963,9 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
             }
             cmd.args(arg);
             let started = std::time::Instant::now();
+            if let Some(name) = Accounts::load().name_arg() {
+                cmd.arg("--name").arg(name);
+            }
             let played = attached(horizon_launcher::launch::wrap(cmd, &instance.launch));
             if let Err(e) = instances::record_play(&instance.id, started.elapsed()) {
                 eprintln!("Play time not saved: {e}");
@@ -1245,9 +1251,13 @@ fn account_command(action: AccountCmd, as_json: bool) -> Result<(), String> {
                         "name": a.name, "uuid": a.uuid,
                         "selected": accounts.selected.as_ref() == Some(&a.uuid),
                     })).collect::<Vec<_>>(),
+                    "offline": accounts.offline.iter().map(|n| serde_json::json!({
+                        "name": n,
+                        "selected": accounts.player() == account::Player::Offline(n.clone()),
+                    })).collect::<Vec<_>>(),
                     "sign_in_configured": account::client_id().is_some(),
                 }));
-            } else if accounts.accounts.is_empty() {
+            } else if accounts.accounts.is_empty() && accounts.offline.is_empty() {
                 println!("No Microsoft account signed in: the game plays offline.");
             } else {
                 for a in &accounts.accounts {
@@ -1258,8 +1268,14 @@ fn account_command(action: AccountCmd, as_json: bool) -> Result<(), String> {
                     };
                     println!("{mark} {}  {}", a.name, a.uuid);
                 }
-                if accounts.selected().is_none() {
-                    println!("Playing offline (`account select NAME` to play as one).");
+                for n in &accounts.offline {
+                    let on = accounts.player() == account::Player::Offline(n.clone());
+                    println!("{} {n}  offline", if on { "*" } else { " " });
+                }
+                if accounts.player() == account::Player::GameName {
+                    println!(
+                        "Playing offline as the game's own name (`account select NAME` to switch)."
+                    );
                 }
             }
         }
@@ -1287,15 +1303,39 @@ fn account_command(action: AccountCmd, as_json: bool) -> Result<(), String> {
             println!("Signed out {}.", a.name);
         }
         AccountCmd::Select { who } => {
-            let a = find(&accounts, &who)?;
-            accounts.selected = Some(a.uuid);
+            let offline = accounts
+                .offline
+                .iter()
+                .find(|n| n.eq_ignore_ascii_case(&who))
+                .cloned();
+            let (player, name) = match (accounts.find(&who).cloned(), offline) {
+                (Some(a), _) => (account::Player::Microsoft(a.uuid), a.name),
+                (None, Some(n)) => (
+                    account::Player::Offline(n.clone()),
+                    format!("{n} (offline)"),
+                ),
+                (None, None) => return Err(find(&accounts, &who).unwrap_err()),
+            };
+            accounts.play_as(player)?;
             accounts.save()?;
-            println!("The game plays as {}.", a.name);
+            println!("The game plays as {name}.");
         }
-        AccountCmd::Offline => {
-            accounts.selected = None;
+        AccountCmd::Offline { name } => {
+            let player = match name {
+                Some(n) => account::Player::Offline(n),
+                None => account::Player::GameName,
+            };
+            accounts.play_as(player)?;
             accounts.save()?;
-            println!("The game plays offline.");
+            match accounts.name_arg() {
+                Some(n) => println!("The game plays offline as {n}."),
+                None => println!("The game plays offline, as the name it made up."),
+            }
+        }
+        AccountCmd::ForgetOffline { name } => {
+            accounts.remove_offline(&name)?;
+            accounts.save()?;
+            println!("Forgot the offline name {name}.");
         }
     }
     Ok(())
diff --git a/launcher/src/game_log.rs b/launcher/src/game_log.rs
index a9c787544..1d671f27e 100644
--- a/launcher/src/game_log.rs
+++ b/launcher/src/game_log.rs
@@ -29,14 +29,12 @@ pub fn matches(line: &str, search: &str) -> bool {
         .all(|w| line.contains(&w.to_lowercase()))
 }
 
-/// The names to take out of a log: the account names, the offline player name kept in each
-/// game folder (`horizon-player.txt`), and the computer's user name.
+/// The names to take out of a log: the account names and offline names, the offline player
+/// name kept in each game folder (`horizon-player.txt`), and the computer's user name.
 pub fn names(homes: &[&Path]) -> Vec<String> {
-    let mut names: Vec<String> = crate::account::Accounts::load()
-        .accounts
-        .into_iter()
-        .map(|a| a.name)
-        .collect();
+    let accounts = crate::account::Accounts::load();
+    let mut names: Vec<String> = accounts.accounts.into_iter().map(|a| a.name).collect();
+    names.extend(accounts.offline);
     for home in homes {
         if let Ok(name) = std::fs::read_to_string(home.join("horizon-player.txt")) {
             names.push(name.trim().to_string());
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 90475305b..1496dbe59 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -32,6 +32,7 @@ mod screenshots_page;
 mod scrollbar;
 mod servers_page;
 mod shortcut_page;
+mod switch_page;
 mod theme;
 mod titlebar;
 mod while_playing;
@@ -164,6 +165,8 @@ struct Launcher {
     install_error: Option<(String, String)>,
     confirm_remove: Option<String>,
     picker_open: bool,
+    /// The top bar's quick switch of who plays (`switch_page.rs`).
+    account_menu: bool,
     settings: Settings,
     /// The Discord, sponsor and website links: built in until links.json on main has been read.
     links: backend::Links,
@@ -362,6 +365,7 @@ impl Launcher {
             install_error: None,
             confirm_remove: None,
             picker_open: false,
+            account_menu: false,
             args_input: settings.game_args.clone(),
             args_focused: false,
             args_focus: cx.focus_handle(),
@@ -467,6 +471,7 @@ impl Launcher {
             }
         }
         self.picker_open = false;
+        self.account_menu = false;
     }
 
     fn check_updates(&mut self) {
@@ -583,6 +588,10 @@ impl Launcher {
                             Err(e) => self.client_error = Some(format!("Playing offline: {e}")),
                         }
                         self.accounts = Accounts::load();
+                        // An offline name the player picked (the quick switch).
+                        if let Some(name) = self.accounts.name_arg() {
+                            cmd.arg("--name").arg(name);
+                        }
                         // A pack's Play button plays that pack; Play plays the selected instance.
                         let (profile, run) = match self.starting_pack.take() {
                             Some(work) => {
@@ -1557,14 +1566,9 @@ impl Launcher {
                 }));
             nav = nav.child(keyboard(track_hover(item, id), &t));
         }
-        // Only a signed-in account says "Microsoft account"; otherwise the name the game made up.
-        let (name, how) = match self.accounts.selected() {
-            Some(a) => (a.name.clone(), "Microsoft account"),
-            None => (
-                self.offline_name.clone().unwrap_or_else(|| "Player".into()),
-                "Offline",
-            ),
-        };
+        // Only a signed-in account says "Microsoft account"; otherwise an offline name, or the
+        // one the game made up.
+        let (name, how) = self.who_plays();
         let account = keyboard(div().id("account"), &t)
             .relative()
             .flex()
@@ -1603,9 +1607,13 @@ impl Launcher {
                     .child(text(theme::CAPTION).text_color(t.muted).child(how)),
             )
             .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
-                this.go(Page::Settings);
+                this.account_menu = !this.account_menu;
                 cx.notify();
             }));
+        let account = div()
+            .relative()
+            .child(account)
+            .children(self.account_menu(cx));
         let settings_open = self.page == Page::Settings;
         let settings = keyboard(div().id("nav-Settings"), &t)
             .relative()
@@ -2626,6 +2634,7 @@ impl Launcher {
         let mono = |s: String| div().font_family(theme::MONO).child(s).into_any_element();
         let plain = |s: &str| div().child(s.to_string()).into_any_element();
         let (accounts, n) = self.account_rows(cx);
+        let (offline, n) = self.offline_rows(n, cx);
         let appearance = segments(
             "appearance",
             &[
@@ -2666,6 +2675,7 @@ impl Launcher {
                     .flex_col()
                     .child(group("Account", "user").mt_0())
                     .child(accounts)
+                    .child(offline)
                     .child(group("Updates", "reload"))
                     .child(index_row(
                         n + 1,
diff --git a/launcher/src/servers_page.rs b/launcher/src/servers_page.rs
index ae33e6cc0..e3ed4f441 100644
--- a/launcher/src/servers_page.rs
+++ b/launcher/src/servers_page.rs
@@ -44,10 +44,12 @@ pub(super) enum Field {
     PreLaunch,
     Wrapper,
     LaunchEnv,
+    /// Settings' new offline name (`switch_page.rs`).
+    OfflineName,
 }
 
 impl Field {
-    const ALL: [Field; 17] = [
+    const ALL: [Field; 18] = [
         Field::Name,
         Field::Seed,
         Field::Players,
@@ -65,6 +67,7 @@ impl Field {
         Field::PreLaunch,
         Field::Wrapper,
         Field::LaunchEnv,
+        Field::OfflineName,
     ];
 }
 
@@ -1043,6 +1046,7 @@ impl Launcher {
             Field::Email => self.invite_friend(),
             Field::InstanceName | Field::InstanceGroup | Field::ConsoleSearch => {}
             Field::PreLaunch | Field::Wrapper | Field::LaunchEnv => self.save_launch(),
+            Field::OfflineName => self.offline_name_enter(),
             Field::ServerName | Field::ServerAddress => self.add_server(),
         }
     }
diff --git a/launcher/src/switch_page.rs b/launcher/src/switch_page.rs
new file mode 100644
index 000000000..3b6bdac14
--- /dev/null
+++ b/launcher/src/switch_page.rs
@@ -0,0 +1,231 @@
+//! Who plays: the top bar's quick switch (a menu under the account chip) and Settings' offline
+//! names (`horizon_launcher::account::Accounts::offline`).
+use super::servers_page::Field;
+use super::*;
+use horizon_launcher::account::Player;
+
+impl Launcher {
+    /// The chip's two lines: the name that plays, and how.
+    pub(super) fn who_plays(&self) -> (String, &'static str) {
+        match self.accounts.player() {
+            Player::Microsoft(_) => (
+                self.accounts
+                    .selected()
+                    .map_or_else(String::new, |a| a.name.clone()),
+                "Microsoft account",
+            ),
+            Player::Offline(name) => (name, "Offline"),
+            Player::GameName => (
+                self.offline_name.clone().unwrap_or_else(|| "Player".into()),
+                "Offline",
+            ),
+        }
+    }
+
+    pub(super) fn play_as(&mut self, who: Player) {
+        let mut accounts = Accounts::load();
+        let done = accounts.play_as(who).and_then(|()| accounts.save());
+        match done {
+            Ok(()) => self.accounts = accounts,
+            Err(e) => self.sign_in_state = Some(SignInState::Done(Err(e))),
+        }
+        self.account_menu = false;
+    }
+
+    /// Everyone the player can play as, with how each signs in.
+    fn players(&self) -> Vec<(Player, String, &'static str)> {
+        let mut out: Vec<_> = self
+            .accounts
+            .accounts
+            .iter()
+            .map(|a| {
+                (
+                    Player::Microsoft(a.uuid.clone()),
+                    a.name.clone(),
+                    "Microsoft",
+                )
+            })
+            .collect();
+        out.extend(
+            self.accounts
+                .offline
+                .iter()
+                .map(|n| (Player::Offline(n.clone()), n.clone(), "Offline")),
+        );
+        out.push((
+            Player::GameName,
+            self.offline_name.clone().unwrap_or_else(|| "Player".into()),
+            "Offline, the game's name",
+        ));
+        out
+    }
+
+    /// The menu under the account chip, while open.
+    pub(super) fn account_menu(&self, cx: &mut Context<Self>) -> Option<impl IntoElement> {
+        if !self.account_menu {
+            return None;
+        }
+        let t = self.theme;
+        let now = self.accounts.player();
+        let mut menu = div()
+            .id("account-menu")
+            .absolute()
+            .top(px(46.))
+            .right_0()
+            .w(px(280.))
+            .p(px(6.))
+            .border_2()
+            .border_color(t.outline)
+            .bg(t.surface)
+            .flex()
+            .flex_col()
+            .occlude();
+        for (i, (who, name, how)) in self.players().into_iter().enumerate() {
+            let chosen = who == now;
+            menu = menu.child(
+                div()
+                    .id(SharedString::from(format!("account-pick-{i}")))
+                    .flex()
+                    .items_center()
+                    .justify_between()
+                    .gap(px(8.))
+                    .h(px(46.))
+                    .px(px(10.))
+                    .rounded(px(theme::RADIUS))
+                    .cursor_pointer()
+                    .hover(move |s| s.bg(t.plate_soft))
+                    .child(
+                        div()
+                            .flex()
+                            .flex_col()
+                            .min_w_0()
+                            .child(text(theme::LABEL).truncate().text_color(t.ink).child(name))
+                            .child(text(theme::CAPTION).text_color(t.muted).child(how)),
+                    )
+                    .when(chosen, |d| {
+                        d.child(div().size(px(6.)).rounded_full().bg(t.accent))
+                    })
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        this.play_as(who.clone());
+                        cx.notify();
+                    })),
+            );
+        }
+        menu = menu.child(div().my(px(6.)).h(px(1.)).bg(t.rule)).child(
+            div()
+                .id("account-manage")
+                .flex()
+                .items_center()
+                .h(px(32.))
+                .px(px(10.))
+                .rounded(px(theme::RADIUS))
+                .text_size(px(theme::LABEL.px))
+                .text_color(t.muted)
+                .cursor_pointer()
+                .hover(move |s| s.bg(t.plate_soft).text_color(t.ink))
+                .child("Manage accounts")
+                .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                    this.account_menu = false;
+                    this.go(Page::Settings);
+                    cx.notify();
+                })),
+        );
+        Some(gpui::deferred(menu).with_priority(1))
+    }
+
+    fn add_offline_name(&mut self) {
+        let name = self.servers.value(Field::OfflineName).trim().to_string();
+        if name.is_empty() {
+            return;
+        }
+        self.play_as(Player::Offline(name));
+        if !matches!(self.sign_in_state, Some(SignInState::Done(Err(_)))) {
+            self.servers.text(Field::OfflineName).clear();
+        }
+    }
+
+    /// Enter in the offline name field.
+    pub(super) fn offline_name_enter(&mut self) {
+        self.add_offline_name();
+    }
+
+    /// Settings' rows for the offline names, after the Microsoft accounts: each with Play as
+    /// and Forget, then a field to add one.
+    pub(super) fn offline_rows(&mut self, mut n: usize, cx: &mut Context<Self>) -> (Div, usize) {
+        let t = self.theme;
+        let mut rows = div().flex().flex_col();
+        let now = self.accounts.player();
+        for (i, name) in self.accounts.offline.clone().into_iter().enumerate() {
+            let plays = now == Player::Offline(name.clone());
+            let mut actions = div().flex().gap(px(4.));
+            if !plays {
+                let who = Player::Offline(name.clone());
+                actions = actions.child(
+                    button(format!("offline-play-{i}"), "Play as", Kind::Secondary, &t).on_click(
+                        cx.listener(move |this, _: &ClickEvent, _, cx| {
+                            this.play_as(who.clone());
+                            cx.notify();
+                        }),
+                    ),
+                );
+            }
+            let forget = name.clone();
+            actions = actions.child(
+                button(format!("offline-forget-{i}"), "Forget", Kind::Ghost, &t).on_click(
+                    cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        let mut accounts = Accounts::load();
+                        if accounts.remove_offline(&forget).is_ok() && accounts.save().is_ok() {
+                            this.accounts = accounts;
+                        }
+                        cx.notify();
+                    }),
+                ),
+            );
+            n += 1;
+            rows = rows.child(index_row(
+                n,
+                name,
+                Some(
+                    div()
+                        .child(if plays {
+                            "Offline name · plays"
+                        } else {
+                            "Offline name"
+                        })
+                        .into_any_element(),
+                ),
+                Some(actions.into_any_element()),
+                &t,
+            ));
+        }
+        n += 1;
+        let add = div()
+            .flex()
+            .items_center()
+            .gap(px(8.))
+            .child(self.field(Field::OfflineName, "A name, 3 to 16 letters", 220., cx))
+            .child(
+                button("offline-add", "Add", Kind::Secondary, &t).on_click(cx.listener(
+                    |this, _: &ClickEvent, _, cx| {
+                        this.add_offline_name();
+                        cx.notify();
+                    },
+                )),
+            );
+        rows = rows.child(index_row(
+            n,
+            "Offline name",
+            Some(
+                div()
+                    .child(
+                        "Play offline under another name, and switch from the top bar. Offline \
+                         names have no skin, and online servers don't take them.",
+                    )
+                    .into_any_element(),
+            ),
+            Some(add.into_any_element()),
+            &t,
+        ));
+        (rows, n)
+    }
+}

From a2f62b15450a884242f2d6f4184eb0386bf8fb4c Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:42:19 +0100
Subject: [PATCH 430/475] parity_hosts: playhorizon's workers run on CPUs 0-3,
 3 harnesses at a time

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/parity-workflow.md | 2 +-
 docs/release-flow.md    | 2 +-
 tools/parity_hosts.json | 6 +++---
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md
index a18f84de9..73ac5c47c 100644
--- a/docs/parity-workflow.md
+++ b/docs/parity-workflow.md
@@ -40,7 +40,7 @@ The game logs into `HORIZON_HOME` and falls back to the player's own game folder
 
 ### Other machines
 
-Harnesses can also run on the Mac mini, the desktop and playhorizon (`tools/parity_hosts.json` describes them; `desktop` and `playhorizon` use their CI runner's environment and vanilla data, and the desktop refuses work, or stops it, while someone uses it: docs/release-flow.md, "The desktop's runner"; its `default` list is empty, so pass `--hosts macmini,playhorizon` or set `PARITY_HOSTS`, after copying `shared-local/` to `~/code/horizon-parity/shared-local` on each host). The runner mirrors the worktree there with rsync (not `.git`, `.local`, `target` or ignored files) into `~/code/horizon-parity/remote/<host><path>`, whose `.local` links to the vanilla data in `~/code/horizon-parity/shared-local`, and starts `tools/parity.py --worker` over ssh. The worker builds the probes (about 80 s the first time) and runs what it is sent under the same tracer, admitting harnesses against its own free memory. One queue, longest first, feeds every machine, remote ones first: the Mac takes up to 14 harnesses, the desktop 8, playhorizon 6. Each pass comes back with the content hash of every file it depended on, so it is keyed on exactly what ran, and logs come back to `.local/parity-runner/logs/`; state, sharing and `gate.py` work as before. If a host can't be reached, or drops out, its harnesses run here.
+Harnesses can also run on the Mac mini, the desktop and playhorizon (`tools/parity_hosts.json` describes them; `desktop` and `playhorizon` use their CI runner's environment and vanilla data, and the desktop refuses work, or stops it, while someone uses it: docs/release-flow.md, "The desktop's runner"; its `default` list is empty, so pass `--hosts macmini,playhorizon` or set `PARITY_HOSTS`, after copying `shared-local/` to `~/code/horizon-parity/shared-local` on each host). The runner mirrors the worktree there with rsync (not `.git`, `.local`, `target` or ignored files) into `~/code/horizon-parity/remote/<host><path>`, whose `.local` links to the vanilla data in `~/code/horizon-parity/shared-local`, and starts `tools/parity.py --worker` over ssh. The worker builds the probes (about 80 s the first time) and runs what it is sent under the same tracer, admitting harnesses against its own free memory. One queue, longest first, feeds every machine, remote ones first: the Mac takes up to 14 harnesses, the desktop 8, playhorizon 3 (on CPUs 0-3: its CI runner has 4-7). Each pass comes back with the content hash of every file it depended on, so it is keyed on exactly what ran, and logs come back to `.local/parity-runner/logs/`; state, sharing and `gate.py` work as before. If a host can't be reached, or drops out, its harnesses run here.
 
 Harnesses a host can't run are listed in the file: `local_only` (`save_roundtrip` runs the game on a virtual screen) and each host's `exclude`. The Mac excludes nothing: vanilla's `Math.sin`, `pow`, `log` and the like don't round the same on an Apple silicon Mac as on Linux (HotSpot uses fdlibm there, Intel's stubs on x86-64), and Rust's float functions round like neither (they call the platform libm), so code that mirrors a vanilla `Math` call uses `horizon_core::jmath`, which computes what HotSpot computes on the host architecture. The ThinkPad no longer runs harnesses (2026-10-26): playhorizon is the Linux host that is always on.
 
diff --git a/docs/release-flow.md b/docs/release-flow.md
index 1917fddd4..be0ccbee8 100644
--- a/docs/release-flow.md
+++ b/docs/release-flow.md
@@ -113,7 +113,7 @@ Agents' `tools/remote.sh` runs and benchmarks share CPUs 0-3, so they never slow
 Without Nix, `linux-runner.sh` takes the build libraries, the JDK, sccache, Xvfb and Mesa's software Vulkan
 (lavapipe; there is no GPU) from apt, and Python 3.13 from uv. The partner can reach the machine, so gh is not
 logged in there: the registration token comes from another machine (`RUNNER_TOKEN`), and no job with secrets may
-run there (parity has none). It is also a parity host (`playhorizon` in `tools/parity_hosts.json`, 6 jobs). Since
+run there (parity has none). It is also a parity host (`playhorizon` in `tools/parity_hosts.json`, 3 jobs on CPUs 0-3). Since
 2026-10-26 it has the `horizon-game` label: pull requests' parity jobs run there or on the Mac mini, and `full-parity`
 ones only there.
 
diff --git a/tools/parity_hosts.json b/tools/parity_hosts.json
index 60e6205e8..29815a9f6 100644
--- a/tools/parity_hosts.json
+++ b/tools/parity_hosts.json
@@ -23,17 +23,17 @@
   "playhorizon": {
    "ssh": "ludovic@playhorizon",
    "root": ".actions-runners/horizon/parity-host",
-   "shell": "systemd-run --user --scope --quiet --slice=horizon-ci.slice --unit=horizon-parity-worker-$$ bash -c",
+   "shell": "systemd-run --user --scope --quiet --slice=horizon-ci.slice --unit=horizon-parity-worker-$$ taskset -c 0-3 bash -c",
    "setup": "test ! -e ~/.actions-runners/horizon/paused && set -a && . ~/.actions-runners/horizon/.env && set +a && export PATH=$(cat ~/.actions-runners/horizon/.path) && unset WAYLAND_DISPLAY && export DISPLAY=:$(cat ~/.actions-runners/horizon/display)",
    "python": "python3.13",
-   "jobs": 6,
+   "jobs": 3,
    "nice": 10,
    "exclude": {
     "mob_ai": "the vanilla oracle runs out of its 3 GB heap here (OutOfMemoryError in IO workers; passes on the desktop and the Mac) - 2026-10-26 trial",
     "lan_integration": "two clients rendered on the CPU (lavapipe): different timing subtests fail on each run (elytra, consume-release, barter, critical-hits) - 2026-10-26 trial",
     "world_reopen": "failed twice here (no Save and Quit button after reopening; the minecart-count flake), passes on the desktop - 2026-10-26 trial"
    },
-   "note": "a partner's server (Ubuntu, 8 EPYC threads, 30 GB, Detroit; tailnet only), used by nothing else: 6 jobs, in the CI runner's environment, slice and Xvfb screen (tools/ci/linux-runner.sh); the always-on Linux host since the ThinkPad stopped running harnesses (2026-10-26)"
+   "note": "a partner's server (Ubuntu, 8 EPYC threads, 30 GB, Detroit; tailnet only), its CI runner has CPUs 4-7, so workers get 0-3 (as tools/remote.sh runs do) and 3 jobs, in the CI runner's environment, slice and Xvfb screen (tools/ci/linux-runner.sh); the always-on Linux host since the ThinkPad stopped running harnesses (2026-10-26)"
   }
  },
  "local_only": {

From dfb28e42d0008f2f2cc775dfcb99e3200b734d1c Mon Sep 17 00:00:00 2001
From: asowneryt <asowneryt@protonmail.com>
Date: Tue, 27 Oct 2026 16:46:07 +1300
Subject: [PATCH 431/475] Send items and mobs through End portals

The non-player portal path only knew Nether portals, so a cow or a dropped
item standing in an end_portal block never travelled (#1515). It now also
finds End portal blocks (EndPortalBlock.entityInside, its 6/16..12/16
entity-inside shape met along the move), and an entity through one waits as
an arrival with a fixed destination (getPortalDestination): the End's spawn
point above a rebuilt obsidian platform, facing west, or out of the End the
top of the Overworld's shared spawn column. Motion and pitch are kept, the
portal cooldown applies, and saved arrivals keep their End plans.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/end.rs         |   2 +-
 .../horizon-client/src/game/nether_portal.rs  | 353 +++++++++++++-----
 2 files changed, 263 insertions(+), 92 deletions(-)

diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs
index 32d5113b0..fab054971 100644
--- a/crates/horizon-client/src/game/end.rs
+++ b/crates/horizon-client/src/game/end.rs
@@ -19,7 +19,7 @@ use horizon_core::{
 use std::{collections::HashMap, sync::Arc};
 
 /// ServerLevel.END_SPAWN_POINT.
-const END_SPAWN: [i32; 3] = [100, 50, 0];
+pub(super) const END_SPAWN: [i32; 3] = [100, 50, 0];
 /// EnderDragonFight gateway ring radius and height.
 const GATEWAY_RADIUS: f64 = 96.0;
 const GATEWAY_Y: i32 = 75;
diff --git a/crates/horizon-client/src/game/nether_portal.rs b/crates/horizon-client/src/game/nether_portal.rs
index 87ba81c93..d5808f07c 100644
--- a/crates/horizon-client/src/game/nether_portal.rs
+++ b/crates/horizon-client/src/game/nether_portal.rs
@@ -2,7 +2,9 @@
 //! `Entity.setAsInsidePortal` / `handlePortal` with `PortalProcessor`,
 //! `NetherPortalBlock.getPortalTransitionTime` and `getPortalDestination`
 //! (`PortalForcer` through `horizon_world::level::portal_travel`), and
-//! `LocalPlayer.handlePortalTransitionEffect`.
+//! `LocalPlayer.handlePortalTransitionEffect`. Items and mobs also go through
+//! End portals here (`EndPortalBlock.entityInside` / `getPortalDestination`);
+//! the player's End portals are game/end.rs's.
 //!
 //! Only one dimension is loaded at a time. The player's destination is found
 //! once the other dimension has loaded around it. An item or mob that goes
@@ -12,7 +14,7 @@ use super::{Dim, Game, Screen};
 use horizon_client::Result;
 use horizon_client::nether_portal::PortalState;
 use horizon_core::{
-    geometry::{Axis, Vec3},
+    geometry::{Aabb, Axis, Vec3},
     position::BlockPos,
     random::RandomSource,
 };
@@ -40,6 +42,32 @@ pub(super) struct Plan {
     offset: Vec3,
     width: f32,
     height: f32,
+    /// Through an End portal: `approximate` is the End's spawn point, or the
+    /// Overworld's shared spawn.
+    end: bool,
+}
+
+impl Plan {
+    /// `EndPortalBlock.getPortalDestination` for an entity other than a
+    /// player in `from`: the End's spawn point, or out of the End the
+    /// Overworld's shared spawn `world_spawn`.
+    fn end_portal(from: Dim, world_spawn: BlockPos, width: f32, height: f32) -> Self {
+        let (dim, approximate) = if from == Dim::End {
+            (Dim::Overworld, world_spawn)
+        } else {
+            let [x, y, z] = super::end::END_SPAWN;
+            (Dim::End, BlockPos::new(x, y, z))
+        };
+        Self {
+            dim,
+            approximate,
+            entry_x_axis: true,
+            offset: Vec3::ZERO,
+            width,
+            height,
+            end: true,
+        }
+    }
 }
 
 /// An entity on its way to a dimension that isn't loaded.
@@ -81,6 +109,76 @@ fn rotate_y(v: Vec3, degrees: f32) -> Vec3 {
 fn doubles(values: [f64; 3]) -> Tag {
     Tag::List(values.iter().map(|v| Tag::Double(v.to_bits())).collect())
 }
+/// Whether a `width` by `height` box moving from `from` to `to` meets the End
+/// portal at `pos`: `Entity.collidedWithShapeMovingFrom` against its
+/// entity-inside shape, y 6/16..12/16 of the block.
+fn touches_end_portal(from: Vec3, to: Vec3, width: f32, height: f32, pos: BlockPos) -> bool {
+    let half = f64::from(width) / 2.0;
+    let start = Aabb::new(
+        Vec3::new(from.x - half, from.y, from.z - half),
+        Vec3::new(from.x + half, from.y + f64::from(height), from.z + half),
+    );
+    let (x, y, z) = (f64::from(pos.x), f64::from(pos.y), f64::from(pos.z));
+    let shape = Aabb::new(
+        Vec3::new(x, y + 0.375, z),
+        Vec3::new(x + 1.0, y + 0.75, z + 1.0),
+    );
+    start.collided_along_vector(to.subtract(from), &[shape])
+}
+/// A waiting entity as `horizon_portal_arrivals.dat` keeps it.
+fn arrival_tag(a: &Arrival) -> Tag {
+    let p = &a.plan;
+    Tag::compound([
+        ("dimension", Tag::String(p.dim.id().into())),
+        ("x", Tag::Int(p.approximate.x)),
+        ("y", Tag::Int(p.approximate.y)),
+        ("z", Tag::Int(p.approximate.z)),
+        ("x_axis", Tag::Int(i32::from(p.entry_x_axis))),
+        ("right", Tag::Double(p.offset.x.to_bits())),
+        ("up", Tag::Double(p.offset.y.to_bits())),
+        ("forward", Tag::Double(p.offset.z.to_bits())),
+        ("width", Tag::Float(p.width.to_bits())),
+        ("height", Tag::Float(p.height.to_bits())),
+        ("end", Tag::Int(i32::from(p.end))),
+        ("entity", a.tag.clone()),
+    ])
+}
+/// The waiting entity `arrival_tag` wrote.
+fn arrival_from_tag(a: &Tag) -> Option<Arrival> {
+    let int = |k: &str| match a.get(k) {
+        Some(Tag::Int(v)) => Some(*v),
+        _ => None,
+    };
+    let float = |k: &str| match a.get(k) {
+        Some(Tag::Float(v)) => Some(f32::from_bits(*v)),
+        _ => None,
+    };
+    let double = |k: &str| match a.get(k) {
+        Some(Tag::Double(v)) => Some(f64::from_bits(*v)),
+        _ => None,
+    };
+    let dim = Dim::from_id(&horizon_client::save::text(a.get("dimension"))?);
+    let (Some(x), Some(y), Some(z), Some(tag)) = (int("x"), int("y"), int("z"), a.get("entity"))
+    else {
+        return None;
+    };
+    Some(Arrival {
+        plan: Plan {
+            dim,
+            approximate: BlockPos::new(x, y, z),
+            entry_x_axis: int("x_axis").unwrap_or(1) != 0,
+            offset: Vec3::new(
+                double("right").unwrap_or(0.5),
+                double("up").unwrap_or(0.0),
+                double("forward").unwrap_or(0.0),
+            ),
+            width: float("width").unwrap_or(0.25),
+            height: float("height").unwrap_or(0.25),
+            end: int("end").unwrap_or(0) != 0,
+        },
+        tag: tag.clone(),
+    })
+}
 
 impl Game<'_> {
     /// The world border's extent.
@@ -146,8 +244,54 @@ impl Game<'_> {
             offset,
             width,
             height,
+            end: false,
         }
     }
+    /// The plan of an item or mob going through the portal block at `entry`:
+    /// an End portal's fixed destination, else the Nether portal's.
+    fn entity_plan(
+        &self,
+        entry: BlockPos,
+        at: Vec3,
+        width: f32,
+        height: f32,
+        reset_forward: bool,
+    ) -> Plan {
+        if !self.is_end_portal(self.world.block(entry.x, entry.y, entry.z)) {
+            return self.portal_plan(entry, at, width, height, reset_forward);
+        }
+        let spawn = self.level.world_spawn.unwrap_or_else(|| {
+            self.spawn.map_or([0, 64, 0], |s| {
+                [s.x.floor() as i32, s.y.floor() as i32, s.z.floor() as i32]
+            })
+        });
+        Plan::end_portal(
+            self.dim,
+            BlockPos::new(spawn[0], spawn[1], spawn[2]),
+            width,
+            height,
+        )
+    }
+    fn is_end_portal(&self, state: horizon_world::registry::BlockStateId) -> bool {
+        &*self.res.facts().get(state).name == "minecraft:end_portal"
+    }
+    /// Where an item or mob through an End portal lands once `plan`'s level
+    /// has loaded around it, and the yaw it faces there: the bottom centre
+    /// of the End's spawn point, above the platform built below it
+    /// (`EndPlatformFeature.createEndPlatform`), facing west; out of the End,
+    /// the top of the shared spawn's column (`Entity.adjustSpawnLocation`).
+    fn end_portal_exit(&mut self, plan: &Plan) -> (Vec3, Option<f32>) {
+        let p = plan.approximate;
+        let centre = Vec3::new(f64::from(p.x) + 0.5, f64::from(p.y), f64::from(p.z) + 0.5);
+        if plan.dim == Dim::End {
+            return self.end_arrival(centre).unwrap_or_else(|e| {
+                log::error!("End platform: {e}");
+                (centre, Some(90.0))
+            });
+        }
+        let y = self.motion_top(p.x, p.z);
+        (Vec3::new(centre.x, f64::from(y), centre.z), None)
+    }
     /// The nether portal blocks of the chunks within `radius` of `center`
     /// (the points of interest `PortalForcer` searches): loaded chunks as
     /// they are, the others as saved; chunks never generated have none.
@@ -520,9 +664,10 @@ impl Game<'_> {
             || self.ridden_by_guest(id)
             || self.mobs.iter().any(|m| m.extra.mount == Some(id))
     }
-    /// `NetherPortalBlock.entityInside` for the items, mobs and empty boats
-    /// and minecarts that moved this tick: the portal blocks their box swept
-    /// through.
+    /// `NetherPortalBlock.entityInside` and `EndPortalBlock.entityInside`
+    /// for the items, mobs and empty boats and minecarts that moved this
+    /// tick: the portal blocks their box swept through (an End portal's
+    /// transition time is 0 too).
     pub(super) fn find_entity_portals(&mut self) {
         if self.remote.is_some() {
             return;
@@ -570,7 +715,7 @@ impl Game<'_> {
                 .set_inside(pos, ENTITY_DELAY);
         }
     }
-    /// The first nether portal block an entity box swept through
+    /// The first nether or End portal block an entity box swept through
     /// (`Entity.checkInsideBlocks`, whose first portal sets the entry).
     fn swept_portal(
         &self,
@@ -604,11 +749,9 @@ impl Game<'_> {
             bounds,
             1_000_000,
             |p, _| {
-                if self
-                    .res
-                    .behaviours()
-                    .portal_axis(self.world.block(p.x, p.y, p.z))
-                    .is_some()
+                let state = self.world.block(p.x, p.y, p.z);
+                if self.res.behaviours().portal_axis(state).is_some()
+                    || (self.is_end_portal(state) && touches_end_portal(from, to, width, height, p))
                 {
                     found = Some(p);
                     return false;
@@ -618,8 +761,8 @@ impl Game<'_> {
         );
         found
     }
-    /// Whether a section `reach` touches has a nether portal state in its
-    /// palette: without one, no block there is a portal. Palette answers are
+    /// Whether a section `reach` touches has a nether or End portal state in
+    /// its palette: without one, no block there is a portal. Palette answers are
     /// kept per chunk across ticks (`portal_sections`); a box over many
     /// sections is not checked.
     fn may_hold_portal(
@@ -656,9 +799,8 @@ impl Game<'_> {
             (z0..=z1).any(|cz| {
                 chunks.get(&(cx, cz)).is_some_and(|chunk| {
                     sections.get((cx, cz), chunk, |v| {
-                        behaviours
-                            .portal_axis(horizon_world::registry::BlockStateId(v))
-                            .is_some()
+                        let state = horizon_world::registry::BlockStateId(v);
+                        behaviours.portal_axis(state).is_some() || self.is_end_portal(state)
                     }) & y_mask
                         != 0
                 })
@@ -670,7 +812,7 @@ impl Game<'_> {
     fn send_through_portal(&mut self, id: u32, entry: BlockPos) {
         if let Some(i) = self.dropped.iter().position(|e| e.id == id) {
             let e = &self.dropped[i];
-            let plan = self.portal_plan(entry, e.position, 0.25, 0.25, false);
+            let plan = self.entity_plan(entry, e.position, 0.25, 0.25, false);
             if !self.may_enter(plan.dim) {
                 return;
             }
@@ -686,7 +828,7 @@ impl Game<'_> {
             self.portals.dirty = true;
         } else if let Some(i) = self.mobs.iter().position(|m| m.id == id) {
             let m = &self.mobs[i];
-            let plan = self.portal_plan(entry, m.position, m.width(), m.height(), true);
+            let plan = self.entity_plan(entry, m.position, m.width(), m.height(), true);
             if !self.may_enter(plan.dim) {
                 return;
             }
@@ -716,7 +858,7 @@ impl Game<'_> {
         } else if let Some(i) = self.boats.iter().position(|b| b.id == id) {
             let b = &self.boats[i];
             let (width, height) = (super::boats::WIDTH as f32, super::boats::HEIGHT as f32);
-            let plan = self.portal_plan(entry, b.position, width, height, false);
+            let plan = self.entity_plan(entry, b.position, width, height, false);
             if !self.may_enter(plan.dim) {
                 return;
             }
@@ -741,7 +883,7 @@ impl Game<'_> {
                 super::minecarts::WIDTH as f32,
                 super::minecarts::HEIGHT as f32,
             );
-            let plan = self.portal_plan(entry, c.position, width, height, false);
+            let plan = self.entity_plan(entry, c.position, width, height, false);
             if !self.may_enter(plan.dim) {
                 return;
             }
@@ -754,8 +896,8 @@ impl Game<'_> {
         }
     }
     /// Entities waiting for the loaded dimension whose exit area is loaded:
-    /// their exit portal (found or built), position, turned yaw and motion,
-    /// and portal cooldown; they join the world with the chunk entities.
+    /// their exit portal (found or built) or End destination, position,
+    /// turned yaw and motion, and portal cooldown; they join the world with the chunk entities.
     pub(super) fn resolve_arrivals(&mut self) {
         if self.remote.is_some() {
             return;
@@ -772,21 +914,26 @@ impl Game<'_> {
             }
             let Arrival { plan, mut tag } = self.portals.arrivals.remove(i);
             self.portals.dirty = true;
-            let Some(exit) = self.nether_exit_portal(&plan) else {
-                continue;
-            };
-            let (at, rotation) = self.arrival(&plan, exit);
-            let motion = rotate_y(horizon_client::entity_nbt::motion(&tag), -rotation);
+            let motion = horizon_client::entity_nbt::motion(&tag);
             let [yaw, pitch] = horizon_client::entity_nbt::rotation(&tag);
+            let (at, motion, yaw) = if plan.end {
+                // Relative.DELTA and X_ROT: the motion and pitch are kept;
+                // the yaw faces west into the End, and is kept out of it.
+                let (at, west) = self.end_portal_exit(&plan);
+                (at, motion, west.unwrap_or(yaw))
+            } else {
+                let Some(exit) = self.nether_exit_portal(&plan) else {
+                    continue;
+                };
+                let (at, rotation) = self.arrival(&plan, exit);
+                (at, rotate_y(motion, -rotation), yaw + rotation)
+            };
             if let Tag::Compound(c) = &mut tag {
                 c.insert("Pos".into(), doubles([at.x, at.y, at.z]));
                 c.insert("Motion".into(), doubles([motion.x, motion.y, motion.z]));
                 c.insert(
                     "Rotation".into(),
-                    Tag::List(vec![
-                        Tag::Float((yaw + rotation).to_bits()),
-                        Tag::Float(pitch.to_bits()),
-                    ]),
+                    Tag::List(vec![Tag::Float(yaw.to_bits()), Tag::Float(pitch.to_bits())]),
                 );
                 // setPortalCooldown before the teleport, copied by restoreFrom.
                 c.insert("PortalCooldown".into(), Tag::Int(ENTITY_DELAY));
@@ -823,75 +970,99 @@ impl Game<'_> {
         let Some(Tag::List(list)) = root.get("arrivals") else {
             return;
         };
-        for a in list {
-            let int = |k: &str| match a.get(k) {
-                Some(Tag::Int(v)) => Some(*v),
-                _ => None,
-            };
-            let float = |k: &str| match a.get(k) {
-                Some(Tag::Float(v)) => Some(f32::from_bits(*v)),
-                _ => None,
-            };
-            let double = |k: &str| match a.get(k) {
-                Some(Tag::Double(v)) => Some(f64::from_bits(*v)),
-                _ => None,
-            };
-            let dim = match horizon_client::save::text(a.get("dimension")).as_deref() {
-                Some("minecraft:the_nether") => Dim::Nether,
-                Some(_) => Dim::Overworld,
-                None => continue,
-            };
-            let (Some(x), Some(y), Some(z), Some(tag)) =
-                (int("x"), int("y"), int("z"), a.get("entity"))
-            else {
-                continue;
-            };
-            self.portals.arrivals.push(Arrival {
-                plan: Plan {
-                    dim,
-                    approximate: BlockPos::new(x, y, z),
-                    entry_x_axis: int("x_axis").unwrap_or(1) != 0,
-                    offset: Vec3::new(
-                        double("right").unwrap_or(0.5),
-                        double("up").unwrap_or(0.0),
-                        double("forward").unwrap_or(0.0),
-                    ),
-                    width: float("width").unwrap_or(0.25),
-                    height: float("height").unwrap_or(0.25),
-                },
-                tag: tag.clone(),
-            });
-        }
+        self.portals
+            .arrivals
+            .extend(list.iter().filter_map(arrival_from_tag));
     }
     /// Write the waiting entities when they changed.
     pub(super) fn save_portal_arrivals(&mut self) {
         if !self.portals.dirty || self.remote.is_some() {
             return;
         }
-        let list = self
-            .portals
-            .arrivals
-            .iter()
-            .map(|a| {
-                let p = &a.plan;
-                Tag::compound([
-                    ("dimension", Tag::String(p.dim.id().into())),
-                    ("x", Tag::Int(p.approximate.x)),
-                    ("y", Tag::Int(p.approximate.y)),
-                    ("z", Tag::Int(p.approximate.z)),
-                    ("x_axis", Tag::Int(i32::from(p.entry_x_axis))),
-                    ("right", Tag::Double(p.offset.x.to_bits())),
-                    ("up", Tag::Double(p.offset.y.to_bits())),
-                    ("forward", Tag::Double(p.offset.z.to_bits())),
-                    ("width", Tag::Float(p.width.to_bits())),
-                    ("height", Tag::Float(p.height.to_bits())),
-                    ("entity", a.tag.clone()),
-                ])
-            })
-            .collect();
+        let list = self.portals.arrivals.iter().map(arrival_tag).collect();
         let root = Tag::compound([("arrivals", Tag::List(list))]);
         if horizon_client::save::write_dat(&self.arrivals_path(), root).is_ok() {
             self.portals.dirty = false;
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn end_portals_lead_to_the_end_spawn_and_back_to_the_world_spawn() {
+        let spawn = BlockPos::new(-7, 70, 12);
+        for from in [Dim::Overworld, Dim::Nether] {
+            let plan = Plan::end_portal(from, spawn, 0.9, 1.4);
+            assert_eq!(plan.dim, Dim::End);
+            assert_eq!(plan.approximate, BlockPos::new(100, 50, 0));
+            assert!(plan.end);
+        }
+        let plan = Plan::end_portal(Dim::End, spawn, 0.25, 0.25);
+        assert_eq!(plan.dim, Dim::Overworld);
+        assert_eq!(plan.approximate, spawn);
+    }
+
+    #[test]
+    fn the_end_portal_shape_takes_falling_items_and_standing_mobs() {
+        let portal = BlockPos::new(0, 100, 3);
+        let at = |y| Vec3::new(0.5, y, 3.5);
+        // A dropped item falling through the slab, or in it.
+        assert!(touches_end_portal(
+            at(100.6),
+            at(100.56),
+            0.25,
+            0.25,
+            portal
+        ));
+        // One tick's fall across the whole slab, in it at neither end.
+        assert!(touches_end_portal(at(101.0), at(99.9), 0.25, 0.25, portal));
+        // Resting below the slab (on the floor) or above it.
+        assert!(!touches_end_portal(
+            at(100.0),
+            at(100.0),
+            0.25,
+            0.25,
+            portal
+        ));
+        assert!(!touches_end_portal(
+            at(100.8),
+            at(100.8),
+            0.25,
+            0.25,
+            portal
+        ));
+        // A cow standing in the portal block.
+        assert!(touches_end_portal(at(100.0), at(100.0), 0.9, 1.4, portal));
+        // Beside it.
+        let beside = Vec3::new(2.0, 100.0, 3.5);
+        assert!(!touches_end_portal(beside, beside, 0.9, 1.4, portal));
+    }
+
+    #[test]
+    fn waiting_arrivals_keep_their_end_destination_when_saved() {
+        let tag = Tag::compound([("id", Tag::String("minecraft:cow".into()))]);
+        for (from, dim) in [(Dim::Overworld, Dim::End), (Dim::End, Dim::Overworld)] {
+            let arrival = Arrival {
+                plan: Plan::end_portal(from, BlockPos::new(3, 64, -5), 0.9, 1.4),
+                tag: tag.clone(),
+            };
+            let back = arrival_from_tag(&arrival_tag(&arrival)).unwrap();
+            assert_eq!(back.plan.dim, dim);
+            assert_eq!(back.plan.approximate, arrival.plan.approximate);
+            assert!(back.plan.end);
+            assert_eq!(back.tag, tag);
+        }
+        // Arrivals saved before End portals were Nether portal plans.
+        let mut old = arrival_tag(&Arrival {
+            plan: Plan::end_portal(Dim::End, BlockPos::new(0, 64, 0), 0.25, 0.25),
+            tag,
+        });
+        if let Tag::Compound(c) = &mut old {
+            c.remove(&"end".into());
+        }
+        assert!(!arrival_from_tag(&old).unwrap().plan.end);
+    }
+}

From b2199f5a0e45eb18cc0b24c75ef3f1b55c976c85 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:48:35 +0100
Subject: [PATCH 432/475] launcher: a skin and a cape for each offline name

Settings > Account's Skin... shows the front of an offline name's skin and cape, takes a
skin PNG (64x64 or 64x32) and a cape PNG (64x32 or 22x17), and picks classic or slim arms.
The launcher keeps copies in skins/ and gives the game HORIZON_OFFLINE_SKIN,
HORIZON_OFFLINE_SKIN_MODEL and HORIZON_OFFLINE_CAPE when that name plays. CLI and MCP:
account skin.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md   |  15 +++
 launcher/README.md          |   7 ++
 launcher/src/account.rs     |  20 ++++
 launcher/src/cli.rs         |  78 ++++++++++++-
 launcher/src/lib.rs         |   1 +
 launcher/src/main.rs        |   5 +
 launcher/src/skin_page.rs   | 225 ++++++++++++++++++++++++++++++++++++
 launcher/src/skins.rs       | 176 ++++++++++++++++++++++++++++
 launcher/src/skins/tests.rs | 104 +++++++++++++++++
 launcher/src/switch_page.rs |  14 ++-
 10 files changed, 642 insertions(+), 3 deletions(-)
 create mode 100644 launcher/src/skin_page.rs
 create mode 100644 launcher/src/skins.rs
 create mode 100644 launcher/src/skins/tests.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 842a3c3c2..893bbd567 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -144,6 +144,21 @@ Forget one of your offline names.
 
 MCP: `account_forget_offline`.
 
+## `horizon-launcher account skin`
+
+Show or set an offline name's skin and cape: a 64x64 (or 64x32) skin PNG, a 64x32 cape PNG, the model. Kept by the launcher and given to the game when that name plays.
+
+    horizon-launcher account skin <NAME> [FILE]
+
+- `NAME`
+- `FILE`: The skin's PNG
+- `--model`: classic or slim arms
+- `--cape`: The cape's PNG
+- `--no-skin`: Back to the default skin
+- `--no-cape`: Take the cape off
+
+MCP: `account_skin`.
+
 ## `horizon-launcher settings`
 
 Show the launcher's settings, or set one (the Settings page): selected-version TAG, minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions on|off, opening-animation on|off, proxy http://host:port ("default" removes it), while-playing stay|minimize|hide (what the window does while the game runs).
diff --git a/launcher/README.md b/launcher/README.md
index 93115c479..d76d8d897 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -129,6 +129,13 @@ The opening, then Play ([clip](docs/opening.webm)):
   the Console's Share log takes them out of the log too. `horizon-launcher account offline
   [NAME]`, `account select <name>` (an account or an offline name), `account forget-offline
   <name>`.
+- **Skin and cape**: each offline name's **Skin…** in Settings > Account shows the front of its
+  skin and cape, takes a skin PNG (64×64, or the older 64×32) and a cape PNG (64×32), and picks
+  classic or slim arms. The launcher keeps copies in its `skins/` folder and gives the game
+  `HORIZON_OFFLINE_SKIN`, `HORIZON_OFFLINE_SKIN_MODEL` and `HORIZON_OFFLINE_CAPE` when that name
+  plays; the game draws the default skins until it reads them. A Microsoft account's skin and
+  cape: coming soon, with sign-in. `horizon-launcher account skin <name> [FILE] [--model
+  classic|slim] [--cape FILE] [--no-skin] [--no-cape]`.
 - **Console**: Home's Console shows the game's output of this run as it comes: a search (every
   word, any case), Follow to keep the newest line in view, Copy, and Open logs folder. Warnings
   and errors stand out. **Share log…** uploads the log to [mclo.gs](https://mclo.gs), a paste
diff --git a/launcher/src/account.rs b/launcher/src/account.rs
index f402fe5ce..257055911 100644
--- a/launcher/src/account.rs
+++ b/launcher/src/account.rs
@@ -645,6 +645,9 @@ pub struct Accounts {
     /// (`horizon-player.txt`).
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub offline_selected: Option<String>,
+    /// Each offline name's skin and cape (`skins`), by the name in lowercase.
+    #[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
+    pub looks: std::collections::BTreeMap<String, crate::skins::Look>,
 }
 
 /// Who plays, as the quick switch lists them.
@@ -761,6 +764,7 @@ impl Accounts {
     pub fn remove_offline(&mut self, name: &str) -> Result<(), String> {
         let before = self.offline.len();
         self.offline.retain(|n| !n.eq_ignore_ascii_case(name));
+        self.looks.remove(&name.to_ascii_lowercase());
         if self.offline.len() == before {
             return Err(format!("No offline name {name}."));
         }
@@ -774,6 +778,22 @@ impl Accounts {
         Ok(())
     }
 
+    /// An offline name's look (the default: no skin of its own).
+    pub fn look(&self, name: &str) -> crate::skins::Look {
+        self.looks
+            .get(&name.to_ascii_lowercase())
+            .cloned()
+            .unwrap_or_default()
+    }
+
+    /// The game's variables for the offline name that plays: its skin and cape.
+    pub fn look_env(&self) -> Vec<(&'static str, String)> {
+        match self.name_arg() {
+            Some(name) => crate::skins::env(&crate::skins::dir(), name, &self.look(name)),
+            None => Vec::new(),
+        }
+    }
+
     /// The game's `--name` for this run: the offline name, when one plays.
     pub fn name_arg(&self) -> Option<&str> {
         match self.selected() {
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 8153c7968..97f3eed09 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -93,6 +93,25 @@ enum AccountCmd {
     Offline { name: Option<String> },
     /// Forget one of your offline names
     ForgetOffline { name: String },
+    /// Show or set an offline name's skin and cape: a 64x64 (or 64x32) skin PNG, a 64x32 cape
+    /// PNG, the model. Kept by the launcher and given to the game when that name plays
+    Skin {
+        name: String,
+        /// The skin's PNG
+        file: Option<PathBuf>,
+        /// classic or slim arms
+        #[arg(long)]
+        model: Option<String>,
+        /// The cape's PNG
+        #[arg(long)]
+        cape: Option<PathBuf>,
+        /// Back to the default skin
+        #[arg(long)]
+        no_skin: bool,
+        /// Take the cape off
+        #[arg(long)]
+        no_cape: bool,
+    },
 }
 
 #[derive(Subcommand)]
@@ -963,9 +982,11 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
             }
             cmd.args(arg);
             let started = std::time::Instant::now();
-            if let Some(name) = Accounts::load().name_arg() {
+            let accounts = Accounts::load();
+            if let Some(name) = accounts.name_arg() {
                 cmd.arg("--name").arg(name);
             }
+            cmd.envs(accounts.look_env());
             let played = attached(horizon_launcher::launch::wrap(cmd, &instance.launch));
             if let Err(e) = instances::record_play(&instance.id, started.elapsed()) {
                 eprintln!("Play time not saved: {e}");
@@ -1332,6 +1353,61 @@ fn account_command(action: AccountCmd, as_json: bool) -> Result<(), String> {
                 None => println!("The game plays offline, as the name it made up."),
             }
         }
+        AccountCmd::Skin {
+            name,
+            file,
+            model,
+            cape,
+            no_skin,
+            no_cape,
+        } => {
+            use horizon_launcher::skins::{self, Model};
+            let name = accounts
+                .offline
+                .iter()
+                .find(|n| n.eq_ignore_ascii_case(&name))
+                .cloned()
+                .ok_or_else(|| {
+                    format!("No offline name {name}: add it with `account offline {name}`.")
+                })?;
+            let model = match model.as_deref() {
+                None => None,
+                Some("classic") => Some(Model::Classic),
+                Some("slim") => Some(Model::Slim),
+                Some(m) => return Err(format!("{m}: say classic or slim")),
+            };
+            let mut look = accounts.look(&name);
+            if let Some(file) = &file {
+                skins::keep(&skins::dir(), &name, file, false)?;
+                look.skin = true;
+            }
+            if let Some(file) = &cape {
+                skins::keep(&skins::dir(), &name, file, true)?;
+                look.cape = true;
+            }
+            if let Some(m) = model {
+                look.model = m;
+            }
+            look.skin &= !no_skin;
+            look.cape &= !no_cape;
+            accounts
+                .looks
+                .insert(name.to_ascii_lowercase(), look.clone());
+            accounts.save()?;
+            if as_json {
+                json(serde_json::json!({
+                    "name": name, "skin": look.skin, "cape": look.cape, "model": look.model.name(),
+                }));
+            } else {
+                let say = |on: bool, what: &str| if on { what.to_string() } else { "none".into() };
+                println!(
+                    "{name}: skin {} ({} arms), cape {}",
+                    say(look.skin, "kept"),
+                    look.model.name(),
+                    say(look.cape, "kept")
+                );
+            }
+        }
         AccountCmd::ForgetOffline { name } => {
             accounts.remove_offline(&name)?;
             accounts.save()?;
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index 96951905f..4d8cfaaf3 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -24,6 +24,7 @@ pub mod server_list;
 pub mod servers;
 pub mod shortcut;
 pub mod signed;
+pub mod skins;
 pub mod sources;
 pub mod tailscale;
 pub mod telemetry;
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 1496dbe59..5532b468d 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -32,6 +32,7 @@ mod screenshots_page;
 mod scrollbar;
 mod servers_page;
 mod shortcut_page;
+mod skin_page;
 mod switch_page;
 mod theme;
 mod titlebar;
@@ -167,6 +168,8 @@ struct Launcher {
     picker_open: bool,
     /// The top bar's quick switch of who plays (`switch_page.rs`).
     account_menu: bool,
+    /// Settings > Account's skin panel for an offline name (`skin_page.rs`).
+    skin: Option<skin_page::SkinPanel>,
     settings: Settings,
     /// The Discord, sponsor and website links: built in until links.json on main has been read.
     links: backend::Links,
@@ -366,6 +369,7 @@ impl Launcher {
             confirm_remove: None,
             picker_open: false,
             account_menu: false,
+            skin: None,
             args_input: settings.game_args.clone(),
             args_focused: false,
             args_focus: cx.focus_handle(),
@@ -592,6 +596,7 @@ impl Launcher {
                         if let Some(name) = self.accounts.name_arg() {
                             cmd.arg("--name").arg(name);
                         }
+                        cmd.envs(self.accounts.look_env());
                         // A pack's Play button plays that pack; Play plays the selected instance.
                         let (profile, run) = match self.starting_pack.take() {
                             Some(work) => {
diff --git a/launcher/src/skin_page.rs b/launcher/src/skin_page.rs
new file mode 100644
index 000000000..00e977216
--- /dev/null
+++ b/launcher/src/skin_page.rs
@@ -0,0 +1,225 @@
+//! Settings > Account's skin panel for an offline name (`horizon_launcher::skins`): the front
+//! of the skin and the cape, choosing either from a PNG, and the model.
+use super::*;
+use gpui::RenderImage;
+use horizon_launcher::skins::{self, Model};
+use std::path::PathBuf;
+use std::sync::Arc;
+
+/// A baked preview, or None without one.
+type Preview = Option<Arc<RenderImage>>;
+
+#[derive(Default)]
+pub(super) struct SkinPanel {
+    /// The offline name it is for.
+    pub(super) name: String,
+    /// The two previews, baked at the window's scale (skin, cape), or None without one.
+    seen: Option<(f32, Preview, Preview)>,
+    /// What the last choice did, or why not.
+    note: Option<Result<String, String>>,
+}
+
+/// Points per skin texel in the preview.
+const TEXEL: f32 = 6.;
+
+impl Launcher {
+    pub(super) fn open_skin(&mut self, name: String) {
+        self.skin = match self.skin.take() {
+            Some(p) if p.name == name => None,
+            _ => Some(SkinPanel {
+                name,
+                ..SkinPanel::default()
+            }),
+        };
+    }
+
+    fn save_look(&mut self, change: impl FnOnce(&mut skins::Look)) -> Result<(), String> {
+        let Some(name) = self.skin.as_ref().map(|p| p.name.clone()) else {
+            return Ok(());
+        };
+        let mut accounts = Accounts::load();
+        let mut look = accounts.look(&name);
+        change(&mut look);
+        accounts.looks.insert(name.to_ascii_lowercase(), look);
+        accounts.save()?;
+        self.accounts = accounts;
+        if let Some(p) = &mut self.skin {
+            p.seen = None;
+        }
+        Ok(())
+    }
+
+    fn choose_look_file(&mut self, cape: bool, cx: &mut Context<Self>) {
+        let paths = cx.prompt_for_paths(PathPromptOptions {
+            files: true,
+            directories: false,
+            multiple: false,
+            prompt: Some("Choose".into()),
+        });
+        cx.spawn(async move |this, cx| {
+            let Ok(Ok(Some(mut paths))) = paths.await else {
+                return;
+            };
+            let Some(path) = paths.pop() else {
+                return;
+            };
+            let _ = this.update(cx, |this, cx| {
+                this.take_look_file(path, cape);
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    pub(super) fn take_look_file(&mut self, path: PathBuf, cape: bool) {
+        let Some(name) = self.skin.as_ref().map(|p| p.name.clone()) else {
+            return;
+        };
+        let done = skins::keep(&skins::dir(), &name, &path, cape).and_then(|()| {
+            self.save_look(|l| match cape {
+                false => l.skin = true,
+                true => l.cape = true,
+            })
+        });
+        let what = if cape { "cape" } else { "skin" };
+        if let Some(p) = &mut self.skin {
+            p.note = Some(done.map(|()| format!("{name}'s {what} is kept.")));
+        }
+    }
+
+    fn previews(&mut self) -> (Preview, Preview) {
+        let scale = self.scale;
+        let Some(panel) = &mut self.skin else {
+            return (None, None);
+        };
+        if let Some((s, skin, cape)) = &panel.seen {
+            if *s == scale {
+                return (skin.clone(), cape.clone());
+            }
+        }
+        let look = self.accounts.look(&panel.name);
+        let (skin_file, cape_file) = skins::files(&skins::dir(), &panel.name);
+        let read = |f: &PathBuf| std::fs::read(f).ok();
+        let skin = read(&skin_file)
+            .filter(|_| look.skin)
+            .and_then(|b| skins::read_skin(&b).ok())
+            .map(|png| art::bake(&skins::front(&png, look.model), 16, 32, TEXEL, scale));
+        let cape = read(&cape_file)
+            .filter(|_| look.cape)
+            .and_then(|b| skins::read_cape(&b).ok())
+            .map(|png| art::bake(&skins::cape_front(&png), 10, 16, TEXEL, scale));
+        panel.seen = Some((scale, skin.clone(), cape.clone()));
+        (skin, cape)
+    }
+
+    /// The panel, under the offline names while open.
+    pub(super) fn skin_panel(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let name = self.skin.as_ref()?.name.clone();
+        if !self.accounts.offline.iter().any(|n| n == &name) {
+            self.skin = None;
+            return None;
+        }
+        let look = self.accounts.look(&name);
+        let (skin, cape) = self.previews();
+        let frame = |w: f32, h: f32, image: Preview, empty: &'static str| {
+            div()
+                .flex()
+                .items_center()
+                .justify_center()
+                .w(px(w + 24.))
+                .h(px(h + 24.))
+                .bg(t.well)
+                .border_2()
+                .border_color(t.outline)
+                .child(match image {
+                    Some(i) => gpui::img(i).w(px(w)).h(px(h)).into_any_element(),
+                    None => text(theme::CAPTION)
+                        .text_color(t.muted)
+                        .child(empty)
+                        .into_any_element(),
+                })
+        };
+        let weak = cx.entity().downgrade();
+        let model = segments(
+            "skin-model",
+            &[(Model::Classic, "Classic arms"), (Model::Slim, "Slim arms")],
+            look.model,
+            &t,
+            move |m, _, cx| {
+                let _ = weak.update(cx, |this, cx| {
+                    let _ = this.save_look(|l| l.model = m);
+                    cx.notify();
+                });
+            },
+        );
+        let pick = |id: &'static str, label: &'static str, cape: bool, cx: &mut Context<Self>| {
+            button(id, label, Kind::Secondary, &t).on_click(cx.listener(
+                move |this, _: &ClickEvent, _, cx| {
+                    this.choose_look_file(cape, cx);
+                    cx.notify();
+                },
+            ))
+        };
+        let drop = |id: &'static str, label: &'static str, cape: bool, cx: &mut Context<Self>| {
+            button(id, label, Kind::Ghost, &t).on_click(cx.listener(
+                move |this, _: &ClickEvent, _, cx| {
+                    let _ = this.save_look(|l| match cape {
+                        false => l.skin = false,
+                        true => l.cape = false,
+                    });
+                    cx.notify();
+                },
+            ))
+        };
+        let mut skin_buttons =
+            div()
+                .flex()
+                .gap(px(6.))
+                .child(pick("skin-choose", "Choose a skin…", false, cx));
+        if look.skin {
+            skin_buttons = skin_buttons.child(drop("skin-remove", "Default skin", false, cx));
+        }
+        let mut cape_buttons =
+            div()
+                .flex()
+                .gap(px(6.))
+                .child(pick("cape-choose", "Choose a cape…", true, cx));
+        if look.cape {
+            cape_buttons = cape_buttons.child(drop("cape-remove", "No cape", true, cx));
+        }
+        let note = self.skin.as_ref().and_then(|p| p.note.clone());
+        Some(
+            plate(&t)
+                .flex()
+                .gap(px(20.))
+                .px(px(16.))
+                .py(px(14.))
+                .ml(px(40.))
+                .child(frame(16. * TEXEL, 32. * TEXEL, skin, "Default"))
+                .child(frame(10. * TEXEL, 16. * TEXEL, cape, "No cape"))
+                .child(
+                    div()
+                        .flex()
+                        .flex_col()
+                        .flex_1()
+                        .min_w_0()
+                        .gap(px(12.))
+                        .child(caps(format!("{name}'s skin")).text_color(t.muted))
+                        .child(skin_buttons)
+                        .child(model)
+                        .child(cape_buttons)
+                        .children(note.map(|n| match n {
+                            Ok(said) => text(theme::CAPTION).text_color(t.muted).child(said),
+                            Err(e) => text(theme::CAPTION).text_color(t.danger).child(e),
+                        }))
+                        .child(text(theme::CAPTION).text_color(t.muted).child(
+                            "A 64×64 (or 64×32) skin PNG and a 64×32 cape PNG, kept by the \
+                             launcher and given to the game when this name plays. The game \
+                             draws the default skins for now; it uses these once it can. A \
+                             Microsoft account's skin and cape: coming soon.",
+                        )),
+                ),
+        )
+    }
+}
diff --git a/launcher/src/skins.rs b/launcher/src/skins.rs
new file mode 100644
index 000000000..c80cc9b90
--- /dev/null
+++ b/launcher/src/skins.rs
@@ -0,0 +1,176 @@
+//! Offline skins and capes: a PNG the player picks for an offline name, kept in the launcher's
+//! `skins/` folder, with its model (classic arms or slim). The game gets them in
+//! `HORIZON_OFFLINE_SKIN`, `HORIZON_OFFLINE_SKIN_MODEL` and `HORIZON_OFFLINE_CAPE` when that
+//! name plays; a game that doesn't read them yet draws the default skin, as before.
+//!
+//! Skins are the layout every Java Edition skin uses: 64×64, or the older 64×32 (whose left arm
+//! and leg are the right ones mirrored). Capes are 64×32 (or the older 22×17).
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+
+pub const SKIN_ENV: &str = "HORIZON_OFFLINE_SKIN";
+pub const MODEL_ENV: &str = "HORIZON_OFFLINE_SKIN_MODEL";
+pub const CAPE_ENV: &str = "HORIZON_OFFLINE_CAPE";
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Model {
+    /// Four-pixel arms ("Steve").
+    #[default]
+    Classic,
+    /// Three-pixel arms ("Alex").
+    Slim,
+}
+
+impl Model {
+    pub fn name(self) -> &'static str {
+        match self {
+            Model::Classic => "classic",
+            Model::Slim => "slim",
+        }
+    }
+}
+
+/// What an offline name wears.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Look {
+    #[serde(default)]
+    pub model: Model,
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub skin: bool,
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub cape: bool,
+}
+
+/// Where an offline name's files are: `skins/<name>.png` and `skins/<name>.cape.png`, the name
+/// in lowercase (offline names are kept once in any case).
+pub fn files(dir: &Path, name: &str) -> (PathBuf, PathBuf) {
+    let key = name.to_ascii_lowercase();
+    (
+        dir.join(format!("{key}.png")),
+        dir.join(format!("{key}.cape.png")),
+    )
+}
+
+pub fn dir() -> PathBuf {
+    crate::backend::data_dir().join("skins")
+}
+
+fn decode(bytes: &[u8]) -> Result<image::RgbaImage, String> {
+    image::load_from_memory_with_format(bytes, image::ImageFormat::Png)
+        .map(|i| i.to_rgba8())
+        .map_err(|_| "That isn't a PNG picture.".to_string())
+}
+
+/// A skin's picture, if it is one: 64×64 or 64×32.
+pub fn read_skin(bytes: &[u8]) -> Result<image::RgbaImage, String> {
+    let png = decode(bytes)?;
+    match png.dimensions() {
+        (64, 64) | (64, 32) => Ok(png),
+        (w, h) => Err(format!(
+            "A skin is 64×64 (or the older 64×32) pixels; this one is {w}×{h}."
+        )),
+    }
+}
+
+/// A cape's picture, if it is one: 64×32 or 22×17.
+pub fn read_cape(bytes: &[u8]) -> Result<image::RgbaImage, String> {
+    let png = decode(bytes)?;
+    match png.dimensions() {
+        (64, 32) | (22, 17) => Ok(png),
+        (w, h) => Err(format!(
+            "A cape is 64×32 (or the older 22×17) pixels; this one is {w}×{h}."
+        )),
+    }
+}
+
+/// A part of the skin copied to the front view: from (x, y), its size, to (x, y), mirrored.
+type Part = (u32, u32, u32, u32, u32, u32, bool);
+
+/// The front of the player, 16×32 texels: head, body, arms and legs, each with its outer layer
+/// over it (64×64 skins have one for every part; 64×32 only for the head).
+pub fn front(skin: &image::RgbaImage, model: Model) -> Vec<[u8; 4]> {
+    let w = 16usize;
+    let mut out = vec![[0u8; 4]; w * 32];
+    let modern = skin.height() == 64;
+    let arm = if model == Model::Slim { 3 } else { 4 };
+    let mut base: Vec<Part> = vec![
+        (8, 8, 8, 8, 4, 0, false),            // head
+        (20, 20, 8, 12, 4, 8, false),         // body
+        (44, 20, arm, 12, 4 - arm, 8, false), // right arm, on the viewer's left
+        (4, 20, 4, 12, 4, 20, false),         // right leg
+    ];
+    let mut outer: Vec<Part> = vec![(40, 8, 8, 8, 4, 0, false)];
+    if modern {
+        base.extend([
+            (36, 52, arm, 12, 12, 8, false),
+            (20, 52, 4, 12, 8, 20, false),
+        ]);
+        outer.extend([
+            (20, 36, 8, 12, 4, 8, false),
+            (44, 36, arm, 12, 4 - arm, 8, false),
+            (52, 52, arm, 12, 12, 8, false),
+            (4, 36, 4, 12, 4, 20, false),
+            (4, 52, 4, 12, 8, 20, false),
+        ]);
+    } else {
+        base.extend([(44, 20, arm, 12, 12, 8, true), (4, 20, 4, 12, 8, 20, true)]);
+    }
+    for (layer, parts) in [base, outer].into_iter().enumerate() {
+        for (fx, fy, pw, ph, tx, ty, mirrored) in parts {
+            for dy in 0..ph {
+                for dx in 0..pw {
+                    let sx = if mirrored { fx + pw - 1 - dx } else { fx + dx };
+                    let c = skin.get_pixel(sx, fy + dy).0;
+                    // The base layer is opaque in game; the outer one shows where it is drawn.
+                    if layer == 0 || c[3] > 0 {
+                        out[(ty + dy) as usize * w + (tx + dx) as usize] = [c[0], c[1], c[2], 255];
+                    }
+                }
+            }
+        }
+    }
+    out
+}
+
+/// The cape's outside, 10×16 texels.
+pub fn cape_front(cape: &image::RgbaImage) -> Vec<[u8; 4]> {
+    let mut out = Vec::with_capacity(160);
+    for y in 1..17 {
+        for x in 1..11 {
+            out.push(cape.get_pixel(x, y).0);
+        }
+    }
+    out
+}
+
+/// Keeps `file` as `name`'s skin (or cape), checked first.
+pub fn keep(dir: &Path, name: &str, file: &Path, cape: bool) -> Result<(), String> {
+    let bytes = std::fs::read(file).map_err(|e| format!("{}: {e}", file.display()))?;
+    match cape {
+        false => read_skin(&bytes).map(|_| ())?,
+        true => read_cape(&bytes).map(|_| ())?,
+    }
+    std::fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let (skin, cape_file) = files(dir, name);
+    let to = if cape { cape_file } else { skin };
+    std::fs::write(&to, bytes).map_err(|e| format!("{}: {e}", to.display()))
+}
+
+/// The variables the game gets for `name`'s look.
+pub fn env(dir: &Path, name: &str, look: &Look) -> Vec<(&'static str, String)> {
+    let (skin, cape) = files(dir, name);
+    let mut out = Vec::new();
+    if look.skin && skin.is_file() {
+        out.push((SKIN_ENV, skin.to_string_lossy().into_owned()));
+        out.push((MODEL_ENV, look.model.name().to_string()));
+    }
+    if look.cape && cape.is_file() {
+        out.push((CAPE_ENV, cape.to_string_lossy().into_owned()));
+    }
+    out
+}
+
+#[cfg(test)]
+#[path = "skins/tests.rs"]
+mod tests;
diff --git a/launcher/src/skins/tests.rs b/launcher/src/skins/tests.rs
new file mode 100644
index 000000000..6ce0473c5
--- /dev/null
+++ b/launcher/src/skins/tests.rs
@@ -0,0 +1,104 @@
+use super::*;
+
+/// A skin whose every texel says where it is: red = x, green = y.
+fn mapped(height: u32) -> image::RgbaImage {
+    image::RgbaImage::from_fn(64, height, |x, y| image::Rgba([x as u8, y as u8, 0, 255]))
+}
+
+fn png(img: &image::RgbaImage) -> Vec<u8> {
+    let mut out = std::io::Cursor::new(Vec::new());
+    img.write_to(&mut out, image::ImageFormat::Png).unwrap();
+    out.into_inner()
+}
+
+#[test]
+fn the_front_view_takes_each_part_from_its_place() {
+    let mut skin = mapped(64);
+    // No outer layer, except one hat texel.
+    for (x, y) in (0..64).flat_map(|x| (0..64).map(move |y| (x, y))) {
+        let outer = (40..48).contains(&x) && y < 16
+            || (16..56).contains(&x) && (32..48).contains(&y)
+            || (0..16).contains(&x) && (48..64).contains(&y)
+            || (48..64).contains(&x) && (48..64).contains(&y);
+        if outer {
+            skin.put_pixel(x, y, image::Rgba([0, 0, 0, 0]));
+        }
+    }
+    skin.put_pixel(41, 9, image::Rgba([200, 0, 9, 255]));
+    let f = front(&skin, Model::Classic);
+    let at = |x: usize, y: usize| f[y * 16 + x];
+    assert_eq!(at(4, 0), [8, 8, 0, 255], "head front starts at (8, 8)");
+    assert_eq!(at(5, 1), [200, 0, 9, 255], "the hat covers it");
+    assert_eq!(at(4, 8), [20, 20, 0, 255], "body");
+    assert_eq!(at(0, 8), [44, 20, 0, 255], "right arm");
+    assert_eq!(
+        at(12, 8),
+        [36, 52, 0, 255],
+        "left arm, its own on a 64×64 skin"
+    );
+    assert_eq!(at(8, 20), [20, 52, 0, 255], "left leg");
+    let slim = front(&skin, Model::Slim);
+    assert_eq!(slim[8 * 16], [0, 0, 0, 0], "slim arms leave a column");
+    assert_eq!(slim[8 * 16 + 1], [44, 20, 0, 255]);
+}
+
+#[test]
+fn an_old_skin_mirrors_its_right_limbs() {
+    let f = front(&mapped(32), Model::Classic);
+    let at = |x: usize, y: usize| f[y * 16 + x];
+    assert_eq!(
+        at(12, 8),
+        [47, 20, 0, 255],
+        "the left arm is the right one mirrored"
+    );
+    assert_eq!(at(15, 8), [44, 20, 0, 255]);
+    assert_eq!(at(8, 20), [7, 20, 0, 255]);
+}
+
+#[test]
+fn only_skin_and_cape_sizes_are_kept() {
+    assert!(read_skin(&png(&mapped(64))).is_ok());
+    assert!(read_skin(&png(&mapped(32))).is_ok());
+    let big = image::RgbaImage::new(128, 128);
+    assert_eq!(
+        read_skin(&png(&big)).unwrap_err(),
+        "A skin is 64×64 (or the older 64×32) pixels; this one is 128×128."
+    );
+    assert!(read_skin(b"not a png").unwrap_err().contains("isn't a PNG"));
+    assert!(read_cape(&png(&mapped(32))).is_ok());
+    assert!(read_cape(&png(&image::RgbaImage::new(22, 17))).is_ok());
+    assert!(read_cape(&png(&mapped(64))).is_err());
+    assert_eq!(cape_front(&mapped(32))[0], [1, 1, 0, 255]);
+}
+
+#[test]
+fn a_kept_look_reaches_the_game_only_with_its_files() {
+    let root = std::env::temp_dir().join(format!("horizon-skins-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&root);
+    std::fs::create_dir_all(&root).unwrap();
+    let (good, bad) = (root.join("alex.png"), root.join("big.png"));
+    std::fs::write(&good, png(&mapped(64))).unwrap();
+    std::fs::write(&bad, png(&image::RgbaImage::new(10, 10))).unwrap();
+    let dir = root.join("skins");
+    let look = Look {
+        model: Model::Slim,
+        skin: true,
+        cape: true,
+    };
+    assert!(env(&dir, "Alex", &look).is_empty(), "nothing kept yet");
+    keep(&dir, "Alex", &good, false).unwrap();
+    assert!(keep(&dir, "Alex", &bad, true).is_err());
+    let (skin, _) = files(&dir, "ALEX");
+    assert_eq!(
+        env(&dir, "alex", &look),
+        [
+            (SKIN_ENV, skin.to_string_lossy().into_owned()),
+            (MODEL_ENV, "slim".to_string())
+        ]
+    );
+    assert_eq!(
+        serde_json::to_string(&Look::default()).unwrap(),
+        r#"{"model":"classic"}"#
+    );
+    std::fs::remove_dir_all(&root).unwrap();
+}
diff --git a/launcher/src/switch_page.rs b/launcher/src/switch_page.rs
index 3b6bdac14..a29d21044 100644
--- a/launcher/src/switch_page.rs
+++ b/launcher/src/switch_page.rs
@@ -169,6 +169,15 @@ impl Launcher {
                     ),
                 );
             }
+            let dressed = name.clone();
+            actions = actions.child(
+                button(format!("offline-skin-{i}"), "Skin…", Kind::Ghost, &t).on_click(
+                    cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        this.open_skin(dressed.clone());
+                        cx.notify();
+                    }),
+                ),
+            );
             let forget = name.clone();
             actions = actions.child(
                 button(format!("offline-forget-{i}"), "Forget", Kind::Ghost, &t).on_click(
@@ -198,6 +207,7 @@ impl Launcher {
                 &t,
             ));
         }
+        rows = rows.children(self.skin_panel(cx));
         n += 1;
         let add = div()
             .flex()
@@ -218,8 +228,8 @@ impl Launcher {
             Some(
                 div()
                     .child(
-                        "Play offline under another name, and switch from the top bar. Offline \
-                         names have no skin, and online servers don't take them.",
+                        "Play offline under another name, and switch from the top bar. Online \
+                         servers don't take offline names.",
                     )
                     .into_any_element(),
             ),

From b3709b9766f56743ac324031cb93b49fc9384fa0 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:58:31 +0100
Subject: [PATCH 433/475] launcher: French and Russian, following the system's
 language

A string table per language (launcher/lang/<code>.json, English text to its translation)
and tr()/trf() in i18n.rs. The window follows the system's language unless Settings >
Launcher > Language picks one; a missing string shows in English. This first part
translates the top bar, the account switch and the Settings page's account, update and
launcher rows; buttons, segments, section titles and page headers translate through their
widgets. CLI: settings language system|en|fr|ru.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md     |   4 +-
 launcher/Cargo.lock           |   1 +
 launcher/Cargo.toml           |   2 +
 launcher/README.md            |   6 ++
 launcher/lang/fr.json         |  87 ++++++++++++++++++++++
 launcher/lang/ru.json         |  87 ++++++++++++++++++++++
 launcher/src/backend.rs       |  25 +++++++
 launcher/src/cli.rs           |  17 ++++-
 launcher/src/i18n.rs          | 134 +++++++++++++++++++++++++++++++++
 launcher/src/i18n/tests.rs    | 135 ++++++++++++++++++++++++++++++++++
 launcher/src/language_page.rs |  35 +++++++++
 launcher/src/lib.rs           |   1 +
 launcher/src/main.rs          |  87 ++++++++++++++--------
 launcher/src/skin_page.rs     |  15 ++--
 launcher/src/switch_page.rs   |  26 +++----
 launcher/src/while_playing.rs |   4 +-
 16 files changed, 610 insertions(+), 56 deletions(-)
 create mode 100644 launcher/lang/fr.json
 create mode 100644 launcher/lang/ru.json
 create mode 100644 launcher/src/i18n.rs
 create mode 100644 launcher/src/i18n/tests.rs
 create mode 100644 launcher/src/language_page.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 893bbd567..f5fea0192 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -161,11 +161,11 @@ MCP: `account_skin`.
 
 ## `horizon-launcher settings`
 
-Show the launcher's settings, or set one (the Settings page): selected-version TAG, minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions on|off, opening-animation on|off, proxy http://host:port ("default" removes it), while-playing stay|minimize|hide (what the window does while the game runs).
+Show the launcher's settings, or set one (the Settings page): selected-version TAG, minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions on|off, opening-animation on|off, proxy http://host:port ("default" removes it), while-playing stay|minimize|hide (what the window does while the game runs), language system|en|fr|ru (the window's language; system follows the computer's).
 
     horizon-launcher settings [KEY] [VALUE]
 
-- `KEY` (selected-version, minecraft-dir, server-dir, install-new-versions, opening-animation, proxy, while-playing)
+- `KEY` (selected-version, minecraft-dir, server-dir, install-new-versions, opening-animation, proxy, while-playing, language)
 - `VALUE`: The new value (with KEY)
 
 MCP: `settings`.
diff --git a/launcher/Cargo.lock b/launcher/Cargo.lock
index 422c2ace9..c0fa55f15 100644
--- a/launcher/Cargo.lock
+++ b/launcher/Cargo.lock
@@ -2763,6 +2763,7 @@ dependencies = [
  "serde_json",
  "sha1",
  "sha2 0.10.9",
+ "sys-locale",
  "tar",
  "toml 1.1.8+spec-1.1.0",
  "trash",
diff --git a/launcher/Cargo.toml b/launcher/Cargo.toml
index 356e8ae2e..9e65a2281 100644
--- a/launcher/Cargo.toml
+++ b/launcher/Cargo.toml
@@ -22,6 +22,8 @@ tar = { version = "0.4", default-features = false }
 toml = "1.1"
 zip = { version = "2", default-features = false, features = ["deflate"] }
 dirs = "5"
+# The system's preferred languages, for the window's language (i18n.rs).
+sys-locale = "0.3"
 self-replace = "1"
 clap = { version = "4", features = ["derive"] }
 horizon-theme = { path = "../crates/horizon-theme" }
diff --git a/launcher/README.md b/launcher/README.md
index d76d8d897..9b617064b 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -129,6 +129,12 @@ The opening, then Play ([clip](docs/opening.webm)):
   the Console's Share log takes them out of the log too. `horizon-launcher account offline
   [NAME]`, `account select <name>` (an account or an offline name), `account forget-offline
   <name>`.
+- **Language**: English, French and Russian (the languages Horizon's own game menus have).
+  The window follows the system's language unless the player picks one in Settings > Launcher
+  (each named in itself); a string a table lacks shows in English. The tables are
+  `launcher/lang/<code>.json`, English text to its translation, Horizon's own; a test fails when
+  the code asks `tr("…")` for a string a table lacks, or a table keeps one the code dropped.
+  `horizon-launcher settings language system|en|fr|ru`.
 - **Skin and cape**: each offline name's **Skin…** in Settings > Account shows the front of its
   skin and cape, takes a skin PNG (64×64, or the older 64×32) and a cape PNG (64×32), and picks
   classic or slim arms. The launcher keeps copies in its `skins/` folder and gives the game
diff --git a/launcher/lang/fr.json b/launcher/lang/fr.json
new file mode 100644
index 000000000..719f6fd52
--- /dev/null
+++ b/launcher/lang/fr.json
@@ -0,0 +1,87 @@
+{
+  "Home": "Accueil",
+  "Mods": "Mods",
+  "Servers": "Serveurs",
+  "Versions": "Versions",
+  "Patch notes": "Notes de version",
+  "Settings": "Paramètres",
+  "Accounts, updates, and the launcher itself.": "Comptes, mises à jour et le launcher lui-même.",
+  "Account": "Compte",
+  "Updates": "Mises à jour",
+  "Launcher": "Launcher",
+  "Network": "Réseau",
+  "Game": "Jeu",
+  "AI": "IA",
+  "About": "À propos",
+  "Install new versions automatically": "Installer les nouvelles versions automatiquement",
+  "Your selected version only changes if you were playing the newest one.": "Votre version choisie ne change que si vous jouiez à la plus récente.",
+  "Appearance": "Apparence",
+  "Dark": "Sombre",
+  "Light": "Clair",
+  "System": "Système",
+  "Dark by default. System follows your computer's light or dark.": "Sombre par défaut. Système suit le mode clair ou sombre de votre ordinateur.",
+  "Language": "Langue",
+  "System follows your computer's language: {language} here. A string not translated yet shows in English.": "Système suit la langue de votre ordinateur : ici {language}. Un texte pas encore traduit s'affiche en anglais.",
+  "While playing": "Pendant le jeu",
+  "Stay": "Rester",
+  "Minimise": "Réduire",
+  "Hide": "Masquer",
+  "The launcher stays open while you play.": "Le launcher reste ouvert pendant que vous jouez.",
+  "The launcher goes down when the game starts, and comes back when it closes.": "Le launcher se réduit quand le jeu démarre et revient quand il se ferme.",
+  "The launcher hides when the game starts, and comes back when it closes.": "Le launcher se masque quand le jeu démarre et revient quand il se ferme.",
+  "Show the opening": "Afficher l'ouverture",
+  "The wordmark, while the release list loads.": "Le logo, pendant que la liste des versions se charge.",
+  "{version} available": "{version} disponible",
+  "Up to date": "À jour",
+  "up to date": "à jour",
+  "Checking…": "Vérification…",
+  "downloading {version}, {percent}%": "téléchargement de {version}, {percent} %",
+  "Updated to {version}. Restart the launcher to use it.": "Mis à jour vers {version}. Redémarrez le launcher pour l'utiliser.",
+  "the update failed: {error}": "la mise à jour a échoué : {error}",
+  "Install": "Installer",
+  "Restart": "Redémarrer",
+  "Check now": "Vérifier",
+  "Open": "Ouvrir",
+  "Data folder": "Dossier des données",
+  "Logs": "Journaux",
+  "crash reports beside it": "rapports de plantage à côté",
+  "Applications menu": "Menu des applications",
+  "Horizon and its icon are in your desktop's menu.": "Horizon et son icône sont dans le menu de votre bureau.",
+  "Not in your desktop's menu.": "Pas dans le menu de votre bureau.",
+  "Microsoft account (coming soon)": "Compte Microsoft (bientôt)",
+  "Microsoft account": "Compte Microsoft",
+  "Another account": "Un autre compte",
+  "Microsoft sign-in is coming soon. Until then the game plays offline: single player, LAN and servers in offline mode work.": "La connexion Microsoft arrive bientôt. D'ici là, le jeu se joue hors ligne : solo, LAN et serveurs en mode hors ligne fonctionnent.",
+  "Coming soon": "Bientôt",
+  "Microsoft account · plays": "Compte Microsoft · joue",
+  "Microsoft account · signed in": "Compte Microsoft · connecté",
+  "Asking Microsoft…": "Demande à Microsoft…",
+  "Add another account.": "Ajoutez un autre compte.",
+  "Copy code": "Copier le code",
+  "Open link": "Ouvrir le lien",
+  "Play as": "Jouer en tant que",
+  "Play offline": "Jouer hors ligne",
+  "Sign out": "Se déconnecter",
+  "Offline": "Hors ligne",
+  "Microsoft": "Microsoft",
+  "Offline, the game's name": "Hors ligne, le nom du jeu",
+  "Manage accounts": "Gérer les comptes",
+  "Offline name": "Nom hors ligne",
+  "Offline name · plays": "Nom hors ligne · joue",
+  "A name, 3 to 16 letters": "Un nom, de 3 à 16 lettres",
+  "Play offline under another name, and switch from the top bar. Online servers don't take offline names.": "Jouez hors ligne sous un autre nom, et changez depuis la barre du haut. Les serveurs en ligne n'acceptent pas les noms hors ligne.",
+  "Add": "Ajouter",
+  "Skin…": "Skin…",
+  "Forget": "Oublier",
+  "{name}'s skin": "Skin de {name}",
+  "{name}'s skin is kept.": "Le skin de {name} est enregistré.",
+  "{name}'s cape is kept.": "La cape de {name} est enregistrée.",
+  "Choose a skin…": "Choisir un skin…",
+  "Default skin": "Skin par défaut",
+  "Classic arms": "Bras classiques",
+  "Slim arms": "Bras fins",
+  "Choose a cape…": "Choisir une cape…",
+  "No cape": "Pas de cape",
+  "Default": "Par défaut",
+  "A 64×64 (or 64×32) skin PNG and a 64×32 cape PNG, kept by the launcher and given to the game when this name plays. The game draws the default skins for now; it uses these once it can. A Microsoft account's skin and cape: coming soon.": "Un PNG de skin 64×64 (ou 64×32) et un PNG de cape 64×32, gardés par le launcher et donnés au jeu quand ce nom joue. Le jeu dessine encore les skins par défaut ; il utilisera ceux-ci dès qu'il le pourra. Skin et cape d'un compte Microsoft : bientôt."
+}
diff --git a/launcher/lang/ru.json b/launcher/lang/ru.json
new file mode 100644
index 000000000..127cda928
--- /dev/null
+++ b/launcher/lang/ru.json
@@ -0,0 +1,87 @@
+{
+  "Home": "Главная",
+  "Mods": "Моды",
+  "Servers": "Серверы",
+  "Versions": "Версии",
+  "Patch notes": "Список изменений",
+  "Settings": "Настройки",
+  "Accounts, updates, and the launcher itself.": "Аккаунты, обновления и сам лаунчер.",
+  "Account": "Аккаунт",
+  "Updates": "Обновления",
+  "Launcher": "Лаунчер",
+  "Network": "Сеть",
+  "Game": "Игра",
+  "AI": "ИИ",
+  "About": "О программе",
+  "Install new versions automatically": "Устанавливать новые версии автоматически",
+  "Your selected version only changes if you were playing the newest one.": "Выбранная версия меняется, только если вы играли в самую новую.",
+  "Appearance": "Оформление",
+  "Dark": "Тёмное",
+  "Light": "Светлое",
+  "System": "Системное",
+  "Dark by default. System follows your computer's light or dark.": "По умолчанию тёмное. «Системное» следует светлой или тёмной теме компьютера.",
+  "Language": "Язык",
+  "System follows your computer's language: {language} here. A string not translated yet shows in English.": "«Системный» следует языку компьютера: здесь {language}. Ещё не переведённый текст показывается по-английски.",
+  "While playing": "Во время игры",
+  "Stay": "Оставаться",
+  "Minimise": "Свернуть",
+  "Hide": "Скрыть",
+  "The launcher stays open while you play.": "Лаунчер остаётся открытым, пока вы играете.",
+  "The launcher goes down when the game starts, and comes back when it closes.": "Лаунчер сворачивается при запуске игры и возвращается, когда она закрывается.",
+  "The launcher hides when the game starts, and comes back when it closes.": "Лаунчер скрывается при запуске игры и возвращается, когда она закрывается.",
+  "Show the opening": "Показывать заставку",
+  "The wordmark, while the release list loads.": "Логотип, пока загружается список версий.",
+  "{version} available": "Доступна {version}",
+  "Up to date": "Обновлено",
+  "up to date": "обновлено",
+  "Checking…": "Проверка…",
+  "downloading {version}, {percent}%": "загрузка {version}, {percent}%",
+  "Updated to {version}. Restart the launcher to use it.": "Обновлено до {version}. Перезапустите лаунчер, чтобы применить.",
+  "the update failed: {error}": "обновление не удалось: {error}",
+  "Install": "Установить",
+  "Restart": "Перезапустить",
+  "Check now": "Проверить",
+  "Open": "Открыть",
+  "Data folder": "Папка данных",
+  "Logs": "Журналы",
+  "crash reports beside it": "отчёты о сбоях рядом",
+  "Applications menu": "Меню приложений",
+  "Horizon and its icon are in your desktop's menu.": "Horizon и его значок есть в меню рабочего стола.",
+  "Not in your desktop's menu.": "Нет в меню рабочего стола.",
+  "Microsoft account (coming soon)": "Аккаунт Microsoft (скоро)",
+  "Microsoft account": "Аккаунт Microsoft",
+  "Another account": "Другой аккаунт",
+  "Microsoft sign-in is coming soon. Until then the game plays offline: single player, LAN and servers in offline mode work.": "Вход через Microsoft скоро появится. А пока игра работает офлайн: одиночная игра, LAN и серверы в офлайн-режиме.",
+  "Coming soon": "Скоро",
+  "Microsoft account · plays": "Аккаунт Microsoft · играет",
+  "Microsoft account · signed in": "Аккаунт Microsoft · вход выполнен",
+  "Asking Microsoft…": "Запрос к Microsoft…",
+  "Add another account.": "Добавьте ещё один аккаунт.",
+  "Copy code": "Скопировать код",
+  "Open link": "Открыть ссылку",
+  "Play as": "Играть за",
+  "Play offline": "Играть офлайн",
+  "Sign out": "Выйти",
+  "Offline": "Офлайн",
+  "Microsoft": "Microsoft",
+  "Offline, the game's name": "Офлайн, имя от игры",
+  "Manage accounts": "Управление аккаунтами",
+  "Offline name": "Офлайн-имя",
+  "Offline name · plays": "Офлайн-имя · играет",
+  "A name, 3 to 16 letters": "Имя, от 3 до 16 букв",
+  "Play offline under another name, and switch from the top bar. Online servers don't take offline names.": "Играйте офлайн под другим именем и переключайтесь в верхней панели. Онлайн-серверы не принимают офлайн-имена.",
+  "Add": "Добавить",
+  "Skin…": "Скин…",
+  "Forget": "Забыть",
+  "{name}'s skin": "Скин {name}",
+  "{name}'s skin is kept.": "Скин {name} сохранён.",
+  "{name}'s cape is kept.": "Плащ {name} сохранён.",
+  "Choose a skin…": "Выбрать скин…",
+  "Default skin": "Скин по умолчанию",
+  "Classic arms": "Обычные руки",
+  "Slim arms": "Тонкие руки",
+  "Choose a cape…": "Выбрать плащ…",
+  "No cape": "Без плаща",
+  "Default": "По умолчанию",
+  "A 64×64 (or 64×32) skin PNG and a 64×32 cape PNG, kept by the launcher and given to the game when this name plays. The game draws the default skins for now; it uses these once it can. A Microsoft account's skin and cape: coming soon.": "PNG скина 64×64 (или 64×32) и PNG плаща 64×32 хранятся в лаунчере и передаются игре, когда играет это имя. Пока игра рисует стандартные скины; она начнёт использовать эти, как только сможет. Скин и плащ аккаунта Microsoft: скоро."
+}
diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs
index 3d900bd87..462b2cdb3 100644
--- a/launcher/src/backend.rs
+++ b/launcher/src/backend.rs
@@ -2604,6 +2604,9 @@ pub struct Settings {
     /// What the window does while the game runs. Stays by default.
     #[serde(default)]
     pub while_playing: WhilePlaying,
+    /// The window's language. Unset follows the system's (`i18n::Language::system`).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<crate::i18n::Language>,
 }
 
 impl Settings {
@@ -2628,6 +2631,12 @@ impl Settings {
             {
                 fields.remove("while_playing");
             }
+            // A language this launcher doesn't have yet follows the system's.
+            if fields.get("language").is_some_and(|l| {
+                serde_json::from_value::<Option<crate::i18n::Language>>(l.clone()).is_err()
+            }) {
+                fields.remove("language");
+            }
         }
         serde_json::from_value(value).unwrap_or_default()
     }
@@ -2635,6 +2644,10 @@ impl Settings {
     pub fn desktop_entry(&self) -> bool {
         self.desktop_entry.unwrap_or(true)
     }
+    /// The window's language: the one picked, else the system's.
+    pub fn language(&self) -> crate::i18n::Language {
+        self.language.unwrap_or_else(crate::i18n::Language::system)
+    }
     /// Whether new Horizon versions are installed automatically.
     pub fn auto_install(&self) -> bool {
         self.install_new_versions.unwrap_or(true)
@@ -2965,6 +2978,18 @@ mod tests {
         assert_eq!(here == WhilePlaying::Hide, cfg!(target_os = "macos"));
     }
 
+    #[test]
+    fn the_language_follows_the_system_unless_picked() {
+        use crate::i18n::Language;
+        assert_eq!(Settings::parse("{}").language, None);
+        let fr = Settings::parse(r#"{"language": "fr"}"#);
+        assert_eq!(fr.language(), Language::French);
+        let future = Settings::parse(r#"{"language": "eo", "game_args": "--x"}"#);
+        assert_eq!((future.language, future.game_args.as_str()), (None, "--x"));
+        let saved = serde_json::to_value(Settings::default()).unwrap();
+        assert!(saved.get("language").is_none(), "unset is left out");
+    }
+
     #[test]
     fn the_appearance_is_dark_unless_picked_and_an_unknown_one_keeps_the_rest() {
         assert_eq!(Settings::parse("{}").appearance, Appearance::Dark);
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 97f3eed09..ff7efcbc7 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -603,7 +603,8 @@ enum Cmd {
     /// Show the launcher's settings, or set one (the Settings page): selected-version TAG,
     /// minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions
     /// on|off, opening-animation on|off, proxy http://host:port ("default" removes it),
-    /// while-playing stay|minimize|hide (what the window does while the game runs)
+    /// while-playing stay|minimize|hide (what the window does while the game runs), language
+    /// system|en|fr|ru (the window's language; system follows the computer's)
     Settings {
         #[arg(value_parser = SETTING_KEYS)]
         key: Option<String>,
@@ -740,7 +741,7 @@ pub fn command() -> clap::Command {
 pub const AI_COMMANDS: [&str; 2] = ["mcp", "agent-config"];
 
 /// The keys `settings` sets.
-const SETTING_KEYS: [&str; 7] = [
+const SETTING_KEYS: [&str; 8] = [
     "selected-version",
     "minecraft-dir",
     "server-dir",
@@ -748,6 +749,7 @@ const SETTING_KEYS: [&str; 7] = [
     "opening-animation",
     "proxy",
     "while-playing",
+    "language",
 ];
 
 fn on_off(value: &str) -> Result<bool, String> {
@@ -770,6 +772,16 @@ fn set_setting(s: &mut backend::Settings, key: &str, value: &str) -> Result<(),
             s.while_playing = backend::WhilePlaying::parse(value)
                 .ok_or_else(|| format!("{value}: say stay, minimize or hide"))?
         }
+        "language" => {
+            use horizon_launcher::i18n::Language;
+            s.language = match value.trim() {
+                "system" | "default" => None,
+                code => Some(
+                    Language::parse(code)
+                        .ok_or_else(|| format!("{value}: say system, en, fr or ru"))?,
+                ),
+            }
+        }
         "proxy" => {
             if value == "default" || value.is_empty() {
                 s.proxy = None;
@@ -796,6 +808,7 @@ fn settings_json(s: &backend::Settings) -> serde_json::Value {
         "proxy": s.proxy,
         "desktop_entry": s.desktop_entry.unwrap_or(true),
         "while_playing": s.while_playing.name(),
+        "language": s.language.map_or("system", |l| l.code()),
         "no_ai": backend::no_ai(),
     })
 }
diff --git a/launcher/src/i18n.rs b/launcher/src/i18n.rs
new file mode 100644
index 000000000..7635461d5
--- /dev/null
+++ b/launcher/src/i18n.rs
@@ -0,0 +1,134 @@
+//! The launcher's languages: English (the strings in the code), French and Russian, the
+//! languages Horizon's own game menus have. A table per language (`launcher/lang/<code>.json`)
+//! maps each English string to its translation; a string the table lacks shows in English.
+//!
+//! The language follows the system's unless the player picks one in Settings
+//! (`Settings::language`). Translations are Horizon's own, written for this launcher.
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicU8, Ordering};
+use std::sync::OnceLock;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Language {
+    #[default]
+    #[serde(rename = "en")]
+    English,
+    #[serde(rename = "fr")]
+    French,
+    #[serde(rename = "ru")]
+    Russian,
+}
+
+impl Language {
+    pub const ALL: [Language; 3] = [Self::English, Self::French, Self::Russian];
+
+    /// Its code in `settings.json` and on the command line.
+    pub fn code(self) -> &'static str {
+        match self {
+            Self::English => "en",
+            Self::French => "fr",
+            Self::Russian => "ru",
+        }
+    }
+
+    /// Its name in itself: what a player looks for in a list of languages.
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::English => "English",
+            Self::French => "Français",
+            Self::Russian => "Русский",
+        }
+    }
+
+    /// A language code (`fr`, `fr-CH`, `fr_FR.UTF-8`), if the launcher has it.
+    pub fn parse(code: &str) -> Option<Self> {
+        let lower = code.trim().to_ascii_lowercase();
+        let base = lower.split(['-', '_', '.', '@']).next().unwrap_or("");
+        Self::ALL.into_iter().find(|l| l.code() == base)
+    }
+
+    /// The first of the system's preferred languages the launcher has, else English.
+    pub fn pick<'a>(preferred: impl IntoIterator<Item = &'a str>) -> Self {
+        preferred
+            .into_iter()
+            .find_map(Self::parse)
+            .unwrap_or_default()
+    }
+
+    /// The system's language, as far as the launcher has it.
+    pub fn system() -> Self {
+        let locales: Vec<String> = sys_locale::get_locales().collect();
+        Self::pick(locales.iter().map(String::as_str))
+    }
+
+    /// The table, as shipped: English text to this language's.
+    fn source(self) -> &'static str {
+        match self {
+            Self::English => "{}",
+            Self::French => include_str!("../lang/fr.json"),
+            Self::Russian => include_str!("../lang/ru.json"),
+        }
+    }
+}
+
+static CURRENT: AtomicU8 = AtomicU8::new(0);
+
+/// Shows the launcher in `language` from now on.
+pub fn set(language: Language) {
+    let i = Language::ALL
+        .iter()
+        .position(|l| *l == language)
+        .unwrap_or(0);
+    CURRENT.store(i as u8, Ordering::Relaxed);
+}
+
+pub fn current() -> Language {
+    Language::ALL[CURRENT.load(Ordering::Relaxed) as usize % Language::ALL.len()]
+}
+
+type Table = HashMap<String, &'static str>;
+
+fn table(language: Language) -> &'static Table {
+    static TABLES: OnceLock<Vec<Table>> = OnceLock::new();
+    let tables = TABLES.get_or_init(|| {
+        Language::ALL
+            .iter()
+            .map(|l| {
+                serde_json::from_str::<HashMap<String, String>>(l.source())
+                    .unwrap_or_default()
+                    .into_iter()
+                    .map(|(en, said)| (en, &*Box::leak(said.into_boxed_str())))
+                    .collect()
+            })
+            .collect()
+    });
+    let i = Language::ALL
+        .iter()
+        .position(|l| *l == language)
+        .unwrap_or(0);
+    &tables[i]
+}
+
+/// `en` in `language`, or `en` itself where the table lacks it.
+pub fn tr_in(language: Language, en: &str) -> &str {
+    table(language).get(en).copied().unwrap_or(en)
+}
+
+/// `en` in the launcher's language.
+pub fn tr(en: &str) -> &str {
+    tr_in(current(), en)
+}
+
+/// `en` in the launcher's language with its `{name}` holes filled.
+pub fn trf(en: &str, args: &[(&str, &str)]) -> String {
+    let mut out = tr(en).to_string();
+    for (name, value) in args {
+        out = out.replace(&format!("{{{name}}}"), value);
+    }
+    out
+}
+
+#[cfg(test)]
+#[path = "i18n/tests.rs"]
+mod tests;
diff --git a/launcher/src/i18n/tests.rs b/launcher/src/i18n/tests.rs
new file mode 100644
index 000000000..b9674f976
--- /dev/null
+++ b/launcher/src/i18n/tests.rs
@@ -0,0 +1,135 @@
+use super::*;
+use std::collections::BTreeSet;
+use std::path::Path;
+
+/// Every Rust file of the launcher's sources.
+fn sources(dir: &Path, out: &mut Vec<String>) {
+    for entry in std::fs::read_dir(dir).unwrap().flatten() {
+        let path = entry.path();
+        if path.is_dir() {
+            sources(&path, out);
+        } else if path.extension().is_some_and(|e| e == "rs") {
+            // Comments left out: they quote strings too.
+            let code = std::fs::read_to_string(path).unwrap();
+            let lines = code
+                .lines()
+                .map(|l| match l.trim_start().starts_with("//") {
+                    true => "",
+                    false => l,
+                });
+            out.push(lines.collect::<Vec<_>>().join("\n"));
+        }
+    }
+}
+
+/// The string literal at the start of `code` (just after its opening quote), unescaped the way
+/// Rust does: `\"`, `\\`, `\n`, and a backslash at a line's end that drops the next line's
+/// indent.
+fn literal(code: &str) -> String {
+    let mut out = String::new();
+    let mut chars = code.chars().peekable();
+    while let Some(c) = chars.next() {
+        match c {
+            '"' => break,
+            '\\' => match chars.next() {
+                Some('n') => out.push('\n'),
+                Some('\n') => {
+                    while chars.peek().is_some_and(|c| c.is_whitespace()) {
+                        chars.next();
+                    }
+                }
+                Some(c) => out.push(c),
+                None => break,
+            },
+            c => out.push(c),
+        }
+    }
+    out
+}
+
+/// The English strings the code asks a translation for: `tr("…")` and `trf("…")`, and every
+/// other string literal (some reach `tr` through a widget).
+fn strings() -> (BTreeSet<String>, BTreeSet<String>) {
+    let mut files = Vec::new();
+    sources(
+        &Path::new(env!("CARGO_MANIFEST_DIR")).join("src"),
+        &mut files,
+    );
+    let (mut asked, mut all) = (BTreeSet::new(), BTreeSet::new());
+    for file in &files {
+        for (at, _) in file.match_indices('"') {
+            let before = &file[..at];
+            if before.ends_with('\\') || before.ends_with('\'') {
+                continue;
+            }
+            let s = literal(&file[at + 1..]);
+            let call = |name: &str| {
+                before.ends_with(&format!("{name}(")) && {
+                    let head = &before[..before.len() - name.len() - 1];
+                    !head.ends_with(|c: char| c.is_alphanumeric() || c == '_')
+                }
+            };
+            if call("tr") || call("trf") {
+                asked.insert(s.clone());
+            }
+            all.insert(s);
+        }
+    }
+    (asked, all)
+}
+
+fn holes(s: &str) -> BTreeSet<&str> {
+    s.split('{')
+        .skip(1)
+        .filter_map(|part| part.split_once('}').map(|(name, _)| name))
+        .collect()
+}
+
+#[test]
+fn every_language_has_every_string_the_code_asks_for() {
+    let (asked, all) = strings();
+    assert!(asked.contains("Language"), "the scan finds tr(\"…\")");
+    for language in [Language::French, Language::Russian] {
+        let table: HashMap<String, String> = serde_json::from_str(language.source())
+            .unwrap_or_else(|e| panic!("lang/{}.json: {e}", language.code()));
+        let missing: Vec<_> = asked.iter().filter(|s| !table.contains_key(*s)).collect();
+        assert!(
+            missing.is_empty(),
+            "lang/{}.json lacks {missing:#?}",
+            language.code()
+        );
+        let unused: Vec<_> = table.keys().filter(|s| !all.contains(*s)).collect();
+        assert!(
+            unused.is_empty(),
+            "lang/{}.json has strings the code no longer has: {unused:#?}",
+            language.code()
+        );
+        for (en, said) in &table {
+            assert_eq!(holes(en), holes(said), "{}: {en:?}", language.code());
+            assert!(
+                !said.trim().is_empty(),
+                "{}: {en:?} is empty",
+                language.code()
+            );
+        }
+    }
+}
+
+#[test]
+fn the_system_language_is_the_first_one_the_launcher_has() {
+    assert_eq!(Language::pick(["fr-CH", "en-US"]), Language::French);
+    assert_eq!(Language::pick(["de-CH", "ru_RU.UTF-8"]), Language::Russian);
+    assert_eq!(Language::pick(["de-DE", "ja"]), Language::English);
+    assert_eq!(Language::pick([]), Language::English);
+    assert_eq!(Language::parse("FR"), Some(Language::French));
+    assert_eq!(Language::parse("french"), None);
+    assert_eq!(serde_json::to_string(&Language::Russian).unwrap(), "\"ru\"");
+}
+
+#[test]
+fn a_missing_string_shows_in_english() {
+    assert_eq!(tr_in(Language::French, "Settings"), "Paramètres");
+    assert_eq!(tr_in(Language::Russian, "Settings"), "Настройки");
+    assert_eq!(tr_in(Language::English, "Settings"), "Settings");
+    assert_eq!(tr_in(Language::French, "No such string"), "No such string");
+}
diff --git a/launcher/src/language_page.rs b/launcher/src/language_page.rs
new file mode 100644
index 000000000..5dd940311
--- /dev/null
+++ b/launcher/src/language_page.rs
@@ -0,0 +1,35 @@
+//! Settings' Language row (`horizon_launcher::i18n`): the system's language, or one the player
+//! picks, each named in itself.
+use super::*;
+use horizon_launcher::i18n::Language;
+
+impl Launcher {
+    pub(super) fn language_row(&self, cx: &mut Context<Self>) -> Div {
+        let t = self.theme;
+        let mut options = vec![(None, "System")];
+        options.extend(Language::ALL.map(|l| (Some(l), l.name())));
+        let picker = segments("language", &options, self.settings.language, &t, {
+            let this = cx.entity().downgrade();
+            move |choice, _, cx| {
+                let _ = this.update(cx, |this, cx| {
+                    this.settings.language = choice;
+                    this.settings.save();
+                    i18n::set(this.settings.language());
+                    cx.notify();
+                });
+            }
+        });
+        let said = trf(
+            "System follows your computer's language: {language} here. A string not translated \
+             yet shows in English.",
+            &[("language", Language::system().name())],
+        );
+        index_row(
+            0,
+            tr("Language"),
+            Some(div().child(said).into_any_element()),
+            Some(picker.into_any_element()),
+            &t,
+        )
+    }
+}
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index 4d8cfaaf3..d971c9667 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -11,6 +11,7 @@ pub mod export;
 pub mod game_app;
 pub mod game_log;
 pub mod heads;
+pub mod i18n;
 pub mod import;
 pub mod instances;
 pub mod launch;
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 5532b468d..67b6d0f84 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -18,6 +18,7 @@ mod game_tools;
 mod import_page;
 mod instances_page;
 mod internet;
+mod language_page;
 mod launch_page;
 mod markdown;
 mod mcp;
@@ -47,6 +48,7 @@ use gpui::{
 };
 use horizon_launcher::account::{self, Accounts, SignIn, SignInState};
 use horizon_launcher::backend::{self, Job, Msg, Release, Running, Settings, Updates};
+use horizon_launcher::i18n::{self, tr, trf};
 use horizon_launcher::instances;
 use horizon_launcher::telemetry;
 use scrollbar::Scrollbar;
@@ -314,6 +316,7 @@ impl Launcher {
         })
         .detach();
         let mut settings = Settings::load();
+        i18n::set(settings.language());
         if settings.minecraft_dir.is_none() {
             settings.minecraft_dir = backend::default_minecraft_dir();
         }
@@ -1191,6 +1194,8 @@ fn button(
     t: &Theme,
 ) -> Stateful<Div> {
     let id: SharedString = id.into();
+    let label: SharedString = label.into();
+    let label = SharedString::from(tr(&label).to_string());
     let t = *t;
     let hover = match kind {
         Kind::Primary => t.on_face.opacity(0.10),
@@ -1234,7 +1239,7 @@ fn button(
             .items_center()
             .gap(px(8.))
             .pb(px(if kind == Kind::Ghost { 0. } else { 2. }))
-            .child(label.into()),
+            .child(label),
     );
     keyboard(track_hover(base, id), &t).active(|s| s.opacity(theme::PRESSED).top(px(1.)))
 }
@@ -1302,7 +1307,7 @@ fn section_title(label: &'static str, icon: &'static str, t: &Theme) -> Div {
         .child(
             blocks::pixel(18., FontWeight::SEMIBOLD)
                 .text_color(t.ink)
-                .child(label),
+                .child(tr(label)),
         )
 }
 
@@ -1348,7 +1353,7 @@ fn segments<T: Copy + PartialEq + 'static>(
                 .when(!active, |d| {
                     d.text_color(t.muted).hover(move |s| s.text_color(t.ink))
                 })
-                .child(div().relative().child(label))
+                .child(div().relative().child(tr(label)))
                 .on_click(move |_: &ClickEvent, window, cx| pick(value, window, cx))
         }))
 }
@@ -1374,13 +1379,13 @@ fn page_header(title: &str, description: &str, t: &Theme) -> Div {
         .child(
             blocks::pixel(36., FontWeight::SEMIBOLD)
                 .text_color(t.ink)
-                .child(title.to_string()),
+                .child(tr(title).to_string()),
         )
         .child(
             text(theme::UI)
                 .max_w(px(520.))
                 .text_color(t.muted)
-                .child(description.to_string()),
+                .child(tr(description).to_string()),
         )
 }
 
@@ -1563,7 +1568,7 @@ impl Launcher {
                     blocks::pixel(16., FontWeight::MEDIUM)
                         .relative()
                         .text_color(if active { t.ink } else { t.muted })
-                        .child(label),
+                        .child(tr(label)),
                 )
                 .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
                     this.go(page);
@@ -2581,10 +2586,10 @@ impl Launcher {
             }),
         );
         let horizon = match (&self.updates.horizon, &self.update_error) {
-            (Some(r), _) => format!("{} available", r.tag),
+            (Some(r), _) => trf("{version} available", &[("version", &r.tag)]),
             (None, Some(e)) => e.clone(),
-            (None, None) if self.checked.is_some() => "Up to date".to_string(),
-            _ => "Checking…".to_string(),
+            (None, None) if self.checked.is_some() => tr("Up to date").to_string(),
+            _ => tr("Checking…").to_string(),
         };
         let horizon_action = self
             .updates
@@ -2601,18 +2606,36 @@ impl Launcher {
             });
         let launcher = match &self.self_update {
             SelfUpdate::Downloading(v, p) => {
-                format!("{}  ·  downloading {v}, {:.0}%", backend::VERSION, p * 100.)
+                let done = format!("{:.0}", p * 100.);
+                let said = trf(
+                    "downloading {version}, {percent}%",
+                    &[("version", v), ("percent", &done)],
+                );
+                format!("{}  ·  {said}", backend::VERSION)
             }
-            SelfUpdate::Ready(v) => format!("Updated to {v}. Restart the launcher to use it."),
-            SelfUpdate::Failed(e) => format!("{}  ·  the update failed: {e}", backend::VERSION),
+            SelfUpdate::Ready(v) => trf(
+                "Updated to {version}. Restart the launcher to use it.",
+                &[("version", v)],
+            ),
+            SelfUpdate::Failed(e) => format!(
+                "{}  ·  {}",
+                backend::VERSION,
+                trf("the update failed: {error}", &[("error", e)])
+            ),
             SelfUpdate::Idle => match &self.updates.launcher {
                 Some(r) => format!(
-                    "{}  ·  {} available",
+                    "{}  ·  {}",
                     backend::VERSION,
-                    backend::launcher_version(&r.tag).unwrap_or_default()
+                    trf(
+                        "{version} available",
+                        &[(
+                            "version",
+                            backend::launcher_version(&r.tag).unwrap_or_default()
+                        )]
+                    )
                 ),
                 None if self.checked.is_some() && self.update_error.is_none() => {
-                    format!("{}  ·  up to date", backend::VERSION)
+                    format!("{}  ·  {}", backend::VERSION, tr("up to date"))
                 }
                 None => backend::VERSION.to_string(),
             },
@@ -2637,7 +2660,7 @@ impl Launcher {
             ),
         };
         let mono = |s: String| div().font_family(theme::MONO).child(s).into_any_element();
-        let plain = |s: &str| div().child(s.to_string()).into_any_element();
+        let plain = |s: &str| div().child(tr(s).to_string()).into_any_element();
         let (accounts, n) = self.account_rows(cx);
         let (offline, n) = self.offline_rows(n, cx);
         let appearance = segments(
@@ -2684,7 +2707,7 @@ impl Launcher {
                     .child(group("Updates", "reload"))
                     .child(index_row(
                         n + 1,
-                        "Install new versions automatically",
+                        tr("Install new versions automatically"),
                         Some(plain(
                             "Your selected version only changes if you were playing the newest one.",
                         )),
@@ -2694,15 +2717,16 @@ impl Launcher {
                     .child(group("Launcher", "monitor"))
                     .child(index_row(
                         n + 3,
-                        "Appearance",
+                        tr("Appearance"),
                         Some(plain("Dark by default. System follows your computer's light or dark.")),
                         Some(appearance.into_any_element()),
                         &t,
                     ))
+                    .child(self.language_row(cx))
                     .child(self.while_playing_row(n + 3, cx))
                     .child(index_row(
                         n + 3,
-                        "Show the opening",
+                        tr("Show the opening"),
                         Some(plain("The wordmark, while the release list loads.")),
                         Some(opening.into_any_element()),
                         &t,
@@ -2717,24 +2741,25 @@ impl Launcher {
                     .child(index_row(n + 7, "Horizon", Some(plain(&horizon)), horizon_action, &t))
                     .child(index_row(
                         n + 8,
-                        "Launcher",
+                        tr("Launcher"),
                         Some(plain(&launcher)),
                         launcher_action,
                         &t,
                     ))
                     .child(index_row(
                         n + 9,
-                        "Data folder",
+                        tr("Data folder"),
                         Some(mono(short(&backend::data_dir()))),
                         None,
                         &t,
                     ))
                     .child(index_row(
                         n + 10,
-                        "Logs",
+                        tr("Logs"),
                         Some(mono(format!(
-                            "{}  ·  crash reports beside it",
-                            short(&backend::logs_dir())
+                            "{}  ·  {}",
+                            short(&backend::logs_dir()),
+                            tr("crash reports beside it")
                         ))),
                         Some(
                             button("open-logs", "Open", Kind::Secondary, &t)
@@ -2750,7 +2775,7 @@ impl Launcher {
                     .when(cfg!(target_os = "linux"), |d| {
                         d.child(index_row(
                             n + 11,
-                            "Applications menu",
+                            tr("Applications menu"),
                             Some(plain(if self.settings.desktop_entry() {
                                 "Horizon and its icon are in your desktop's menu."
                             } else {
@@ -2976,11 +3001,11 @@ impl Launcher {
                 a.name.clone(),
                 Some(
                     div()
-                        .child(if plays {
+                        .child(tr(if plays {
                             "Microsoft account · plays"
                         } else {
                             "Microsoft account · signed in"
-                        })
+                        }))
                         .into_any_element(),
                 ),
                 Some(actions.into_any_element()),
@@ -2993,8 +3018,8 @@ impl Launcher {
             Some(SignInState::Starting | SignInState::Code(_))
         );
         let detail = match &self.sign_in_state {
-            _ if !configured => div().child(account::NOT_CONFIGURED),
-            Some(SignInState::Starting) => div().child("Asking Microsoft…"),
+            _ if !configured => div().child(tr(account::NOT_CONFIGURED)),
+            Some(SignInState::Starting) => div().child(tr("Asking Microsoft…")),
             Some(SignInState::Code(code)) => div()
                 .flex()
                 .flex_col()
@@ -3014,7 +3039,7 @@ impl Launcher {
             None if self.accounts.accounts.is_empty() => div().child(
                 "Sign in to play on online servers with your name and skin. Without an account the game plays offline.",
             ),
-            None => div().child("Add another account."),
+            None => div().child(tr("Add another account.")),
         };
         let detail = if self.keychain || self.accounts.accounts.is_empty() {
             detail
@@ -3085,7 +3110,7 @@ impl Launcher {
         };
         rows = rows.child(index_row(
             n,
-            title,
+            tr(title),
             Some(detail.into_any_element()),
             action,
             &t,
diff --git a/launcher/src/skin_page.rs b/launcher/src/skin_page.rs
index 00e977216..5b2f6ae09 100644
--- a/launcher/src/skin_page.rs
+++ b/launcher/src/skin_page.rs
@@ -81,9 +81,12 @@ impl Launcher {
                 true => l.cape = true,
             })
         });
-        let what = if cape { "cape" } else { "skin" };
         if let Some(p) = &mut self.skin {
-            p.note = Some(done.map(|()| format!("{name}'s {what} is kept.")));
+            let said = match cape {
+                false => trf("{name}'s skin is kept.", &[("name", &name)]),
+                true => trf("{name}'s cape is kept.", &[("name", &name)]),
+            };
+            p.note = Some(done.map(|()| said));
         }
     }
 
@@ -136,7 +139,7 @@ impl Launcher {
                     Some(i) => gpui::img(i).w(px(w)).h(px(h)).into_any_element(),
                     None => text(theme::CAPTION)
                         .text_color(t.muted)
-                        .child(empty)
+                        .child(tr(empty))
                         .into_any_element(),
                 })
         };
@@ -205,7 +208,7 @@ impl Launcher {
                         .flex_1()
                         .min_w_0()
                         .gap(px(12.))
-                        .child(caps(format!("{name}'s skin")).text_color(t.muted))
+                        .child(caps(trf("{name}'s skin", &[("name", &name)])).text_color(t.muted))
                         .child(skin_buttons)
                         .child(model)
                         .child(cape_buttons)
@@ -213,12 +216,12 @@ impl Launcher {
                             Ok(said) => text(theme::CAPTION).text_color(t.muted).child(said),
                             Err(e) => text(theme::CAPTION).text_color(t.danger).child(e),
                         }))
-                        .child(text(theme::CAPTION).text_color(t.muted).child(
+                        .child(text(theme::CAPTION).text_color(t.muted).child(tr(
                             "A 64×64 (or 64×32) skin PNG and a 64×32 cape PNG, kept by the \
                              launcher and given to the game when this name plays. The game \
                              draws the default skins for now; it uses these once it can. A \
                              Microsoft account's skin and cape: coming soon.",
-                        )),
+                        ))),
                 ),
         )
     }
diff --git a/launcher/src/switch_page.rs b/launcher/src/switch_page.rs
index a29d21044..eb1e0bbfc 100644
--- a/launcher/src/switch_page.rs
+++ b/launcher/src/switch_page.rs
@@ -12,12 +12,12 @@ impl Launcher {
                 self.accounts
                     .selected()
                     .map_or_else(String::new, |a| a.name.clone()),
-                "Microsoft account",
+                tr("Microsoft account"),
             ),
-            Player::Offline(name) => (name, "Offline"),
+            Player::Offline(name) => (name, tr("Offline")),
             Player::GameName => (
                 self.offline_name.clone().unwrap_or_else(|| "Player".into()),
-                "Offline",
+                tr("Offline"),
             ),
         }
     }
@@ -42,7 +42,7 @@ impl Launcher {
                 (
                     Player::Microsoft(a.uuid.clone()),
                     a.name.clone(),
-                    "Microsoft",
+                    tr("Microsoft"),
                 )
             })
             .collect();
@@ -50,12 +50,12 @@ impl Launcher {
             self.accounts
                 .offline
                 .iter()
-                .map(|n| (Player::Offline(n.clone()), n.clone(), "Offline")),
+                .map(|n| (Player::Offline(n.clone()), n.clone(), tr("Offline"))),
         );
         out.push((
             Player::GameName,
             self.offline_name.clone().unwrap_or_else(|| "Player".into()),
-            "Offline, the game's name",
+            tr("Offline, the game's name"),
         ));
         out
     }
@@ -123,7 +123,7 @@ impl Launcher {
                 .text_color(t.muted)
                 .cursor_pointer()
                 .hover(move |s| s.bg(t.plate_soft).text_color(t.ink))
-                .child("Manage accounts")
+                .child(tr("Manage accounts"))
                 .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
                     this.account_menu = false;
                     this.go(Page::Settings);
@@ -196,11 +196,11 @@ impl Launcher {
                 name,
                 Some(
                     div()
-                        .child(if plays {
+                        .child(tr(if plays {
                             "Offline name · plays"
                         } else {
                             "Offline name"
-                        })
+                        }))
                         .into_any_element(),
                 ),
                 Some(actions.into_any_element()),
@@ -213,7 +213,7 @@ impl Launcher {
             .flex()
             .items_center()
             .gap(px(8.))
-            .child(self.field(Field::OfflineName, "A name, 3 to 16 letters", 220., cx))
+            .child(self.field(Field::OfflineName, tr("A name, 3 to 16 letters"), 220., cx))
             .child(
                 button("offline-add", "Add", Kind::Secondary, &t).on_click(cx.listener(
                     |this, _: &ClickEvent, _, cx| {
@@ -224,13 +224,13 @@ impl Launcher {
             );
         rows = rows.child(index_row(
             n,
-            "Offline name",
+            tr("Offline name"),
             Some(
                 div()
-                    .child(
+                    .child(tr(
                         "Play offline under another name, and switch from the top bar. Online \
                          servers don't take offline names.",
-                    )
+                    ))
                     .into_any_element(),
             ),
             Some(add.into_any_element()),
diff --git a/launcher/src/while_playing.rs b/launcher/src/while_playing.rs
index d39309f7c..f724d7e22 100644
--- a/launcher/src/while_playing.rs
+++ b/launcher/src/while_playing.rs
@@ -83,8 +83,8 @@ impl Launcher {
         };
         index_row(
             n,
-            "While playing",
-            Some(div().child(said).into_any_element()),
+            tr("While playing"),
+            Some(div().child(tr(said)).into_any_element()),
             Some(picker.into_any_element()),
             &t,
         )

From 620dfc6e0d53f0d32d75b791009ecbd923b92114 Mon Sep 17 00:00:00 2001
From: Senjin <senjin@hatchling.org>
Date: Tue, 27 Oct 2026 05:01:43 +0100
Subject: [PATCH 434/475] HDR: let light sources shine the same under the
 vignette

The lift's threshold read the frame, which the vignette darkens toward
the screen's edges, so a jack o'lantern lit up fully in the middle of
the screen and only at its eyes and mouth further out. Read it from the
world copy instead; the gain still applies to the frame, so the vignette
darkens highlights as before.

Telling the vignetted world from UI also failed on pixels with a channel
at 0 (a pumpkin's stem): each channel's ratio was compared to their
mean, and a 0 channel's ratio is 0. Hold the channels to one factor, the
ratio of their sums, allowing a step of 8-bit rounding.

Part of #1441.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/hdr.wgsl | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/hdr.wgsl b/crates/horizon-client/src/hdr.wgsl
index bf6c27cca..7e9dd4edf 100644
--- a/crates/horizon-client/src/hdr.wgsl
+++ b/crates/horizon-client/src/hdr.wgsl
@@ -30,14 +30,15 @@ const STRENGTH: f32 = 0.7;
 
 // Whether `c` still shows the world pixel `w`: the same, or darkened evenly
 // across its channels, as the vignette and other screen-wide tints darken it.
-// The hand, HUD and text replace pixels instead, so they never pass.
+// The hand, HUD and text replace pixels instead, so they never pass. The
+// channels are held to one factor, the ratio of their sums, so a channel at 0
+// stays 0; a step of 8-bit rounding is allowed on each.
 fn shows_world(c: vec3<f32>, w: vec3<f32>) -> bool {
     if all(c == w) {
         return true;
     }
-    let k = c / max(w, vec3(1.0 / 255.0));
-    let mean = (k.r + k.g + k.b) / 3.0;
-    return mean <= 1.01 && mean > 0.5 && all(abs(k - vec3(mean)) < vec3(0.03));
+    let f = (c.r + c.g + c.b) / max(w.r + w.g + w.b, 1.0 / 255.0);
+    return f <= 1.01 && f > 0.5 && all(abs(c - f * w) <= 0.03 * w + 1.0 / 255.0);
 }
 
 @vertex fn vs_hdr(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
@@ -54,7 +55,10 @@ fn shows_world(c: vec3<f32>, w: vec3<f32>) -> bool {
     // The world's alpha is 0 on light-emitting blocks, the sun and the moon
     // (terrain.wgsl, the celestial pipeline): only those shine.
     if params.world > 0.5 && params.peak > 1.0 && w.a < 0.75 && shows_world(c, w.rgb) {
-        let y = 0.5 * (dot(light, vec3(0.2126, 0.7152, 0.0722)) + max(light.r, max(light.g, light.b)));
+        // Brightness of the world pixel, before the vignette darkens the frame
+        // toward its edges: a light source shines the same anywhere on screen.
+        let wl = pow(max(w.rgb, vec3(0.0)), vec3(2.2));
+        let y = 0.5 * (dot(wl, vec3(0.2126, 0.7152, 0.0722)) + max(wl.r, max(wl.g, wl.b)));
         let lift = smoothstep(LIFT_START, LIFT_FULL, y);
         if lift > 0.0 {
             let top = max(light.r, max(light.g, light.b));

From 8beaa57331d3bf1d89d93eda0c09feeb4b49dca7 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 05:07:38 +0100
Subject: [PATCH 435/475] launcher: an accent colour and a picture behind Home

Settings > Launcher picks an accent (violet by default, blue, teal, green, amber, red, pink)
and the player's own picture behind Home. An accent turns the violet tokens to its hue and
adjusts their lightness until text on the Play button and the accent on every background read
as well as the violet's. The picture is checked, copied under a name of its hash and shown
cropped under the banner's veils. CLI: settings accent NAME, settings background PATH|default.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/launcher-commands.md    |   4 +-
 launcher/README.md           |   7 ++
 launcher/lang/fr.json        |  10 +-
 launcher/lang/ru.json        |  10 +-
 launcher/src/backend.rs      |  29 +++++
 launcher/src/cli.rs          |  26 ++++-
 launcher/src/lib.rs          |   1 +
 launcher/src/main.rs         |  36 +++++--
 launcher/src/theme.rs        |  22 ++--
 launcher/src/themes.rs       | 201 +++++++++++++++++++++++++++++++++++
 launcher/src/themes/tests.rs | 107 +++++++++++++++++++
 launcher/src/themes_page.rs  | 155 +++++++++++++++++++++++++++
 12 files changed, 577 insertions(+), 31 deletions(-)
 create mode 100644 launcher/src/themes.rs
 create mode 100644 launcher/src/themes/tests.rs
 create mode 100644 launcher/src/themes_page.rs

diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index f5fea0192..900a10283 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -161,11 +161,11 @@ MCP: `account_skin`.
 
 ## `horizon-launcher settings`
 
-Show the launcher's settings, or set one (the Settings page): selected-version TAG, minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions on|off, opening-animation on|off, proxy http://host:port ("default" removes it), while-playing stay|minimize|hide (what the window does while the game runs), language system|en|fr|ru (the window's language; system follows the computer's).
+Show the launcher's settings, or set one (the Settings page): selected-version TAG, minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions on|off, opening-animation on|off, proxy http://host:port ("default" removes it), while-playing stay|minimize|hide (what the window does while the game runs), language system|en|fr|ru (the window's language; system follows the computer's), accent violet|blue|teal|green|amber|red|pink, background PATH (a picture behind Home; "default" shows Horizon's landscape).
 
     horizon-launcher settings [KEY] [VALUE]
 
-- `KEY` (selected-version, minecraft-dir, server-dir, install-new-versions, opening-animation, proxy, while-playing, language)
+- `KEY` (selected-version, minecraft-dir, server-dir, install-new-versions, opening-animation, proxy, while-playing, language, accent, background)
 - `VALUE`: The new value (with KEY)
 
 MCP: `settings`.
diff --git a/launcher/README.md b/launcher/README.md
index 9b617064b..6aec8b633 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -129,6 +129,13 @@ The opening, then Play ([clip](docs/opening.webm)):
   the Console's Share log takes them out of the log too. `horizon-launcher account offline
   [NAME]`, `account select <name>` (an account or an offline name), `account forget-offline
   <name>`.
+- **Accent and Home background**: on top of Dark, Light or System, Settings > Launcher picks an
+  accent (Horizon's violet, blue, teal, green, amber, red or pink) and a picture of the player's
+  own behind Home (PNG, JPEG or WebP, cropped to fill; **Landscape** brings Horizon's back). An
+  accent turns the violet tokens to its hue, then darkens or lightens them just enough to keep
+  white on the Play button at 4.5:1 and the accent at 3:1 on every background (a test holds every
+  accent in both looks to it). The picture is copied into the data folder.
+  `horizon-launcher settings accent NAME`, `settings background PATH|default`.
 - **Language**: English, French and Russian (the languages Horizon's own game menus have).
   The window follows the system's language unless the player picks one in Settings > Launcher
   (each named in itself); a string a table lacks shows in English. The tables are
diff --git a/launcher/lang/fr.json b/launcher/lang/fr.json
index 719f6fd52..d2181dfcc 100644
--- a/launcher/lang/fr.json
+++ b/launcher/lang/fr.json
@@ -83,5 +83,13 @@
   "Choose a cape…": "Choisir une cape…",
   "No cape": "Pas de cape",
   "Default": "Par défaut",
-  "A 64×64 (or 64×32) skin PNG and a 64×32 cape PNG, kept by the launcher and given to the game when this name plays. The game draws the default skins for now; it uses these once it can. A Microsoft account's skin and cape: coming soon.": "Un PNG de skin 64×64 (ou 64×32) et un PNG de cape 64×32, gardés par le launcher et donnés au jeu quand ce nom joue. Le jeu dessine encore les skins par défaut ; il utilisera ceux-ci dès qu'il le pourra. Skin et cape d'un compte Microsoft : bientôt."
+  "A 64×64 (or 64×32) skin PNG and a 64×32 cape PNG, kept by the launcher and given to the game when this name plays. The game draws the default skins for now; it uses these once it can. A Microsoft account's skin and cape: coming soon.": "Un PNG de skin 64×64 (ou 64×32) et un PNG de cape 64×32, gardés par le launcher et donnés au jeu quand ce nom joue. Le jeu dessine encore les skins par défaut ; il utilisera ceux-ci dès qu'il le pourra. Skin et cape d'un compte Microsoft : bientôt.",
+  "Accent colour": "Couleur d'accent",
+  "Horizon's violet by default. Every colour keeps text as easy to read.": "Le violet d'Horizon par défaut. Chaque couleur garde le texte aussi lisible.",
+  "Choose": "Choisir",
+  "Choose a picture…": "Choisir une image…",
+  "Landscape": "Paysage",
+  "Your picture, behind Home, cropped to fill it.": "Votre image, derrière l'accueil, recadrée pour le remplir.",
+  "Horizon's landscape. Pick a PNG, JPEG or WebP picture of your own.": "Le paysage d'Horizon. Choisissez votre propre image PNG, JPEG ou WebP.",
+  "Home background": "Fond de l'accueil"
 }
diff --git a/launcher/lang/ru.json b/launcher/lang/ru.json
index 127cda928..d47b03cf0 100644
--- a/launcher/lang/ru.json
+++ b/launcher/lang/ru.json
@@ -83,5 +83,13 @@
   "Choose a cape…": "Выбрать плащ…",
   "No cape": "Без плаща",
   "Default": "По умолчанию",
-  "A 64×64 (or 64×32) skin PNG and a 64×32 cape PNG, kept by the launcher and given to the game when this name plays. The game draws the default skins for now; it uses these once it can. A Microsoft account's skin and cape: coming soon.": "PNG скина 64×64 (или 64×32) и PNG плаща 64×32 хранятся в лаунчере и передаются игре, когда играет это имя. Пока игра рисует стандартные скины; она начнёт использовать эти, как только сможет. Скин и плащ аккаунта Microsoft: скоро."
+  "A 64×64 (or 64×32) skin PNG and a 64×32 cape PNG, kept by the launcher and given to the game when this name plays. The game draws the default skins for now; it uses these once it can. A Microsoft account's skin and cape: coming soon.": "PNG скина 64×64 (или 64×32) и PNG плаща 64×32 хранятся в лаунчере и передаются игре, когда играет это имя. Пока игра рисует стандартные скины; она начнёт использовать эти, как только сможет. Скин и плащ аккаунта Microsoft: скоро.",
+  "Accent colour": "Цвет акцента",
+  "Horizon's violet by default. Every colour keeps text as easy to read.": "По умолчанию фиолетовый Horizon. С любым цветом текст читается так же легко.",
+  "Choose": "Выбрать",
+  "Choose a picture…": "Выбрать картинку…",
+  "Landscape": "Пейзаж",
+  "Your picture, behind Home, cropped to fill it.": "Ваша картинка за главной страницей, обрезанная по размеру.",
+  "Horizon's landscape. Pick a PNG, JPEG or WebP picture of your own.": "Пейзаж Horizon. Выберите свою картинку PNG, JPEG или WebP.",
+  "Home background": "Фон главной"
 }
diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs
index 462b2cdb3..3c2c3d3e4 100644
--- a/launcher/src/backend.rs
+++ b/launcher/src/backend.rs
@@ -2604,6 +2604,13 @@ pub struct Settings {
     /// What the window does while the game runs. Stays by default.
     #[serde(default)]
     pub while_playing: WhilePlaying,
+    /// The accent colour on top of the appearance (`themes::Accent`). Horizon's violet by default.
+    #[serde(default)]
+    pub accent: crate::themes::Accent,
+    /// Home's background: a picture the player picked, kept in the data folder under this name
+    /// (`themes::keep_background`). Unset shows Horizon's landscape.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub background: Option<String>,
     /// The window's language. Unset follows the system's (`i18n::Language::system`).
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub language: Option<crate::i18n::Language>,
@@ -2631,6 +2638,11 @@ impl Settings {
             {
                 fields.remove("while_playing");
             }
+            if fields.get("accent").is_some_and(|a| {
+                serde_json::from_value::<crate::themes::Accent>(a.clone()).is_err()
+            }) {
+                fields.remove("accent");
+            }
             // A language this launcher doesn't have yet follows the system's.
             if fields.get("language").is_some_and(|l| {
                 serde_json::from_value::<Option<crate::i18n::Language>>(l.clone()).is_err()
@@ -2990,6 +3002,23 @@ mod tests {
         assert!(saved.get("language").is_none(), "unset is left out");
     }
 
+    #[test]
+    fn the_accent_is_violet_unless_picked_and_an_unknown_one_keeps_the_rest() {
+        use crate::themes::Accent;
+        assert_eq!(Settings::parse("{}").accent, Accent::Violet);
+        let teal =
+            Settings::parse(r#"{"accent": "teal", "background": "background-0123456789ab.png"}"#);
+        assert_eq!(
+            (teal.accent, teal.background.as_deref()),
+            (Accent::Teal, Some("background-0123456789ab.png"))
+        );
+        let future = Settings::parse(r#"{"accent": "plaid", "game_args": "--x"}"#);
+        assert_eq!(
+            (future.accent, future.game_args.as_str()),
+            (Accent::Violet, "--x")
+        );
+    }
+
     #[test]
     fn the_appearance_is_dark_unless_picked_and_an_unknown_one_keeps_the_rest() {
         assert_eq!(Settings::parse("{}").appearance, Appearance::Dark);
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index ff7efcbc7..cf7770c65 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -604,7 +604,9 @@ enum Cmd {
     /// minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions
     /// on|off, opening-animation on|off, proxy http://host:port ("default" removes it),
     /// while-playing stay|minimize|hide (what the window does while the game runs), language
-    /// system|en|fr|ru (the window's language; system follows the computer's)
+    /// system|en|fr|ru (the window's language; system follows the computer's), accent
+    /// violet|blue|teal|green|amber|red|pink, background PATH (a picture behind Home; "default"
+    /// shows Horizon's landscape)
     Settings {
         #[arg(value_parser = SETTING_KEYS)]
         key: Option<String>,
@@ -741,7 +743,7 @@ pub fn command() -> clap::Command {
 pub const AI_COMMANDS: [&str; 2] = ["mcp", "agent-config"];
 
 /// The keys `settings` sets.
-const SETTING_KEYS: [&str; 8] = [
+const SETTING_KEYS: [&str; 10] = [
     "selected-version",
     "minecraft-dir",
     "server-dir",
@@ -750,6 +752,8 @@ const SETTING_KEYS: [&str; 8] = [
     "proxy",
     "while-playing",
     "language",
+    "accent",
+    "background",
 ];
 
 fn on_off(value: &str) -> Result<bool, String> {
@@ -772,6 +776,22 @@ fn set_setting(s: &mut backend::Settings, key: &str, value: &str) -> Result<(),
             s.while_playing = backend::WhilePlaying::parse(value)
                 .ok_or_else(|| format!("{value}: say stay, minimize or hide"))?
         }
+        "accent" => {
+            use horizon_launcher::themes::Accent;
+            s.accent = Accent::parse(value).ok_or_else(|| {
+                let names: Vec<_> = Accent::ALL.iter().map(|a| a.name()).collect();
+                format!("{value}: say {}", names.join(", "))
+            })?
+        }
+        "background" => {
+            s.background = match value.trim() {
+                "default" | "" => None,
+                file => Some(horizon_launcher::themes::keep_background(
+                    &backend::data_dir(),
+                    std::path::Path::new(file),
+                )?),
+            }
+        }
         "language" => {
             use horizon_launcher::i18n::Language;
             s.language = match value.trim() {
@@ -809,6 +829,8 @@ fn settings_json(s: &backend::Settings) -> serde_json::Value {
         "desktop_entry": s.desktop_entry.unwrap_or(true),
         "while_playing": s.while_playing.name(),
         "language": s.language.map_or("system", |l| l.code()),
+        "accent": s.accent.name(),
+        "background": horizon_launcher::themes::background(&backend::data_dir(), s.background.as_deref()),
         "no_ai": backend::no_ai(),
     })
 }
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index d971c9667..43b28f42e 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -29,4 +29,5 @@ pub mod skins;
 pub mod sources;
 pub mod tailscale;
 pub mod telemetry;
+pub mod themes;
 pub mod worlds;
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 67b6d0f84..e1c0e8ca9 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -36,6 +36,7 @@ mod shortcut_page;
 mod skin_page;
 mod switch_page;
 mod theme;
+mod themes_page;
 mod titlebar;
 mod while_playing;
 mod worlds_page;
@@ -172,6 +173,8 @@ struct Launcher {
     account_menu: bool,
     /// Settings > Account's skin panel for an offline name (`skin_page.rs`).
     skin: Option<skin_page::SkinPanel>,
+    /// Why the last picture for Home's background was refused.
+    background_error: Option<String>,
     settings: Settings,
     /// The Discord, sponsor and website links: built in until links.json on main has been read.
     links: backend::Links,
@@ -277,7 +280,7 @@ impl Launcher {
     fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let (tx, rx) = channel();
         let appearance = cx.observe_window_appearance(window, |this, window, cx| {
-            this.theme = Theme::for_appearance(this.settings.appearance, window.appearance());
+            this.theme = this.settings_theme(window);
             cx.notify();
         });
         cx.spawn(async move |this, cx| loop {
@@ -344,7 +347,7 @@ impl Launcher {
         // `window.appearance()`, so both draw the same look.
         titlebar::apply_appearance(window, settings.appearance);
         let mut this = Self {
-            theme: Theme::for_appearance(settings.appearance, window.appearance()),
+            theme: Theme::for_appearance(settings.appearance, settings.accent, window.appearance()),
             page: Page::from_env(),
             switches: 0,
             content_scroll: Scrollbar::default(),
@@ -373,6 +376,7 @@ impl Launcher {
             picker_open: false,
             account_menu: false,
             skin: None,
+            background_error: None,
             args_input: settings.game_args.clone(),
             args_focused: false,
             args_focus: cx.focus_handle(),
@@ -2218,6 +2222,21 @@ impl Launcher {
                     gpui::linear_color_stop(t.page.opacity(to), at),
                 ))
         };
+        let picture = self.home_background();
+        let scene = match picture {
+            Some(path) => gpui::img(path)
+                .absolute()
+                .top_0()
+                .left_0()
+                .size_full()
+                .object_fit(gpui::ObjectFit::Cover),
+            None => gpui::img(scene)
+                .absolute()
+                .bottom_0()
+                .left_0()
+                .w(px(scene_width))
+                .h(px(art::SCENE_HEIGHT as f32 * art::SCENE_TEXEL)),
+        };
         let banner = div()
             .relative()
             .flex()
@@ -2232,14 +2251,7 @@ impl Launcher {
             .bg(gpui::rgb(art::sky_top(t.dark)))
             .border_b_2()
             .border_color(t.outline)
-            .child(
-                gpui::img(scene)
-                    .absolute()
-                    .bottom_0()
-                    .left_0()
-                    .w(px(scene_width))
-                    .h(px(art::SCENE_HEIGHT as f32 * art::SCENE_TEXEL)),
-            )
+            .child(scene)
             .child(veil(90., 0.82, 0., 0.62))
             .child(veil(180., 0., 0.75, 1.))
             .child(div().relative().child(hero))
@@ -2679,7 +2691,7 @@ impl Launcher {
                         this.settings.appearance = choice;
                         this.settings.save();
                         titlebar::apply_appearance(window, choice);
-                        this.theme = Theme::for_appearance(choice, window.appearance());
+                        this.theme = this.settings_theme(window);
                         cx.notify();
                     });
                 }
@@ -2722,6 +2734,8 @@ impl Launcher {
                         Some(appearance.into_any_element()),
                         &t,
                     ))
+                    .child(self.accent_row(cx))
+                    .child(self.home_background_row(cx))
                     .child(self.language_row(cx))
                     .child(self.while_playing_row(n + 3, cx))
                     .child(index_row(
diff --git a/launcher/src/theme.rs b/launcher/src/theme.rs
index 9d495a598..8ef6c43dc 100644
--- a/launcher/src/theme.rs
+++ b/launcher/src/theme.rs
@@ -4,6 +4,7 @@
 //! Mono for text (all bundled, SIL Open Font License).
 use gpui::{rgb, Hsla, WindowAppearance};
 use horizon_launcher::backend::Appearance;
+use horizon_launcher::themes::Accent;
 use horizon_theme as tokens;
 use std::time::Duration;
 
@@ -91,25 +92,18 @@ pub fn pinned_dark(choice: Appearance) -> Option<bool> {
 
 impl Theme {
     /// The pinned look (`pinned_dark`: dark unless the player picked another), the system's when
-    /// they asked to follow it.
-    pub fn for_appearance(choice: Appearance, system: WindowAppearance) -> Self {
+    /// they asked to follow it, in the player's accent.
+    pub fn for_appearance(choice: Appearance, accent: Accent, system: WindowAppearance) -> Self {
         let system_dark = !matches!(
             system,
             WindowAppearance::Light | WindowAppearance::VibrantLight
         );
-        if pinned_dark(choice).unwrap_or(system_dark) {
-            Self::dark()
+        let dark = pinned_dark(choice).unwrap_or(system_dark);
+        Self::from(accent.apply(if dark {
+            tokens::BLOCKS_DARK
         } else {
-            Self::light()
-        }
-    }
-
-    pub fn dark() -> Self {
-        Self::from(tokens::BLOCKS_DARK)
-    }
-
-    pub fn light() -> Self {
-        Self::from(tokens::BLOCKS_LIGHT)
+            tokens::BLOCKS_LIGHT
+        }))
     }
 
     fn from(p: tokens::Blocks) -> Self {
diff --git a/launcher/src/themes.rs b/launcher/src/themes.rs
new file mode 100644
index 000000000..7d12441bd
--- /dev/null
+++ b/launcher/src/themes.rs
@@ -0,0 +1,201 @@
+//! The player's own look, on top of Dark, Light or System: an accent colour and a picture behind
+//! Home.
+//!
+//! An accent is a hue. Horizon's violet is the default; another hue turns the violet tokens
+//! (`horizon_theme::Blocks`' accent and the main action's face, bevel and lip) to it, keeping
+//! their saturation and lightness, then darkens or lightens each just enough to read as well as
+//! the violet does: white on the face at 4.5:1, the accent at 3:1 on every background.
+use horizon_theme::{contrast, Blocks};
+use std::path::{Path, PathBuf};
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Accent {
+    #[default]
+    Violet,
+    Blue,
+    Teal,
+    Green,
+    Amber,
+    Red,
+    Pink,
+}
+
+impl Accent {
+    pub const ALL: [Accent; 7] = [
+        Self::Violet,
+        Self::Blue,
+        Self::Teal,
+        Self::Green,
+        Self::Amber,
+        Self::Red,
+        Self::Pink,
+    ];
+
+    /// Its name in `settings.json` and on the command line.
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Violet => "violet",
+            Self::Blue => "blue",
+            Self::Teal => "teal",
+            Self::Green => "green",
+            Self::Amber => "amber",
+            Self::Red => "red",
+            Self::Pink => "pink",
+        }
+    }
+
+    pub fn parse(name: &str) -> Option<Self> {
+        let name = name.trim().to_ascii_lowercase();
+        let name = if name == "purple" || name == "default" {
+            "violet"
+        } else {
+            &name
+        };
+        Self::ALL.into_iter().find(|a| a.name() == name)
+    }
+
+    /// Its hue in degrees; None for the violet, whose tokens stay as they are.
+    fn hue(self) -> Option<f32> {
+        match self {
+            Self::Violet => None,
+            Self::Blue => Some(212.),
+            Self::Teal => Some(176.),
+            Self::Green => Some(140.),
+            Self::Amber => Some(36.),
+            Self::Red => Some(356.),
+            Self::Pink => Some(322.),
+        }
+    }
+
+    /// `palette` with this accent.
+    pub fn apply(self, mut p: Blocks) -> Blocks {
+        let Some(hue) = self.hue() else {
+            return p;
+        };
+        let turn = |c: u32| {
+            let (_, s, l) = hsl(c);
+            (hue, s, l)
+        };
+        // The face holds white text.
+        let face = fit(turn(p.face), |c| contrast(p.on_face, c) >= 4.5, -1.);
+        let (_, _, face_l) = hsl(face);
+        let (h, s, l) = turn(p.face_bevel);
+        p.face_bevel = from_hsl(h, s, l.max(face_l + 0.08).min(0.92));
+        let (h, s, l) = turn(p.face_lip);
+        p.face_lip = from_hsl(h, s, l.min(face_l - 0.12).max(0.05));
+        p.face = face;
+        // The accent marks things on every background: lighter on dark, darker on light.
+        let grounds = [p.page, p.raised, p.button, p.panel, p.well];
+        let reads = |c: u32| grounds.iter().all(|&g| contrast(c, g) >= 3.2);
+        p.accent = fit(turn(p.accent), reads, if p.dark { 1. } else { -1. });
+        p
+    }
+}
+
+/// The colour's hue (degrees), saturation and lightness (0 to 1).
+fn hsl(c: u32) -> (f32, f32, f32) {
+    let [r, g, b] = [16, 8, 0].map(|s| ((c >> s) & 255) as f32 / 255.);
+    let (max, min) = (r.max(g).max(b), r.min(g).min(b));
+    let l = (max + min) / 2.;
+    if max == min {
+        return (0., 0., l);
+    }
+    let d = max - min;
+    let s = if l > 0.5 {
+        d / (2. - max - min)
+    } else {
+        d / (max + min)
+    };
+    let h = if max == r {
+        (g - b) / d + if g < b { 6. } else { 0. }
+    } else if max == g {
+        (b - r) / d + 2.
+    } else {
+        (r - g) / d + 4.
+    };
+    (h * 60., s, l)
+}
+
+fn from_hsl(h: f32, s: f32, l: f32) -> u32 {
+    let c = (1. - (2. * l - 1.).abs()) * s;
+    let x = c * (1. - ((h / 60.) % 2. - 1.).abs());
+    let m = l - c / 2.;
+    let (r, g, b) = match (h.rem_euclid(360.) / 60.) as u32 {
+        0 => (c, x, 0.),
+        1 => (x, c, 0.),
+        2 => (0., c, x),
+        3 => (0., x, c),
+        4 => (x, 0., c),
+        _ => (c, 0., x),
+    };
+    let byte = |v: f32| ((v + m).clamp(0., 1.) * 255.).round() as u32;
+    byte(r) << 16 | byte(g) << 8 | byte(b)
+}
+
+/// The colour, made lighter (`step` 1) or darker (-1) a little at a time until `good` holds.
+fn fit((h, s, l): (f32, f32, f32), good: impl Fn(u32) -> bool, step: f32) -> u32 {
+    let mut l = l;
+    for _ in 0..100 {
+        let c = from_hsl(h, s, l);
+        if good(c) || !(0.0..=1.0).contains(&l) {
+            return c;
+        }
+        l += step * 0.01;
+    }
+    from_hsl(h, s, l.clamp(0., 1.))
+}
+
+/// The pictures Home can show: what the decoders read.
+const PICTURES: [&str; 4] = ["png", "jpg", "jpeg", "webp"];
+/// A picture above this is refused: a screen's worth is far less.
+const MAX_BYTES: u64 = 40 << 20;
+
+/// Keeps `file` as Home's background in `dir` (`background-<hash>.<ext>`: a new picture gets a
+/// new name, so the window doesn't show the one it cached), after checking it is a picture, and
+/// returns the kept file's name. An older background goes.
+pub fn keep_background(dir: &Path, file: &Path) -> Result<String, String> {
+    let shown = file.display();
+    let ext = file
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(str::to_ascii_lowercase)
+        .filter(|e| PICTURES.contains(&e.as_str()))
+        .ok_or_else(|| format!("{shown}: a PNG, JPEG or WebP picture, please."))?;
+    let size = std::fs::metadata(file)
+        .map_err(|e| format!("{shown}: {e}"))?
+        .len();
+    if size > MAX_BYTES {
+        return Err(format!("{shown} is over 40 MB."));
+    }
+    let bytes = std::fs::read(file).map_err(|e| format!("{shown}: {e}"))?;
+    let (w, h) = image::ImageReader::new(std::io::Cursor::new(&bytes))
+        .with_guessed_format()
+        .ok()
+        .and_then(|r| r.into_dimensions().ok())
+        .ok_or_else(|| format!("{shown} isn't a picture the launcher can read."))?;
+    if w < 64 || h < 64 {
+        return Err(format!("{shown} is {w}×{h}: too small to fill Home."));
+    }
+    std::fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let hash = crate::sources::sha1_hex(&bytes);
+    let name = format!("background-{}.{ext}", &hash[..12]);
+    std::fs::write(dir.join(&name), &bytes).map_err(|e| format!("{name}: {e}"))?;
+    for old in std::fs::read_dir(dir).into_iter().flatten().flatten() {
+        let other = old.file_name().to_string_lossy().into_owned();
+        if other.starts_with("background-") && other != name {
+            let _ = std::fs::remove_file(old.path());
+        }
+    }
+    Ok(name)
+}
+
+/// Home's background, if the player keeps one and it is still there.
+pub fn background(dir: &Path, name: Option<&str>) -> Option<PathBuf> {
+    let name = name.filter(|n| n.starts_with("background-") && !n.contains(['/', '\\']))?;
+    Some(dir.join(name)).filter(|p| p.is_file())
+}
+
+#[cfg(test)]
+#[path = "themes/tests.rs"]
+mod tests;
diff --git a/launcher/src/themes/tests.rs b/launcher/src/themes/tests.rs
new file mode 100644
index 000000000..e66a5e083
--- /dev/null
+++ b/launcher/src/themes/tests.rs
@@ -0,0 +1,107 @@
+use super::*;
+use horizon_theme::{BLOCKS_DARK, BLOCKS_LIGHT};
+
+fn blend(top: u32, under: u32, alpha: f32) -> u32 {
+    let channel = |shift: u32| {
+        let (a, b) = ((top >> shift & 0xff) as f32, (under >> shift & 0xff) as f32);
+        ((a * alpha + b * (1. - alpha)).round() as u32) << shift
+    };
+    channel(16) | channel(8) | channel(0)
+}
+
+#[test]
+fn every_accent_reads_as_well_as_the_violet() {
+    for base in [BLOCKS_DARK, BLOCKS_LIGHT] {
+        for accent in Accent::ALL {
+            let p = accent.apply(base);
+            let what = format!(
+                "{} {}",
+                accent.name(),
+                if p.dark { "dark" } else { "light" }
+            );
+            let on_face = contrast(p.on_face, p.face);
+            assert!(on_face >= 4.5, "{what}: text on the face {on_face:.2}");
+            for g in [p.page, p.raised, p.button, p.panel, p.well] {
+                let ring = contrast(p.accent, g);
+                assert!(ring >= 3.0, "{what}: accent on {g:06x} {ring:.2}");
+            }
+            // Text over a selected suggestion (the launcher's theme::SELECTION).
+            let selected = contrast(p.ink, blend(p.accent, p.panel, 0.22));
+            assert!(selected >= 4.5, "{what}: text on a selection {selected:.2}");
+            let (_, _, face) = hsl(p.face);
+            assert!(
+                hsl(p.face_bevel).2 > face && hsl(p.face_lip).2 < face,
+                "{what}"
+            );
+            if accent != Accent::Violet {
+                let (h, _, _) = hsl(p.face);
+                let want = accent.hue().unwrap();
+                let off = ((h - want).rem_euclid(360.)).min((want - h).rem_euclid(360.));
+                assert!(off < 3., "{what}: face hue {h:.0}, not {want}");
+            }
+        }
+        let violet = Accent::Violet.apply(base);
+        assert_eq!((violet.accent, violet.face), (base.accent, base.face));
+    }
+}
+
+#[test]
+fn colours_go_to_hsl_and_back() {
+    for c in [
+        0x5b3fd6, 0x9a86ff, 0x000000, 0xffffff, 0x45c27a, 0xf0b84f, 0x123456,
+    ] {
+        let (h, s, l) = hsl(c);
+        assert_eq!(from_hsl(h, s, l), c, "{c:06x}");
+    }
+    assert_eq!(Accent::parse("Teal"), Some(Accent::Teal));
+    assert_eq!(Accent::parse("purple"), Some(Accent::Violet));
+    assert_eq!(Accent::parse("chartreuse"), None);
+    assert_eq!(serde_json::to_string(&Accent::Amber).unwrap(), "\"amber\"");
+}
+
+#[test]
+fn a_background_is_a_picture_kept_once() {
+    let root = std::env::temp_dir().join(format!("horizon-background-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&root);
+    std::fs::create_dir_all(&root).unwrap();
+    let picture = |name: &str, w: u32, h: u32| {
+        let path = root.join(name);
+        image::RgbImage::new(w, h).save(&path).unwrap();
+        path
+    };
+    let dir = root.join("data");
+    let png = picture("dusk.png", 160, 90);
+    let first = keep_background(&dir, &png).unwrap();
+    assert!(
+        first.starts_with("background-") && first.ends_with(".png"),
+        "{first}"
+    );
+    let jpg = picture("noon.jpg", 160, 90);
+    let second = keep_background(&dir, &jpg).unwrap();
+    assert!(second.ends_with(".jpg") && second != first, "{second}");
+    assert!(!dir.join(&first).exists(), "the older one goes");
+    assert_eq!(background(&dir, Some(&second)), Some(dir.join(&second)));
+    assert_eq!(background(&dir, Some(&first)), None, "gone");
+    assert_eq!(background(&dir, Some("../noon.jpg")), None);
+    assert_eq!(background(&dir, None), None);
+
+    let tiny = picture("tiny.png", 16, 16);
+    assert!(keep_background(&dir, &tiny)
+        .unwrap_err()
+        .contains("too small"));
+    let text = root.join("notes.txt");
+    std::fs::write(&text, "hi").unwrap();
+    assert!(keep_background(&dir, &text)
+        .unwrap_err()
+        .contains("PNG, JPEG or WebP"));
+    let fake = root.join("fake.png");
+    std::fs::write(&fake, "not a picture").unwrap();
+    assert!(keep_background(&dir, &fake)
+        .unwrap_err()
+        .contains("can read"));
+    assert!(
+        dir.join(&second).exists(),
+        "a refused file keeps the old one"
+    );
+    std::fs::remove_dir_all(&root).unwrap();
+}
diff --git a/launcher/src/themes_page.rs b/launcher/src/themes_page.rs
new file mode 100644
index 000000000..0f3ab890f
--- /dev/null
+++ b/launcher/src/themes_page.rs
@@ -0,0 +1,155 @@
+//! Settings' accent colour and Home background rows (`horizon_launcher::themes`).
+use super::*;
+use horizon_launcher::themes::{self, Accent};
+use std::path::PathBuf;
+
+/// Each accent's swatch, in points.
+const SWATCH: f32 = 26.;
+
+impl Launcher {
+    /// The theme Settings ask for, under the window's own light or dark.
+    pub(super) fn settings_theme(&self, window: &Window) -> Theme {
+        Theme::for_appearance(
+            self.settings.appearance,
+            self.settings.accent,
+            window.appearance(),
+        )
+    }
+
+    /// The picture behind Home, if the player keeps one.
+    pub(super) fn home_background(&self) -> Option<PathBuf> {
+        themes::background(&backend::data_dir(), self.settings.background.as_deref())
+    }
+
+    pub(super) fn accent_row(&self, cx: &mut Context<Self>) -> Div {
+        let t = self.theme;
+        let mut swatches = div().flex().gap(px(6.));
+        for accent in Accent::ALL {
+            let face = Theme::for_appearance(
+                if t.dark {
+                    backend::Appearance::Dark
+                } else {
+                    backend::Appearance::Light
+                },
+                accent,
+                gpui::WindowAppearance::Dark,
+            )
+            .face;
+            let chosen = self.settings.accent == accent;
+            swatches = swatches.child(
+                keyboard(
+                    div().id(SharedString::from(format!("accent-{}", accent.name()))),
+                    &t,
+                )
+                .size(px(SWATCH))
+                .bg(face)
+                .border_2()
+                .border_color(if chosen { t.ink } else { t.outline })
+                .cursor_pointer()
+                .when(chosen, |d| {
+                    d.flex()
+                        .items_center()
+                        .justify_center()
+                        .child(div().size(px(8.)).bg(t.on_face))
+                })
+                .on_click(cx.listener(move |this, _: &ClickEvent, window, cx| {
+                    this.settings.accent = accent;
+                    this.settings.save();
+                    this.theme = this.settings_theme(window);
+                    cx.notify();
+                })),
+            );
+        }
+        index_row(
+            0,
+            tr("Accent colour"),
+            Some(
+                div()
+                    .child(tr(
+                        "Horizon's violet by default. Every colour keeps text as easy to read.",
+                    ))
+                    .into_any_element(),
+            ),
+            Some(swatches.into_any_element()),
+            &t,
+        )
+    }
+
+    fn choose_background(&mut self, cx: &mut Context<Self>) {
+        let paths = cx.prompt_for_paths(PathPromptOptions {
+            files: true,
+            directories: false,
+            multiple: false,
+            prompt: Some(tr("Choose").to_string().into()),
+        });
+        cx.spawn(async move |this, cx| {
+            let Ok(Ok(Some(mut paths))) = paths.await else {
+                return;
+            };
+            let Some(path) = paths.pop() else {
+                return;
+            };
+            let _ = this.update(cx, |this, cx| {
+                this.take_background(&path);
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    fn take_background(&mut self, path: &std::path::Path) {
+        match themes::keep_background(&backend::data_dir(), path) {
+            Ok(name) => {
+                self.settings.background = Some(name);
+                self.settings.save();
+                self.background_error = None;
+            }
+            Err(e) => self.background_error = Some(e),
+        }
+    }
+
+    pub(super) fn home_background_row(&self, cx: &mut Context<Self>) -> Div {
+        let t = self.theme;
+        let custom = self.home_background().is_some();
+        let mut actions = div().flex().gap(px(4.)).child(
+            button(
+                "background-choose",
+                "Choose a picture…",
+                Kind::Secondary,
+                &t,
+            )
+            .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                this.choose_background(cx);
+                cx.notify();
+            })),
+        );
+        if custom {
+            actions = actions.child(
+                button("background-reset", "Landscape", Kind::Ghost, &t).on_click(cx.listener(
+                    |this, _: &ClickEvent, _, cx| {
+                        this.settings.background = None;
+                        this.settings.save();
+                        cx.notify();
+                    },
+                )),
+            );
+        }
+        let said = if custom {
+            tr("Your picture, behind Home, cropped to fill it.")
+        } else {
+            tr("Horizon's landscape. Pick a PNG, JPEG or WebP picture of your own.")
+        };
+        let detail = div().flex().flex_col().child(said.to_string()).children(
+            self.background_error
+                .clone()
+                .map(|e| div().text_color(t.danger).child(e)),
+        );
+        index_row(
+            0,
+            tr("Home background"),
+            Some(detail.into_any_element()),
+            Some(actions.into_any_element()),
+            &t,
+        )
+    }
+}

From 21fd3a6b064c121c058e1d80fb26b1473cd3aa69 Mon Sep 17 00:00:00 2001
From: asowneryt <asowneryt@protonmail.com>
Date: Tue, 27 Oct 2026 17:13:36 +1300
Subject: [PATCH 436/475] Turn End portal travellers as their teleport does

Checked against the decompiled 26.3 sources: EndPortalBlock's transition
out of the End is Relative.ROTATION plus the respawn data's yaw and pitch,
so a mob or item turns by the world spawn's angles instead of keeping its
own. Into the End it faces west and keeps its pitch, and calculateAbsolute
clamps the pitch to +-90 either way.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../horizon-client/src/game/nether_portal.rs  | 63 ++++++++++++++-----
 1 file changed, 48 insertions(+), 15 deletions(-)

diff --git a/crates/horizon-client/src/game/nether_portal.rs b/crates/horizon-client/src/game/nether_portal.rs
index d5808f07c..c8142284a 100644
--- a/crates/horizon-client/src/game/nether_portal.rs
+++ b/crates/horizon-client/src/game/nether_portal.rs
@@ -125,6 +125,19 @@ fn touches_end_portal(from: Vec3, to: Vec3, width: f32, height: f32, pos: BlockP
     );
     start.collided_along_vector(to.subtract(from), &[shape])
 }
+/// `PositionMoveRotation.calculateAbsolute` for an End portal's transition
+/// of an entity facing `[yaw, pitch]`: into the End it faces west and keeps
+/// its pitch (`Relative.X_ROT`); out of it both turn by the world spawn's
+/// angles (`Relative.ROTATION`). The pitch stays within ±90.
+fn end_portal_rotation(into_end: bool, [yaw, pitch]: [f32; 2], spawn: [f32; 2]) -> [f32; 2] {
+    let (yaw, pitch) = if into_end {
+        // Direction.WEST.toYRot().
+        (90.0, pitch)
+    } else {
+        (yaw + spawn[0], pitch + spawn[1])
+    };
+    [yaw, pitch.clamp(-90.0, 90.0)]
+}
 /// A waiting entity as `horizon_portal_arrivals.dat` keeps it.
 fn arrival_tag(a: &Arrival) -> Tag {
     let p = &a.plan;
@@ -276,21 +289,21 @@ impl Game<'_> {
         &*self.res.facts().get(state).name == "minecraft:end_portal"
     }
     /// Where an item or mob through an End portal lands once `plan`'s level
-    /// has loaded around it, and the yaw it faces there: the bottom centre
-    /// of the End's spawn point, above the platform built below it
-    /// (`EndPlatformFeature.createEndPlatform`), facing west; out of the End,
-    /// the top of the shared spawn's column (`Entity.adjustSpawnLocation`).
-    fn end_portal_exit(&mut self, plan: &Plan) -> (Vec3, Option<f32>) {
+    /// has loaded around it: the bottom centre of the End's spawn point,
+    /// above the platform built below it (`EndPlatformFeature.createEndPlatform`);
+    /// out of the End, the top of the shared spawn's column
+    /// (`Entity.adjustSpawnLocation`).
+    fn end_portal_exit(&mut self, plan: &Plan) -> Vec3 {
         let p = plan.approximate;
         let centre = Vec3::new(f64::from(p.x) + 0.5, f64::from(p.y), f64::from(p.z) + 0.5);
         if plan.dim == Dim::End {
-            return self.end_arrival(centre).unwrap_or_else(|e| {
+            if let Err(e) = self.end_arrival(centre) {
                 log::error!("End platform: {e}");
-                (centre, Some(90.0))
-            });
+            }
+            return centre;
         }
         let y = self.motion_top(p.x, p.z);
-        (Vec3::new(centre.x, f64::from(y), centre.z), None)
+        Vec3::new(centre.x, f64::from(y), centre.z)
     }
     /// The nether portal blocks of the chunks within `radius` of `center`
     /// (the points of interest `PortalForcer` searches): loaded chunks as
@@ -916,17 +929,19 @@ impl Game<'_> {
             self.portals.dirty = true;
             let motion = horizon_client::entity_nbt::motion(&tag);
             let [yaw, pitch] = horizon_client::entity_nbt::rotation(&tag);
-            let (at, motion, yaw) = if plan.end {
-                // Relative.DELTA and X_ROT: the motion and pitch are kept;
-                // the yaw faces west into the End, and is kept out of it.
-                let (at, west) = self.end_portal_exit(&plan);
-                (at, motion, west.unwrap_or(yaw))
+            let (at, motion, [yaw, pitch]) = if plan.end {
+                // Relative.DELTA: the motion is kept.
+                let at = self.end_portal_exit(&plan);
+                let into_end = plan.dim == Dim::End;
+                let turn =
+                    end_portal_rotation(into_end, [yaw, pitch], self.level.world_spawn_angle);
+                (at, motion, turn)
             } else {
                 let Some(exit) = self.nether_exit_portal(&plan) else {
                     continue;
                 };
                 let (at, rotation) = self.arrival(&plan, exit);
-                (at, rotate_y(motion, -rotation), yaw + rotation)
+                (at, rotate_y(motion, -rotation), [yaw + rotation, pitch])
             };
             if let Tag::Compound(c) = &mut tag {
                 c.insert("Pos".into(), doubles([at.x, at.y, at.z]));
@@ -1041,6 +1056,24 @@ mod tests {
         assert!(!touches_end_portal(beside, beside, 0.9, 1.4, portal));
     }
 
+    #[test]
+    fn end_portals_turn_entities_like_their_teleport_transition() {
+        // Into the End: facing west, pitch kept.
+        assert_eq!(
+            end_portal_rotation(true, [-30.0, 20.0], [45.0, 10.0]),
+            [90.0, 20.0]
+        );
+        // Out of it: turned by the world spawn's yaw and pitch, pitch clamped.
+        assert_eq!(
+            end_portal_rotation(false, [-30.0, 20.0], [45.0, 10.0]),
+            [15.0, 30.0]
+        );
+        assert_eq!(
+            end_portal_rotation(false, [0.0, 80.0], [0.0, 30.0]),
+            [0.0, 90.0]
+        );
+    }
+
     #[test]
     fn waiting_arrivals_keep_their_end_destination_when_saved() {
         let tag = Tag::compound([("id", Tag::String("minecraft:cow".into()))]);

From 39c8a2aa0e1ed85da1ef7b35fa13586aeccbc311 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 05:13:43 +0100
Subject: [PATCH 437/475] launcher: Home and the sidebar in French and Russian

The second part of the launcher's translation: Home's banner, rows, crash notice and
Join a friend, the instance row and its actions, the sidebar's headings and instance
states, the partner label, play times and "last played" dates, and the resources line.
Play's label clears its icon in wider languages.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 launcher/lang/fr.json          | 64 +++++++++++++++++++++++++++++++++-
 launcher/lang/ru.json          | 64 +++++++++++++++++++++++++++++++++-
 launcher/src/backend.rs        | 15 ++++----
 launcher/src/instances.rs      |  2 +-
 launcher/src/instances_page.rs | 28 ++++++++-------
 launcher/src/main.rs           | 46 +++++++++++++-----------
 launcher/src/partner.rs        |  2 +-
 launcher/src/worlds_page.rs    |  6 ++--
 8 files changed, 180 insertions(+), 47 deletions(-)

diff --git a/launcher/lang/fr.json b/launcher/lang/fr.json
index d2181dfcc..68ef9f744 100644
--- a/launcher/lang/fr.json
+++ b/launcher/lang/fr.json
@@ -91,5 +91,67 @@
   "Landscape": "Paysage",
   "Your picture, behind Home, cropped to fill it.": "Votre image, derrière l'accueil, recadrée pour le remplir.",
   "Horizon's landscape. Pick a PNG, JPEG or WebP picture of your own.": "Le paysage d'Horizon. Choisissez votre propre image PNG, JPEG ou WebP.",
-  "Home background": "Fond de l'accueil"
+  "Home background": "Fond de l'accueil",
+  "Play": "Jouer",
+  "Running": "En cours",
+  "Stopped": "Arrêté",
+  "Start the game, or run a server for others to join.": "Lancez le jeu, ou ouvrez un serveur que d'autres peuvent rejoindre.",
+  "No version installed yet.": "Aucune version installée pour l'instant.",
+  "Choose a version": "Choisir une version",
+  "Host a server": "Héberger un serveur",
+  "Preparing…": "Préparation…",
+  "Prepare": "Préparer",
+  "Prepare again": "Préparer à nouveau",
+  "Not found. Choose the folder where your launcher keeps Minecraft.": "Introuvable. Choisissez le dossier où votre launcher garde Minecraft.",
+  "Ready to play": "Prêt à jouer",
+  "Resources": "Ressources",
+  "Minecraft folder": "Dossier Minecraft",
+  "Choose…": "Choisir…",
+  "Playing offline": "Jeu hors ligne",
+  "Online servers need a Microsoft account.": "Les serveurs en ligne demandent un compte Microsoft.",
+  "Accounts…": "Comptes…",
+  "The first preparation takes a few minutes.": "La première préparation prend quelques minutes.",
+  "Horizon crashed": "Horizon a planté",
+  "When you report it on Discord, attach the crash report file (or paste it with Copy report) and say what you were doing.": "Pour le signaler sur Discord, joignez le rapport de plantage (ou collez-le avec Copier le rapport) et dites ce que vous faisiez.",
+  "The game ended without a crash report. When you report it on Discord, attach latest.log from the logs folder and say what you were doing.": "Le jeu s'est arrêté sans rapport de plantage. Pour le signaler sur Discord, joignez latest.log du dossier des journaux et dites ce que vous faisiez.",
+  "Open report": "Ouvrir le rapport",
+  "Copied": "Copié",
+  "Copy report": "Copier le rapport",
+  "Open logs folder": "Ouvrir le dossier des journaux",
+  "Report on Discord": "Signaler sur Discord",
+  "Dismiss": "Fermer",
+  "INSTANCES": "INSTANCES",
+  "SERVERS": "SERVEURS",
+  "HIDE": "MASQUER",
+  "Website": "Site web",
+  "Ready": "Prêt",
+  "Needs preparing": "À préparer",
+  "{version} is not installed": "{version} n'est pas installée",
+  "No version installed": "Aucune version installée",
+  "Modpack": "Modpack",
+  "From Horizon's registry": "Du registre d'Horizon",
+  "Instance": "Instance",
+  "Edit…": "Modifier…",
+  "Copy…": "Copier…",
+  "Export…": "Exporter…",
+  "Close export": "Fermer l'export",
+  "Launch…": "Lancement…",
+  "Close launch": "Fermer le lancement",
+  "Open folder": "Ouvrir le dossier",
+  "Join a friend": "Rejoindre un ami",
+  "Paste an invite code": "Collez un code d'invitation",
+  "Paste the code a friend shows when they invite you.": "Collez le code qu'un ami affiche quand il vous invite.",
+  "Join": "Rejoindre",
+  "Shortcut": "Raccourci",
+  "Remove shortcut": "Retirer le raccourci",
+  "today": "aujourd'hui",
+  "yesterday": "hier",
+  "{days} days ago": "il y a {days} jours",
+  "{time} in total · last played {when}": "{time} au total · joué pour la dernière fois {when}",
+  "Not played yet": "Pas encore joué",
+  "under a minute": "moins d'une minute",
+  "PARTNER": "PARTENAIRE",
+  "Not prepared. Horizon needs the files of your own Minecraft {version}.": "Pas préparé. Horizon a besoin des fichiers de votre propre Minecraft {version}.",
+  "Prepared for Minecraft {version}": "Préparé pour Minecraft {version}",
+  "Prepared for Minecraft {version}, without its sounds: the game will be silent. Prepare again to copy them from your Minecraft install.": "Préparé pour Minecraft {version}, sans ses sons : le jeu sera muet. Préparez à nouveau pour les copier depuis votre installation de Minecraft."
 }
diff --git a/launcher/lang/ru.json b/launcher/lang/ru.json
index d47b03cf0..48051bfac 100644
--- a/launcher/lang/ru.json
+++ b/launcher/lang/ru.json
@@ -91,5 +91,67 @@
   "Landscape": "Пейзаж",
   "Your picture, behind Home, cropped to fill it.": "Ваша картинка за главной страницей, обрезанная по размеру.",
   "Horizon's landscape. Pick a PNG, JPEG or WebP picture of your own.": "Пейзаж Horizon. Выберите свою картинку PNG, JPEG или WebP.",
-  "Home background": "Фон главной"
+  "Home background": "Фон главной",
+  "Play": "Играть",
+  "Running": "Запущено",
+  "Stopped": "Остановлен",
+  "Start the game, or run a server for others to join.": "Запустите игру или сервер, к которому смогут подключиться другие.",
+  "No version installed yet.": "Пока не установлено ни одной версии.",
+  "Choose a version": "Выбрать версию",
+  "Host a server": "Открыть сервер",
+  "Preparing…": "Подготовка…",
+  "Prepare": "Подготовить",
+  "Prepare again": "Подготовить заново",
+  "Not found. Choose the folder where your launcher keeps Minecraft.": "Не найдено. Выберите папку, где ваш лаунчер хранит Minecraft.",
+  "Ready to play": "Готово к игре",
+  "Resources": "Ресурсы",
+  "Minecraft folder": "Папка Minecraft",
+  "Choose…": "Выбрать…",
+  "Playing offline": "Игра офлайн",
+  "Online servers need a Microsoft account.": "Для онлайн-серверов нужен аккаунт Microsoft.",
+  "Accounts…": "Аккаунты…",
+  "The first preparation takes a few minutes.": "Первая подготовка занимает несколько минут.",
+  "Horizon crashed": "Horizon вылетел",
+  "When you report it on Discord, attach the crash report file (or paste it with Copy report) and say what you were doing.": "Сообщая об этом в Discord, приложите файл отчёта о сбое (или вставьте его через «Скопировать отчёт») и расскажите, что вы делали.",
+  "The game ended without a crash report. When you report it on Discord, attach latest.log from the logs folder and say what you were doing.": "Игра закрылась без отчёта о сбое. Сообщая об этом в Discord, приложите latest.log из папки журналов и расскажите, что вы делали.",
+  "Open report": "Открыть отчёт",
+  "Copied": "Скопировано",
+  "Copy report": "Скопировать отчёт",
+  "Open logs folder": "Открыть папку журналов",
+  "Report on Discord": "Сообщить в Discord",
+  "Dismiss": "Закрыть",
+  "INSTANCES": "СБОРКИ",
+  "SERVERS": "СЕРВЕРЫ",
+  "HIDE": "СКРЫТЬ",
+  "Website": "Сайт",
+  "Ready": "Готово",
+  "Needs preparing": "Нужна подготовка",
+  "{version} is not installed": "{version} не установлена",
+  "No version installed": "Версия не установлена",
+  "Modpack": "Сборка модов",
+  "From Horizon's registry": "Из каталога Horizon",
+  "Instance": "Сборка",
+  "Edit…": "Изменить…",
+  "Copy…": "Копировать…",
+  "Export…": "Экспорт…",
+  "Close export": "Закрыть экспорт",
+  "Launch…": "Запуск…",
+  "Close launch": "Закрыть запуск",
+  "Open folder": "Открыть папку",
+  "Join a friend": "Присоединиться к другу",
+  "Paste an invite code": "Вставьте код приглашения",
+  "Paste the code a friend shows when they invite you.": "Вставьте код, который друг показывает, когда приглашает вас.",
+  "Join": "Войти",
+  "Shortcut": "Ярлык",
+  "Remove shortcut": "Убрать ярлык",
+  "today": "сегодня",
+  "yesterday": "вчера",
+  "{days} days ago": "{days} дн. назад",
+  "{time} in total · last played {when}": "всего {time} · последняя игра: {when}",
+  "Not played yet": "Ещё не запускалась",
+  "under a minute": "меньше минуты",
+  "PARTNER": "ПАРТНЁР",
+  "Not prepared. Horizon needs the files of your own Minecraft {version}.": "Не подготовлено. Horizon нужны файлы вашего собственного Minecraft {version}.",
+  "Prepared for Minecraft {version}": "Подготовлено для Minecraft {version}",
+  "Prepared for Minecraft {version}, without its sounds: the game will be silent. Prepare again to copy them from your Minecraft install.": "Подготовлено для Minecraft {version}, но без звуков: игра будет беззвучной. Подготовьте заново, чтобы скопировать их из вашей установки Minecraft."
 }
diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs
index 3c2c3d3e4..17840fe90 100644
--- a/launcher/src/backend.rs
+++ b/launcher/src/backend.rs
@@ -651,14 +651,17 @@ fn sounds_in(resources: &Path) -> bool {
 
 /// What the Play page says of a version's resources.
 pub fn resources_summary(prepared: bool, sounds: bool, version: &str) -> String {
+    use crate::i18n::trf;
     match (prepared, sounds) {
-        (false, _) => {
-            format!("Not prepared. Horizon needs the files of your own Minecraft {version}.")
-        }
-        (true, true) => format!("Prepared for Minecraft {version}"),
-        (true, false) => format!(
+        (false, _) => trf(
+            "Not prepared. Horizon needs the files of your own Minecraft {version}.",
+            &[("version", version)],
+        ),
+        (true, true) => trf("Prepared for Minecraft {version}", &[("version", version)]),
+        (true, false) => trf(
             "Prepared for Minecraft {version}, without its sounds: the game will be silent. \
-             Prepare again to copy them from your Minecraft install."
+             Prepare again to copy them from your Minecraft install.",
+            &[("version", version)],
         ),
     }
 }
diff --git a/launcher/src/instances.rs b/launcher/src/instances.rs
index 38951bf02..0d47386cb 100644
--- a/launcher/src/instances.rs
+++ b/launcher/src/instances.rs
@@ -448,7 +448,7 @@ fn record_play_in(
 pub fn play_time(played: Duration) -> String {
     let minutes = played.as_secs() / 60;
     match (minutes / 60, minutes % 60) {
-        (0, 0) => "under a minute".into(),
+        (0, 0) => crate::i18n::tr("under a minute").into(),
         (0, m) => format!("{m} min"),
         (h, m) if h < 100 => format!("{h} h {m:02} min"),
         (h, _) => format!("{h} h"),
diff --git a/launcher/src/instances_page.rs b/launcher/src/instances_page.rs
index b0777e9ba..e94fffaaa 100644
--- a/launcher/src/instances_page.rs
+++ b/launcher/src/instances_page.rs
@@ -190,11 +190,11 @@ impl Launcher {
                 InstanceKind::Default | InstanceKind::Own => (
                     self.page == Page::Play && selected.as_ref() == Some(&i.id),
                     match (&tag, &i.version) {
-                        (None, Some(own)) => format!("{own} is not installed"),
-                        (None, None) => "No version installed".into(),
-                        (Some(_), _) if !prepared => "Needs preparing".into(),
-                        (Some(tag), Some(_)) => format!("Ready · {tag}"),
-                        (Some(_), None) => "Ready".into(),
+                        (None, Some(own)) => trf("{version} is not installed", &[("version", own)]),
+                        (None, None) => tr("No version installed").into(),
+                        (Some(_), _) if !prepared => tr("Needs preparing").into(),
+                        (Some(tag), Some(_)) => format!("{} · {tag}", tr("Ready")),
+                        (Some(_), None) => tr("Ready").into(),
                     },
                 ),
                 InstanceKind::Port => {
@@ -202,10 +202,10 @@ impl Launcher {
                     let summary = self.packs.iter().find(|p| p.slug == slug);
                     (
                         on_packs && self.pack_open.as_deref() == Some(slug),
-                        summary.map_or_else(|| "Modpack".into(), |p| p.summary()),
+                        summary.map_or_else(|| tr("Modpack").into(), |p| p.summary()),
                     )
                 }
-                InstanceKind::Pack => (false, "From Horizon's registry".into()),
+                InstanceKind::Pack => (false, tr("From Horizon's registry").into()),
             };
             let dot = matches!(i.kind, InstanceKind::Default | InstanceKind::Own).then(|| {
                 div()
@@ -621,7 +621,7 @@ impl Launcher {
             );
         Some(index_row(
             n,
-            "Instance",
+            tr("Instance"),
             Some(
                 div()
                     .flex()
@@ -651,12 +651,14 @@ impl Launcher {
 /// "3 h 05 min in total · last played today", or "Not played yet".
 fn played_line(instance: &Instance) -> String {
     match instance.last_played {
-        Some(when) => format!(
-            "{} in total · last played {}",
-            instances::play_time(instance.played),
-            worlds_page::ago(when)
+        Some(when) => trf(
+            "{time} in total · last played {when}",
+            &[
+                ("time", &instances::play_time(instance.played)),
+                ("when", &worlds_page::ago(when)),
+            ],
         ),
-        None => "Not played yet".into(),
+        None => tr("Not played yet").into(),
     }
 }
 
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index e1c0e8ca9..bd7822bd6 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -1755,7 +1755,7 @@ impl Launcher {
             .flex()
             .flex_col()
             .gap(px(4.))
-            .child(heading("INSTANCES".into()).child(add))
+            .child(heading(tr("INSTANCES").into()).child(add))
             .children(self.instance_items(heading, cx));
         let servers: Vec<_> = self
             .servers
@@ -1764,7 +1764,7 @@ impl Launcher {
             .unwrap_or_else(|| self.side_servers.clone());
         let mut list = list;
         if !servers.is_empty() {
-            list = list.child(heading("SERVERS".into()));
+            list = list.child(heading(tr("SERVERS").into()));
         }
         for e in servers {
             let up = self.servers.is_up(&e.dir);
@@ -1790,7 +1790,7 @@ impl Launcher {
                             .flex_col()
                             .min_w_0()
                             .child(title(e.name.clone()))
-                            .child(sub(if up { "Running" } else { "Stopped" }.into())),
+                            .child(sub(tr(if up { "Running" } else { "Stopped" }).into())),
                     )
                     .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
                         this.servers.open = Some(dir.clone());
@@ -1874,7 +1874,7 @@ impl Launcher {
                         text(theme::MICRO)
                             .text_color(t.muted)
                             .hover(move |s| s.text_color(t.ink))
-                            .child("HIDE"),
+                            .child(tr("HIDE")),
                     )
                     .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
                         this.settings.partner_hidden = true;
@@ -1896,7 +1896,7 @@ impl Launcher {
         if !self.links.website.is_empty() {
             foot = foot.child(link(
                 "website",
-                "Website",
+                tr("Website"),
                 "globe",
                 self.links.website.clone(),
             ));
@@ -2061,7 +2061,7 @@ impl Launcher {
                     "Start the game, or run a server for others to join.",
                     &t,
                 ))
-                .child(centered("No version installed yet.", &t).child(
+                .child(centered(tr("No version installed yet."), &t).child(
                     button("go-versions", "Choose a version", Kind::Secondary, &t).on_click(
                         cx.listener(|this, _: &ClickEvent, _, cx| {
                             this.go(Page::Versions);
@@ -2077,10 +2077,12 @@ impl Launcher {
         let hero = self.hero(&tag, &version, prepared, cx);
         let running = self.client.is_some() || self.starting_client.is_some();
         let play_label = if running { "Running" } else { "Play" };
+        // The label clears the icon in every language ("Играть" is wider than "Play").
         let mut play = button("play", play_label, Kind::Primary, &t)
             .min_w(px(200.))
             .h(px(60.))
-            .px(px(28.))
+            .pl(px(60.))
+            .pr(px(28.))
             .text_size(px(28.))
             .font_weight(FontWeight::SEMIBOLD)
             .child(
@@ -2121,7 +2123,7 @@ impl Launcher {
             );
 
         let resources_value = if self.preparing {
-            "Preparing…".to_string()
+            tr("Preparing…").to_string()
         } else {
             backend::resources_summary(prepared, !silent, &version)
         };
@@ -2146,7 +2148,9 @@ impl Launcher {
         let minecraft = self.settings.minecraft_dir.as_deref().map_or_else(
             || {
                 div()
-                    .child("Not found. Choose the folder where your launcher keeps Minecraft.")
+                    .child(tr(
+                        "Not found. Choose the folder where your launcher keeps Minecraft.",
+                    ))
                     .into_any_element()
             },
             |p| {
@@ -2165,14 +2169,14 @@ impl Launcher {
             .children(self.launch_panel(cx))
             .child(index_row(
                 2,
-                "Resources",
+                tr("Resources"),
                 Some(div().child(resources_value).into_any_element()),
                 Some(prepare.into_any_element()),
                 &t,
             ))
             .child(index_row(
                 3,
-                "Minecraft folder",
+                tr("Minecraft folder"),
                 Some(minecraft),
                 Some(
                     button("choose-mc", "Choose…", Kind::Ghost, &t)
@@ -2188,10 +2192,10 @@ impl Launcher {
             if self.accounts.selected().is_none() && account::client_id().is_some() {
                 rows = rows.child(index_row(
                     5,
-                    "Playing offline",
+                    tr("Playing offline"),
                     Some(
                         div()
-                            .child("Online servers need a Microsoft account.")
+                            .child(tr("Online servers need a Microsoft account."))
                             .into_any_element(),
                     ),
                     Some(
@@ -2276,7 +2280,7 @@ impl Launcher {
                     .child(
                         text(theme::CAPTION)
                             .text_color(t.muted)
-                            .child("The first preparation takes a few minutes."),
+                            .child(tr("The first preparation takes a few minutes.")),
                     ),
             );
         }
@@ -2370,11 +2374,11 @@ impl Launcher {
                 },
             )),
         );
-        let help = if crash.report.is_some() {
+        let help = tr(if crash.report.is_some() {
             "When you report it on Discord, attach the crash report file (or paste it with Copy report) and say what you were doing."
         } else {
             "The game ended without a crash report. When you report it on Discord, attach latest.log from the logs folder and say what you were doing."
-        };
+        });
         let mut body = div()
             .flex_1()
             .min_w_0()
@@ -2384,7 +2388,7 @@ impl Launcher {
             .child(
                 text(theme::HEADING)
                     .text_color(t.ink)
-                    .child("Horizon crashed"),
+                    .child(tr("Horizon crashed")),
             );
         if !crash.summary.is_empty() {
             body = body.child(div().text_color(t.ink_soft).child(crash.summary));
@@ -2460,7 +2464,7 @@ impl Launcher {
                             .child(caps(format!("Minecraft {version}")).text_color(t.ink_soft))
                             .child(div().size(px(4.)).bg(t.muted))
                             .child(
-                                caps(if prepared { "Ready" } else { "Needs preparing" })
+                                caps(tr(if prepared { "Ready" } else { "Needs preparing" }))
                                     .text_color(if prepared { t.success } else { t.warn }),
                             ),
                     )
@@ -3153,7 +3157,7 @@ impl Launcher {
             .text_size(px(12.))
             .cursor_text()
             .child(if self.friend_code.is_empty() && !focused {
-                div().text_color(t.muted).child("Paste an invite code")
+                div().text_color(t.muted).child(tr("Paste an invite code"))
             } else {
                 // The end of a long code stays in view while typing.
                 let shown: String = {
@@ -3203,10 +3207,10 @@ impl Launcher {
         }
         index_row(
             4,
-            "Join a friend",
+            tr("Join a friend"),
             Some(
                 div()
-                    .child("Paste the code a friend shows when they invite you.")
+                    .child(tr("Paste the code a friend shows when they invite you."))
                     .into_any_element(),
             ),
             Some(
diff --git a/launcher/src/partner.rs b/launcher/src/partner.rs
index c4feac7b8..6242f9228 100644
--- a/launcher/src/partner.rs
+++ b/launcher/src/partner.rs
@@ -38,7 +38,7 @@ pub fn banner(id: &'static str, width: f32, t: &Theme) -> Stateful<Div> {
             crate::text(crate::theme::MICRO)
                 .text_color(t.muted)
                 .group_hover(id, move |s| s.text_color(t.ink))
-                .child("PARTNER"),
+                .child(horizon_launcher::i18n::tr("PARTNER")),
         )
         .child(
             div().relative().group_hover(id, |s| s.top(px(-2.))).child(
diff --git a/launcher/src/worlds_page.rs b/launcher/src/worlds_page.rs
index 16484a10a..b850c306a 100644
--- a/launcher/src/worlds_page.rs
+++ b/launcher/src/worlds_page.rs
@@ -32,9 +32,9 @@ pub(super) fn ago(when: std::time::SystemTime) -> String {
     let when: chrono::DateTime<chrono::Local> = when.into();
     let days = (chrono::Local::now().date_naive() - when.date_naive()).num_days();
     match days {
-        ..=0 => "today".into(),
-        1 => "yesterday".into(),
-        2..=13 => format!("{days} days ago"),
+        ..=0 => tr("today").into(),
+        1 => tr("yesterday").into(),
+        2..=13 => trf("{days} days ago", &[("days", &days.to_string())]),
         _ => when.format("%Y-%m-%d").to_string(),
     }
 }

From a19cad22cb4efc178809343a4fb1b5df6298805c Mon Sep 17 00:00:00 2001
From: Kacpherek <papiezkacper10@gmail.com>
Date: Tue, 27 Oct 2026 05:51:10 +0100
Subject: [PATCH 438/475] A mob jumps out of a fluid only where Entity.isFree
 allows: no liquid in the box

---
 crates/horizon-client/src/mobs/living.rs | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs
index ce3183721..b1b2a3c38 100644
--- a/crates/horizon-client/src/mobs/living.rs
+++ b/crates/horizon-client/src/mobs/living.rs
@@ -320,6 +320,18 @@ impl MobWorld<'_> {
         };
         scene.unobstructed(b).unwrap_or(false)
     }
+    /// `Entity.isFree`: no collision and `LevelReader.containsAnyLiquid` false
+    /// over the blocks from the box's minimum corner to its maximum corner.
+    pub fn is_free(&self, b: Aabb) -> bool {
+        let (lo, hi) = (b.min_position(), b.max_position());
+        let liquid = (lo.x.floor() as i32..=hi.x.floor() as i32).any(|x| {
+            (lo.y.floor() as i32..=hi.y.floor() as i32).any(|y| {
+                (lo.z.floor() as i32..=hi.z.floor() as i32)
+                    .any(|z| self.facts.get(self.world.block(x, y, z)).fluid != Fluid::None)
+            })
+        });
+        !liquid && self.no_collision(b)
+    }
 }
 impl Mob {
     /// `Entity.refreshDimensions` after growing from `old_w` by `old_h`:
@@ -938,7 +950,7 @@ impl Mob {
         // jumpOutOfFluid
         let m = self.velocity;
         if self.horizontal_collision
-            && w.no_collision(self.bounds().move_by(Vec3::new(
+            && w.is_free(self.bounds().move_by(Vec3::new(
                 m.x,
                 m.y + f64::from(0.6_f32) - self.position.y + old_y,
                 m.z,

From 4f6e4e72b1794160cc610d0559f3af15d3912138 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:20:42 +0100
Subject: [PATCH 439/475] Keep a client's effects until the server removes them

26.3's client LivingEntity.tickEffects only runs tickClient on each effect;
the server's ClientboundRemoveMobEffectPacket removes one. The join reset
stays. The AGENTS.md wording is the maintainer's to change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                 | 3 +--
 crates/horizon-client/src/game/potions.rs | 6 ++----
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index be78da022..4d2a258ec 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -15,8 +15,7 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
 - **Mark what an agent posts.** A PR body starts with a line naming whose agent opened it and with what.
   Ludovic's agents write `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.`, and a
   contributor's agent names its own person and tool (issues: "Filed by", reviews: "Review by"). Every
-  comment starts with `🤖 Agent:`. Name people by their GitHub handle (`gh api user --jq .login`), never a
-  real name. Never write as Ludovic or as anyone else.
+  comment starts with `🤖 Agent:`. Never write as Ludovic or as anyone else.
 - **Attribution.** Commits end with a `Co-Authored-By:` line for the agent that wrote them, and PR bodies
   with that agent's own "Generated with" line. Ludovic's agents use
   `Co-Authored-By: Claude <model> <noreply@anthropic.com>` and
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index 6334ff5ad..2ccfd4116 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -427,11 +427,9 @@ impl Game<'_> {
     /// `MobEffectInstance.tickClient`): they count down, and the server
     /// removes them. Their modifiers and flags move the predicted player.
     pub(super) fn tick_client_effects(&mut self) {
-        // LivingEntity.tickEffects (client): an exhausted effect drops.
-        self.potions.effects.list.retain_mut(|e| {
+        for e in &mut self.potions.effects.list {
             e.tick_client();
-            e.duration != 0
-        });
+        }
         self.apply_effect_status();
     }
     /// Add an active effect to the player and update attributes / absorption.

From 2ba33bd1465537b3ee676a30f11134ee895a650a Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:21:20 +0100
Subject: [PATCH 440/475] jumpOutOfFluid: only entities a mob collides with
 block the hop

EntityGetter.getEntityCollisions keeps the entities that canBeCollidedWith
the mob: among mobs that is a living shulker, not every mob nearby.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/mobs/living.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs
index 7331eb344..bc112e51a 100644
--- a/crates/horizon-client/src/mobs/living.rs
+++ b/crates/horizon-client/src/mobs/living.rs
@@ -833,8 +833,8 @@ impl Mob {
                 self.velocity.y -= gravity / 4.0;
             }
         }
-        // jumpOutOfFluid: Entity.isFree wants the box dry and clear of
-        // collidable entities too.
+        // jumpOutOfFluid: Entity.isFree wants the box dry and clear of the
+        // entities a mob collides with (canBeCollidedWith: living shulkers).
         let m = self.velocity;
         let ahead = self.bounds().move_by(Vec3::new(
             m.x,
@@ -847,7 +847,12 @@ impl Mob {
             && !w.contains_any_liquid(ahead)
             && !w
                 .others_near(wide)
-                .any(|s| s.id != self.id && s.alive && s.bounds.intersects(wide))
+                .any(|s| {
+                    s.id != self.id
+                        && s.alive
+                        && s.species == super::Species::Shulker
+                        && s.bounds.intersects(wide)
+                })
         {
             self.velocity.y = f64::from(0.3_f32);
         }

From 6cb5e4954e3718ba55d1347c47157f7faa0f4127 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:21:51 +0100
Subject: [PATCH 441/475] An occupied horse gives no inventory or feeding
 either

AbstractHorse.mobInteract (and Horse/ZombieHorse/AbstractChestedHorse)
hand an isVehicle horse to Mob.mobInteract before the inventory, the
feeding and the ride, so the passenger check goes before all three.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/mounts.rs | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/crates/horizon-client/src/game/mounts.rs b/crates/horizon-client/src/game/mounts.rs
index 7da98135f..fa0052bc5 100644
--- a/crates/horizon-client/src/game/mounts.rs
+++ b/crates/horizon-client/src/game/mounts.rs
@@ -126,6 +126,19 @@ impl Game<'_> {
         if !equine::is_equine(species) || !m.alive() || Some(m.id) == self.riding {
             return false;
         }
+        // AbstractHorse.mobInteract: a horse a mob rides (`isVehicle`) has no
+        // seat, inventory or feeding to give. Camels seat two and check their
+        // passengers themselves.
+        let id = m.id;
+        if !matches!(species, Species::Camel | Species::CamelHusk)
+            && self
+                .mobs
+                .iter()
+                .any(|p| p.extra.mount == Some(id) && !p.removed && p.alive())
+        {
+            return false;
+        }
+        let m = &self.mobs[index];
         // AbstractHorse.mobInteract: shift + use opens a tamed adult's inventory.
         if !m.is_baby()
             && m.extra.tame
@@ -175,17 +188,6 @@ impl Game<'_> {
             return true;
         }
         // doPlayerRide
-        // Entity.canAddPassenger: ordinary horses have one seat. Camels
-        // override that capacity; equipment and feeding above are separate.
-        if !matches!(species, Species::Camel | Species::CamelHusk)
-            && self.mobs.iter().any(|passenger| {
-                passenger.extra.mount == Some(self.mobs[index].id)
-                    && !passenger.removed
-                    && passenger.alive()
-            })
-        {
-            return false;
-        }
         let m = &mut self.mobs[index];
         m.extra.flag = false;
         m.extra.counter = 0;

From 03d8ffe2c6f6cd7f379485900e4d818b7db0ce5a Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:22:28 +0100
Subject: [PATCH 442/475] Sign editor: send the lines as edited, sign or not

AbstractSignEditScreen.setMessage writes messages[line] and the sign;
removed() sends messages. The editor keeps its lines up to date, so a
sign removed while it is open still gets the player's text (review by
rdbt's agent).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/sign_edit.rs | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/crates/horizon-client/src/game/sign_edit.rs b/crates/horizon-client/src/game/sign_edit.rs
index 529e511f2..cd82c542b 100644
--- a/crates/horizon-client/src/game/sign_edit.rs
+++ b/crates/horizon-client/src/game/sign_edit.rs
@@ -20,8 +20,8 @@ pub(super) struct SignEditor {
     pub line: usize,
     /// The line being edited (`AbstractSignEditScreen`'s text field).
     edit: EditBox,
-    /// `AbstractSignEditScreen.messages`: the lines when it opened, sent if
-    /// the sign is gone by the time the editor closes.
+    /// `AbstractSignEditScreen.messages`: the side's lines as edited, sent
+    /// when the editor closes, even if the sign is gone by then.
     lines: [String; 4],
 }
 
@@ -61,14 +61,9 @@ impl Game<'_> {
     pub(super) fn close_sign_editor(&mut self) {
         if let Some(edit) = self.sign_edit.take() {
             if self.remote.is_some() {
-                let lines = match self.world.block_entities.get(&edit.pos) {
-                    Some(BlockEntity::Sign(sign)) if edit.front => sign.front.lines.clone(),
-                    Some(BlockEntity::Sign(sign)) => sign.back.lines.clone(),
-                    _ => edit.lines,
-                };
                 self.send(S::SignUpdate(play::SignUpdate {
                     pos: [edit.pos.0, edit.pos.1, edit.pos.2],
-                    lines,
+                    lines: edit.lines,
                     front: edit.front,
                 }));
             } else {
@@ -219,7 +214,8 @@ impl Game<'_> {
             edit.edit.set_value(&text);
         }
     }
-    /// The box's text onto the sign, when it still fits the line.
+    /// The box's text onto the editor's lines and the sign
+    /// (`AbstractSignEditScreen.setMessage`), when it still fits the line.
     fn sign_write(&mut self) {
         let Some(edit) = self.sign_edit.as_ref() else {
             return;
@@ -228,6 +224,9 @@ impl Game<'_> {
         if !self.sign_fits(&value) {
             return;
         }
+        if let Some(edit) = self.sign_edit.as_mut() {
+            edit.lines[line].clone_from(&value);
+        }
         let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&pos) else {
             return;
         };

From ab099b2701d68f61ca534e8fb1b66662183461a6 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:28:26 +0100
Subject: [PATCH 443/475] rustfmt

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/mobs/living.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs
index bc112e51a..1e2b0c4ee 100644
--- a/crates/horizon-client/src/mobs/living.rs
+++ b/crates/horizon-client/src/mobs/living.rs
@@ -845,14 +845,12 @@ impl Mob {
         if self.horizontal_collision
             && w.no_collision(ahead)
             && !w.contains_any_liquid(ahead)
-            && !w
-                .others_near(wide)
-                .any(|s| {
-                    s.id != self.id
-                        && s.alive
-                        && s.species == super::Species::Shulker
-                        && s.bounds.intersects(wide)
-                })
+            && !w.others_near(wide).any(|s| {
+                s.id != self.id
+                    && s.alive
+                    && s.species == super::Species::Shulker
+                    && s.bounds.intersects(wide)
+            })
         {
             self.velocity.y = f64::from(0.3_f32);
         }

From 79fca908869c1a6a2e44f5a5e1a56de083db644f Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:29:42 +0100
Subject: [PATCH 444/475] Tame a pet to the player's real UUID, not an unset
 placeholder

acting_uuid() falls back to [0, 0, 0, 0] while level.player_uuid is unset (a new
world before its first save); the owner saved then never matches the UUID the
world gets, so the player could no longer command the pet after a reload.
acting_player_uuid() assigns the world's player UUID first, as dropped items do.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/creatures.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 68964a3fd..aaef37a64 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -2739,7 +2739,7 @@ impl Game<'_> {
             .items()
             .get(&item)
             .is_some_and(|i| i.max_damage > 0);
-        let acting = self.acting_uuid();
+        let acting = self.acting_player_uuid();
         let m = &mut self.mobs[index];
         if !m.alive() {
             return Ok(false);

From 370444eed09d8ea3dccf37887820278c8e2c0a0e Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:29:50 +0100
Subject: [PATCH 445/475] Dim the End flash's light under a boss bar's world
 fog

LightmapRenderStateExtractor adds a third of the flash's intensity to the sky
factor while the boss overlay creates world fog (the dragon fight).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/end.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs
index b34a86183..7901ce258 100644
--- a/crates/horizon-client/src/game/end.rs
+++ b/crates/horizon-client/src/game/end.rs
@@ -254,10 +254,16 @@ impl Game<'_> {
     }
 
     /// LightmapRenderStateExtractor: End flashes add to the sky light factor
-    /// unless Hide Lightning Flashes is on (the sky sprite is not gated).
+    /// unless Hide Lightning Flashes is on (the sky sprite is not gated), a
+    /// third of it under a boss bar's world fog.
     pub(super) fn end_flash_sky(&self, sky: &mut horizon_client::environment::Sky, partial: f64) {
         if self.dim == Dim::End && !self.settings.file.bool("hideLightningFlashes") {
-            sky.sky_light_factor += self.end.flash.intensity(partial as f32);
+            let intensity = self.end.flash.intensity(partial as f32);
+            sky.sky_light_factor += if self.boss_overlay.should_create_world_fog() {
+                intensity / 3.0
+            } else {
+                intensity
+            };
         }
     }
 

From 765cef8a4eb33b82f7f9e8c79ede3d037f513968 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:29:56 +0100
Subject: [PATCH 446/475] Put the candle's doc comment back on candle

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/animate_tick.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/animate_tick.rs b/crates/horizon-client/src/animate_tick.rs
index 0160071d9..5e0bfbb8f 100644
--- a/crates/horizon-client/src/animate_tick.rs
+++ b/crates/horizon-client/src/animate_tick.rs
@@ -1213,7 +1213,6 @@ fn block_animate_tick(
         }
     }
 }
-/// `AbstractCandleBlock.addParticlesAndSound`.
 /// `AmbientLeavesBlockSoundPlayer.playAmbientLeavesSounds` for the poplar leaves:
 /// one log and three leaves of the same kind around the block.
 fn leaves_ambient_sound(
@@ -1299,6 +1298,7 @@ fn sand_sound_nearby(tables: &AnimateTables, ctx: &AnimateContext, pos: [i32; 3]
     }
     false
 }
+/// `AbstractCandleBlock.addParticlesAndSound`.
 fn candle(engine: &mut ParticleEngine, p: [f64; 3]) {
     let r = engine.random();
     let chance = r.next_float();

From 5435eb0f17d6f655604ba9cec75a6d2a829ad0fa Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:30:07 +0100
Subject: [PATCH 447/475] Send a cold strider's shiver at index 19

AgeableMob has two entries in 26.3 (DATA_BABY_ID 16, AGE_LOCKED 17), so
Strider's DATA_BOOST_TIME is 18 and DATA_SUFFOCATING 19. A boolean at 18 is
the wrong type for that slot on a vanilla client.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/lan.rs    | 8 ++++----
 crates/horizon-client/src/game/remote.rs | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 967d29e40..8bed065a8 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -372,8 +372,8 @@ fn mob_meta(
 }
 
 /// What a client shakes a mob by: Entity.DATA_TICKS_FROZEN (7), whose full
-/// count is `isFullyFrozen`, and Strider.DATA_SUFFOCATING (18, after
-/// AgeableMob's baby flag and DATA_BOOST_TIME).
+/// count is `isFullyFrozen`, and Strider.DATA_SUFFOCATING (19, after
+/// AgeableMob's two and DATA_BOOST_TIME).
 fn mob_freeze_meta(
     m: &Mob,
     meta: &mut Vec<(u8, i32, Value)>,
@@ -385,9 +385,9 @@ fn mob_freeze_meta(
     defaults.push((7, serializer::INT, Value::Int(0)));
     if m.kind.id == "minecraft:strider" {
         if m.extra.flag {
-            meta.push((18, serializer::BOOLEAN, Value::Bool(true)));
+            meta.push((19, serializer::BOOLEAN, Value::Bool(true)));
         }
-        defaults.push((18, serializer::BOOLEAN, Value::Bool(false)));
+        defaults.push((19, serializer::BOOLEAN, Value::Bool(false)));
     }
 }
 
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 08f76033a..d05d21651 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -1921,9 +1921,9 @@ impl Game<'_> {
                         match (index, value) {
                             // Entity.DATA_TICKS_FROZEN: isFullyFrozen shakes it.
                             (7, Value::Int(ticks)) => m.ticks_frozen = *ticks,
-                            // Strider.DATA_SUFFOCATING (after AgeableMob's baby
-                            // flag and DATA_BOOST_TIME): a cold strider shakes.
-                            (18, Value::Bool(cold))
+                            // Strider.DATA_SUFFOCATING (after AgeableMob's two
+                            // and DATA_BOOST_TIME): a cold strider shakes.
+                            (19, Value::Bool(cold))
                                 if m.species() == horizon_client::mobs::Species::Strider =>
                             {
                                 m.extra.flag = *cold;

From 6c09ec2cc89febd655ff7eb414e8c1faf8c93df8 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:30:27 +0100
Subject: [PATCH 448/475] Save a player effect's icon as shown only when its
 particles are

MobEffectInstance's show_icon defaults to show_particles: an effect given with
hidden particles hides its icon too, and keeps doing so after a reload.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/save.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs
index f965cf406..f3149c578 100644
--- a/crates/horizon-client/src/save.rs
+++ b/crates/horizon-client/src/save.rs
@@ -3152,7 +3152,7 @@ impl Level {
                                 ("amplifier", Tag::Byte(*amplifier as i8)),
                                 ("ambient", Tag::Byte(i8::from(*ambient))),
                                 ("show_particles", Tag::Byte(i8::from(*particles))),
-                                ("show_icon", Tag::Byte(1)),
+                                ("show_icon", Tag::Byte(i8::from(*particles))),
                             ])
                         })
                         .collect(),

From 57213668a0be5f67c68e5864182c8bc72d9db031 Mon Sep 17 00:00:00 2001
From: "minimax-m3.1-flash" <noreply@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:09:25 +0500
Subject: [PATCH 449/475] Add a regression test: an arrow kills a player at
 half a heart

The health layer spends the last of the player's health and raises the dead
flag, so Game::tick can show the death screen.

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 crates/horizon-client/src/health.rs | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/crates/horizon-client/src/health.rs b/crates/horizon-client/src/health.rs
index 46821df27..4514c2bcf 100644
--- a/crates/horizon-client/src/health.rs
+++ b/crates/horizon-client/src/health.rs
@@ -860,6 +860,31 @@ mod tests {
         assert!(!third.hurt && !third.knockback);
     }
 
+    /// #2141: an arrow that takes the last of the player's health must kill
+    /// them: `LivingEntity.hurt` leaves the health at zero and `Player.die`
+    /// follows.
+    #[test]
+    fn an_arrow_kills_a_player_at_one_health() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = crate::assets::Assets::load(&root).unwrap();
+        let resources = crate::motion::MotionResources::load(&root, &assets).unwrap();
+        let mut player =
+            crate::motion::PlayerMotion::new(&resources, horizon_core::geometry::Vec3::ZERO)
+                .unwrap();
+        player.set_health(1.0, false).unwrap();
+        let (health, rules) = (&resources.health, super::HealthRules::default());
+        let id = health.damage.id("minecraft:arrow").unwrap();
+        let hurt = player.hurt(health, rules, id, 5.0).unwrap();
+        assert!(hurt, "the arrow must hurt");
+        assert_eq!(player.health.health(), 0.0, "the health must be spent");
+        assert!(player.health.dead_or_dying(), "the player must be dead");
+    }
+
     #[test]
     fn hurt_sounds_follow_damage_effects() {
         // DamageEffects: HURT, THORNS, DROWNING, BURNING, POKING, FREEZING.

From 40f8b9600d3f54a55d73b02151485664cffbdaed Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:34:02 +0100
Subject: [PATCH 450/475] Shulker canStayAt: only collidable entities block the
 shell

Level.noCollision(shulker, box) keeps the entities whose
canBeCollidedWith is true for the shulker: living shulkers and adult
happy ghasts (boats and minecarts too, outside the mob world). Players
and other mobs never stop a shulker from opening or landing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/mobs/shulker.rs | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/crates/horizon-client/src/mobs/shulker.rs b/crates/horizon-client/src/mobs/shulker.rs
index d5bdb6888..32f952e15 100644
--- a/crates/horizon-client/src/mobs/shulker.rs
+++ b/crates/horizon-client/src/mobs/shulker.rs
@@ -89,9 +89,10 @@ fn progress_aabb(direction: u8, from: f64, to: f64, pos: Vec3) -> Aabb {
         ))
         .move_by(pos)
 }
-/// `Level.noCollision(entity, aabb)`: no block collision under the empty
-/// context, and no entity `m` can be collided with overlaps (other mobs,
-/// and the player when they are not a spectator).
+/// `Level.noCollision(shulker, aabb)`: no block collision under the empty
+/// context, and none of the entities a shulker collides with overlaps
+/// (`canBeCollidedWith`: living shulkers and adult happy ghasts; players
+/// and other mobs never block it).
 fn no_collision(m: &Mob, w: &MobWorld, bounds: Aabb) -> bool {
     let mut scene = crate::collisions::SceneCollisions {
         world: w.world,
@@ -102,15 +103,12 @@ fn no_collision(m: &Mob, w: &MobWorld, bounds: Aabb) -> bool {
         return false;
     }
     let grown = bounds.inflate(Vec3::new(1.0e-7, 1.0e-7, 1.0e-7));
-    if let Some(p) = &w.player
-        && p.alive
-        && !p.spectator
-        && p.bounds.intersects(grown)
-    {
-        return false;
-    }
-    !w.others_near(grown)
-        .any(|s| s.id != m.id && s.alive && s.bounds.intersects(grown))
+    !w.others_near(grown).any(|s| {
+        s.id != m.id
+            && s.alive
+            && (s.species == Species::Shulker || (s.species == Species::HappyGhast && !s.baby))
+            && s.bounds.intersects(grown)
+    })
 }
 /// `Shulker.canStayAt`: an empty spot against a sturdy face, with room
 /// for the fully opened shell (`canStayAt`).

From 83ee5c303b7b4a3e81434db619dbb46772fcec81 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:46:49 +0100
Subject: [PATCH 451/475] parity: game-window harnesses run alone on 4-CPU
 machines

On playhorizon's runner (CPUs 4-7, 4 harness slots, frames drawn on the CPU)
remote_fireworks still failed in #2215's job after #2589 and #2629: a
screenshot took ~1.5 s (58 ticks for two) beside three other harnesses. The
harnesses in parity_hosts.json's new solo list run alone there, after the
others; bigger machines are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/parity-workflow.md     |  2 ++
 tests/test_parity_runner.py | 32 ++++++++++++++++++++++++++++++++
 tools/parity.py             | 26 +++++++++++++++++++++++++-
 tools/parity_hosts.json     |  6 ++++++
 4 files changed, 65 insertions(+), 1 deletion(-)

diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md
index 73ac5c47c..5c83c6a33 100644
--- a/docs/parity-workflow.md
+++ b/docs/parity-workflow.md
@@ -44,6 +44,8 @@ Harnesses can also run on the Mac mini, the desktop and playhorizon (`tools/pari
 
 Harnesses a host can't run are listed in the file: `local_only` (`save_roundtrip` runs the game on a virtual screen) and each host's `exclude`. The Mac excludes nothing: vanilla's `Math.sin`, `pow`, `log` and the like don't round the same on an Apple silicon Mac as on Linux (HotSpot uses fdlibm there, Intel's stubs on x86-64), and Rust's float functions round like neither (they call the platform libm), so code that mirrors a vanilla `Math` call uses `horizon_core::jmath`, which computes what HotSpot computes on the host architecture. The ThinkPad no longer runs harnesses (2026-10-26): playhorizon is the Linux host that is always on.
 
+The file's `solo` list names harnesses that drive game windows (`remote_fireworks`, `server_player_sculk`, `world_reopen`, ...). On a machine where `parity.py` has 4 CPUs or fewer, such as playhorizon's CI runner, each of them runs alone, after the others: there frames are drawn on the CPU, and beside other harnesses a screenshot or a control request took more ticks than the check allows. `PARITY_SOLO=1` or `0` forces this on or off.
+
 ### Any command on playhorizon: `tools/remote.sh`
 
 For Linux work that doesn't need a whole parity run (a crate's tests, a few harnesses, a server build), `tools/remote.sh <worktree> <command...>` runs the command on playhorizon at the worktree's commit and streams its output back; its exit status is the command's. Commit and push first: the host fetches the commit from GitHub, and nothing else leaves this machine (no files, no credentials, no environment). Each worktree keeps one checkout there, `~/remote-work/<name>` with its own `target/`, so the next run only rebuilds what changed, and one run per name goes at a time. The command runs niced in the host's CI slice, pinned to CPUs 0-3 (`--cpus`): the CI runner has 4-7, so these runs never slow a pull request's parity job. A benchmark asks for its CPUs with `--cpus 0-3 --exclusive` (and says so in its pull request): it starts only when no other run uses them, and later runs wait for it to end. The command gets scratch game and launcher homes and the vanilla data linked as CI links it; a command naming `parity`, `lan_e2e` or `horizon-prepare` also gets `.local/horizon-client`, prepared as CI prepares it. Whatever the command leaves running (a game, a daemon) is stopped when it ends, and stopping `remote.sh` (or losing the connection) stops the command on the host. Logs stay in `~/remote-work/<name>.logs/`; `--list` shows the checkouts, `--gc [DAYS]` removes old ones.
diff --git a/tests/test_parity_runner.py b/tests/test_parity_runner.py
index 39d3cc783..fdc636a24 100644
--- a/tests/test_parity_runner.py
+++ b/tests/test_parity_runner.py
@@ -399,6 +399,38 @@ class KnownFlakyTests(unittest.TestCase):
         self.assertTrue(set(flaky) <= {parity.base_name(name) for name in parity.harnesses()})
 
 
+
+class SoloTests(unittest.TestCase):
+    """Harnesses driving game windows run alone on a small machine (playhorizon's 4-CPU runner)."""
+
+    def executor(self, running):
+        with tempfile.TemporaryDirectory() as tmp, mock.patch.object(parity, "STATE_DIR", Path(tmp)):
+            local = parity.LocalExecutor(4, 1 << 40, 60)
+        local.solo = {"remote_fireworks"}
+        local.running = {label: {} for label in running}
+        return local
+
+    def test_a_solo_harness_waits_for_an_empty_machine_and_then_holds_it(self):
+        busy = self.executor(["food"])
+        self.assertFalse(busy.accepts("remote_fireworks"))
+        self.assertTrue(busy.accepts("light"))
+        self.assertEqual(busy.free(), 3)
+        self.assertTrue(self.executor([]).accepts("remote_fireworks"))
+        alone = self.executor(["remote_fireworks~2"])
+        self.assertEqual(alone.free(), 0)
+
+    def test_only_small_machines_and_listed_harnesses(self):
+        config = {"solo": {"remote_fireworks": "two game windows"}}
+        with mock.patch.dict(os.environ, {"PARITY_SOLO": "1"}):
+            self.assertEqual(parity.solo_harnesses(config), {"remote_fireworks"})
+        with mock.patch.dict(os.environ, {"PARITY_SOLO": "0"}):
+            self.assertEqual(parity.solo_harnesses(config), set())
+        with mock.patch.dict(os.environ, {"PARITY_SOLO": ""}), mock.patch.object(parity, "SOLO_CPUS", 10 ** 6):
+            self.assertEqual(parity.solo_harnesses(config), {"remote_fireworks"})
+        solo = parity.host_config().get("solo", {})
+        self.assertTrue(solo and set(solo) <= {parity.base_name(name) for name in parity.harnesses()})
+
+
 if __name__ == "__main__":
     unittest.main()
 
diff --git a/tools/parity.py b/tools/parity.py
index cd8d1e2f6..38d113cab 100644
--- a/tools/parity.py
+++ b/tools/parity.py
@@ -800,16 +800,21 @@ class LocalExecutor:
         self.name, self.jobs, self.memory_budget, self.timeout = HOST, jobs, memory_budget, timeout
         self.max_peak = max_peak  # set while other machines can take heavier harnesses
         self.running = {}
+        self.solo = set()  # harnesses that run alone here (solo_harnesses)
         self.dead = False  # this machine never drops out, unlike a remote host
         self.available, self.measured = 0, 0.0
         (STATE_DIR / "logs").mkdir(parents=True, exist_ok=True)
         (STATE_DIR / "traces").mkdir(parents=True, exist_ok=True)
 
     def free(self):
+        if any(harness_of(label) in self.solo for label in self.running):
+            return 0
         return self.jobs - len(self.running)
 
     def accepts(self, name):
-        return True
+        # A solo harness waits until nothing else runs here; the others fill the slots meanwhile, so solo ones
+        # run last, alone.
+        return name not in self.solo or not self.running
 
     def fits(self, expected, only_here=True):
         """Admission by recorded peak, within the budget and leaving MEMORY_RESERVE of what is free now.
@@ -1462,6 +1467,21 @@ def known_flaky(config):
     return dict(config.get("known_flaky", {}))
 
 
+def solo_harnesses(config):
+    """Harnesses tools/parity_hosts.json's "solo" lists ({name: reason}: those driving game windows, whose frames
+    are drawn on the CPU on Linux runners) run alone on a machine with SOLO_CPUS CPUs or fewer for this process
+    (playhorizon's runner has 4): beside other harnesses there they lose ticks between control requests. The set,
+    or an empty one on a bigger machine. PARITY_SOLO=1 or 0 forces it on or off."""
+    forced = os.environ.get("PARITY_SOLO")
+    cpus = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count() or 1
+    if forced == "0" or forced != "1" and cpus > SOLO_CPUS:
+        return set()
+    return set(config.get("solo", {}))
+
+
+SOLO_CPUS = 4
+
+
 def named_only(config):
     """Harnesses tools/parity_hosts.json keeps out of every automatic selection (--changed, --failed, the default,
     --flake-check): they run only when named or with --all, the nightly audit. {name: reason}"""
@@ -1640,6 +1660,10 @@ def main():
         reuse_oracles = not (args.fresh or args.all)
         local = LocalExecutor(jobs, int(memory_available() * 0.75), args.timeout,
                               REMOTE_LOCAL_PEAK if remotes and args.jobs is None else None)
+        local.solo = solo_harnesses(config)
+        if local.solo & {harness_of(name) for name in selected}:
+            print(f"Alone on this machine ({SOLO_CPUS} CPUs or fewer), after the others: "
+                  f"{', '.join(sorted(local.solo & {harness_of(name) for name in selected}))}", flush=True)
         results, elapsed = run(selected, state, hasher, environment_key(hasher), [*remotes, local], reuse_oracles,
                                rounds, known_flaky(config))
     finally:
diff --git a/tools/parity_hosts.json b/tools/parity_hosts.json
index 29815a9f6..cec022194 100644
--- a/tools/parity_hosts.json
+++ b/tools/parity_hosts.json
@@ -40,6 +40,12 @@
   "save_roundtrip": "runs the game on a virtual screen (vscreen) with a null ALSA device, or offscreen in the logged-in macOS session"
  },
  "linux_only": {},
+ "solo": {
+  "remote_fireball": "two game windows (lan_e2e); on 4 CPUs beside other harnesses, screenshots and control requests take ticks the check needs",
+  "remote_fireworks": "two game windows (lan_e2e); a screenshot took ~1.5 s beside 3 other harnesses on playhorizon's runner, past the sparks' life (2026-10-27)",
+  "server_player_sculk": "two game windows (lan_e2e); failed on playhorizon's runner beside other harnesses, passes alone (2026-10-27)",
+  "world_reopen": "a game window reopening a world: failed on playhorizon's runner beside other harnesses (2026-10-27)"
+ },
  "named_only": {
   "lan_integration": "the whole lan_e2e suite: ~40 min a run on a loaded runner, and single checks flake under load; run it by name, or tools/lan_e2e.py"
  },

From b463f1c80a75471f1e5171f989dd3036d90d654e Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:50:22 +0100
Subject: [PATCH 452/475] Waxed hanging signs play their own failed-interaction
 sound

HangingSignBlockEntity.getSignInteractionFailedSoundEvent is
block.hanging_sign.waxed_interact_fail, not the standing sign's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/sign_edit.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/crates/horizon-client/src/game/sign_edit.rs b/crates/horizon-client/src/game/sign_edit.rs
index bdd2008f4..3d946ce7b 100644
--- a/crates/horizon-client/src/game/sign_edit.rs
+++ b/crates/horizon-client/src/game/sign_edit.rs
@@ -87,12 +87,14 @@ impl Game<'_> {
             return;
         };
         if sign.waxed {
-            self.audio.play(
-                "minecraft:block.sign.waxed_interact_fail",
-                Some(pos.map(|v| f64::from(v) + 0.5)),
-                1.0,
-                1.0,
-            );
+            // `getSignInteractionFailedSoundEvent`: a hanging sign has its own.
+            let sound = if sign.hanging {
+                "minecraft:block.hanging_sign.waxed_interact_fail"
+            } else {
+                "minecraft:block.sign.waxed_interact_fail"
+            };
+            self.audio
+                .play(sound, Some(pos.map(|v| f64::from(v) + 0.5)), 1.0, 1.0);
         } else if self.may_build() {
             let front = self.facing_sign_front(key);
             self.open_sign_editor(key, front);

From 4d897de20bcd4353ca85bc214de2f7319e5d5720 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:50:26 +0100
Subject: [PATCH 453/475] Play the rain extinguish sound for every player

Entity.applyEffectsFromBlocks plays playEntityOnFireExtinguishedSound for any
player whose fire the rain puts out: a LAN guest or the server thread's player
(the default single player) heard nothing before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/powder_snow.rs | 30 +++++++------------
 1 file changed, 11 insertions(+), 19 deletions(-)

diff --git a/crates/horizon-client/src/game/powder_snow.rs b/crates/horizon-client/src/game/powder_snow.rs
index 5b3692df3..7d935d07b 100644
--- a/crates/horizon-client/src/game/powder_snow.rs
+++ b/crates/horizon-client/src/game/powder_snow.rs
@@ -67,35 +67,27 @@ impl Game<'_> {
             pitch,
         );
     }
-    /// `Entity.baseTick`: a burning player in the rain (`isInRain`) has the
-    /// fire put out (`clearFire`). Returns whether it did.
-    pub(super) fn rain_extinguish_player(&mut self) -> bool {
+    /// `Entity.applyEffectsFromBlocks`: a burning player in the rain
+    /// (`isInRain`) has the fire put out (`clearFire`), with the extinguish
+    /// sound that everyone near hears.
+    pub(super) fn rain_extinguish_player(&mut self) {
         let Some(player) = self.player.as_ref() else {
-            return false;
+            return;
         };
         let (at, top) = (player.position, player.bounds().max_position().y);
         if player.fire_ticks <= 0 || !self.in_rain(at, top) {
-            return false;
+            return;
         }
         if let Some(player) = self.player.as_mut() {
             player.fire_ticks = 0;
         }
-        true
+        self.extinguish_sound([at.x, at.y, at.z]);
     }
-    /// The in-window player's rain extinguish, with its sound (a server's
-    /// fire is the server's).
+    /// The in-window player's rain extinguish (a server's player has its
+    /// fire put out by the server).
     pub(super) fn rain_extinguish_in_frame(&mut self) {
-        if self.remote.is_some() {
-            return;
-        }
-        let at = self
-            .player
-            .as_ref()
-            .map(|p| [p.position.x, p.position.y, p.position.z]);
-        if self.rain_extinguish_player()
-            && let Some(at) = at
-        {
-            self.extinguish_sound(at);
+        if self.remote.is_none() {
+            self.rain_extinguish_player();
         }
     }
     /// Whether the block at `pos` is powder snow.

From 78dba05d8f7e7daa62e4355c3d8ff1dbc5c67b49 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:54:16 +0100
Subject: [PATCH 454/475] Merge #2516 into fix/desert-leaves-ambient

Both change Animate::Falling: suspicious sand and gravel take the new flag
false (BrushableBlock.animateTick drops dust only; the desert sound is
SandBlock's).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/animate_tick.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/animate_tick.rs b/crates/horizon-client/src/animate_tick.rs
index a0803a6e9..2ca30a0a1 100644
--- a/crates/horizon-client/src/animate_tick.rs
+++ b/crates/horizon-client/src/animate_tick.rs
@@ -174,8 +174,8 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
         "end_portal" => Animate::EndPortal,
         "wet_sponge" => Animate::WetSponge,
         // BrushableBlock has no dust colour of its own, so the dust is the map colour.
-        "suspicious_sand" => Animate::Falling(0xF7E9A3),
-        "suspicious_gravel" => Animate::Falling(0x707070),
+        "suspicious_sand" => Animate::Falling(0xF7E9A3, false),
+        "suspicious_gravel" => Animate::Falling(0x707070, false),
         "sculk_sensor" | "calibrated_sculk_sensor"
             if prop("sculk_sensor_phase").as_deref() == Some("active") =>
         {

From 6a65ee1124f05011034be6499d137e49fb319616 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:56:46 +0100
Subject: [PATCH 455/475] A guest saved by a totem is not a player kill

The guest's health goes through the same totem path as the host's
(applied on the next tick_totem), so the kill check skips a fired totem
for both.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/lan_pvp.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs
index a51f3a6c0..3a2fa21c1 100644
--- a/crates/horizon-client/src/game/lan_pvp.rs
+++ b/crates/horizon-client/src/game/lan_pvp.rs
@@ -264,7 +264,7 @@ impl Game<'_> {
         if hurt {
             let died = match victim {
                 // A totem that fired is applied on the next tick_totem, so the
-                // host is still at zero health but is not dying.
+                // victim is still at zero health but is not dying.
                 Victim::Host => self
                     .player
                     .as_ref()
@@ -273,7 +273,7 @@ impl Game<'_> {
                     .hub
                     .guest(conn)
                     .and_then(|g| g.motion.as_deref())
-                    .is_some_and(|p| p.health.dead_or_dying()),
+                    .is_some_and(|p| p.health.dead_or_dying() && !p.health.totem_used),
             };
             if died {
                 match s.attacker {

From d53114fa82f8af75b60fca4c9cf5a996ba0e97fc Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:58:31 +0100
Subject: [PATCH 456/475] Size a drowned's thrown trident in F3+B

Main's ProjectileKind::Trident (a mob's trident) is the trident's 0.5 box with
its 0.13 eye height, as the player's tridents below.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/debug_keys.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs
index 1428ae9b2..dc79bf8c1 100644
--- a/crates/horizon-client/src/game/debug_keys.rs
+++ b/crates/horizon-client/src/game/debug_keys.rs
@@ -889,7 +889,7 @@ impl Game<'_> {
         for p in &self.creatures.projectiles {
             use horizon_client::projectiles::ProjectileKind as K;
             let (size, eye) = match p.kind {
-                K::Arrow { .. } => (0.5, 0.13),
+                K::Arrow { .. } | K::Trident => (0.5, 0.13),
                 K::Snowball | K::Egg | K::EnderPearl | K::LlamaSpit | K::Potion { .. } => {
                     (0.25, 0.2125)
                 }

From 36f6ab9839726abd262b53175130ac11d5c3fdee Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 06:59:59 +0100
Subject: [PATCH 457/475] Infested, Weaving and Wind Charged draw from the
 bearer's random

InfestedMobEffect.onMobHurt, WeavingMobEffect.spawnCobwebsRandomlyAround
and WindChargedMobEffect.onMobRemoved all use mob.getRandom(): a mob's
own random, the world's for the player as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/creatures.rs |  7 +--
 crates/horizon-client/src/game/potions.rs   | 51 ++++++++++++++-------
 2 files changed, 38 insertions(+), 20 deletions(-)

diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 2db9622e0..4bae67c72 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -691,14 +691,15 @@ impl Game<'_> {
         for m in dead {
             self.mob_died(&m);
         }
-        for m in corpses {
+        for mut m in corpses {
             let names: Vec<&'static str> = m
                 .extra
                 .effects
                 .iter()
                 .map(|e| e.0.trim_start_matches("minecraft:"))
                 .collect();
-            self.effects_on_death(&names, m.bounds(), false, Some(m.id));
+            let bounds = m.bounds();
+            self.effects_on_death(&names, bounds, false, Some(m.id), Some(&mut m.random));
         }
         self.handle_mob_events(events)?;
         self.lan_guest_mob_events(guest_events);
@@ -911,7 +912,7 @@ impl Game<'_> {
                 m.position.z,
             ];
             let look = m.view_vector();
-            self.infested_hurt(at, look);
+            self.infested_hurt(at, look, Some(mob));
         }
     }
     /// `LivingEntity.dropFromGiftLootTable`: the gift table from its random
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index 94ad1585c..39e82de29 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -16,7 +16,7 @@ use horizon_client::{
 };
 use horizon_core::{
     geometry::{Aabb, Direction, Vec3},
-    random::RandomSource,
+    random::{LegacyRandom, RandomSource},
 };
 
 /// A thrown splash or lingering potion in flight.
@@ -54,13 +54,16 @@ fn mob_effect_id(id: &str) -> Option<&'static str> {
 impl Game<'_> {
     /// `LivingEntity.triggerOnDeathMobEffects` (`onMobRemoved` with the reason
     /// KILLED) for what Oozing, Weaving and Wind Charged do when their bearer
-    /// dies. `bearer` is the dying mob's id, `player` whether it is a player.
+    /// dies. `bearer` is the dying mob's id, `player` whether it is a player,
+    /// `random` the dying mob's own (`mob.getRandom()`; the world's for the
+    /// player).
     pub(super) fn effects_on_death(
         &mut self,
         effects: &[&str],
         bounds: Aabb,
         player: bool,
         bearer: Option<u32>,
+        mut random: Option<&mut LegacyRandom>,
     ) {
         let feet = bounds.bottom_center();
         if effects.contains(&"oozing") {
@@ -96,27 +99,32 @@ impl Game<'_> {
             }
         }
         if effects.contains(&"weaving") && (player || self.ui.rules.bool("mob_griefing")) {
-            self.spawn_cobwebs_around([
-                feet.x.floor() as i32,
-                feet.y.floor() as i32,
-                feet.z.floor() as i32,
-            ]);
+            self.spawn_cobwebs_around(
+                [
+                    feet.x.floor() as i32,
+                    feet.y.floor() as i32,
+                    feet.z.floor() as i32,
+                ],
+                random.as_deref_mut(),
+            );
         }
         if effects.contains(&"wind_charged") {
             // A burst centred at half the height, radius 3 to 5.
             let center = [feet.x, feet.y + bounds.size().y / 2.0, feet.z];
-            let radius = 3.0 + self.world.random.next_float() * 2.0;
+            let r = random.unwrap_or(&mut self.world.random);
+            let radius = 3.0 + r.next_float() * 2.0;
             let _ = self.wind_burst(center, radius, 1.0, false, false);
         }
     }
     /// `WeavingMobEffect.spawnCobwebsRandomlyAround`: two or three cobwebs in
     /// free spaces with a solid floor, picked among 15 random blocks within one
     /// block of `pos`.
-    fn spawn_cobwebs_around(&mut self, pos: [i32; 3]) {
-        let wanted = 2 + self.world.random.next_int_bound(2).unwrap_or(0) as usize;
+    fn spawn_cobwebs_around(&mut self, pos: [i32; 3], mut random: Option<&mut LegacyRandom>) {
+        let r = random.as_deref_mut().unwrap_or(&mut self.world.random);
+        let wanted = 2 + r.next_int_bound(2).unwrap_or(0) as usize;
         let mut chosen: Vec<[i32; 3]> = Vec::new();
         for _ in 0..15 {
-            let r = &mut self.world.random;
+            let r = random.as_deref_mut().unwrap_or(&mut self.world.random);
             let at = [
                 pos[0] - 1 + r.next_int_bound(3).unwrap_or(0),
                 pos[1] - 1 + r.next_int_bound(3).unwrap_or(0),
@@ -151,21 +159,30 @@ impl Game<'_> {
                 p.position.z,
             ];
             let look = super::view_vector(self.yaw, self.pitch);
-            self.infested_hurt(at, look);
+            self.infested_hurt(at, look, None);
+        }
+    }
+    /// A living mob's own random (`Entity.random`), else the world's.
+    fn bearer_random(&mut self, bearer: Option<u32>) -> &mut LegacyRandom {
+        match bearer.and_then(|id| self.mobs.iter().position(|m| m.id == id)) {
+            Some(i) => &mut self.mobs[i].random,
+            None => &mut self.world.random,
         }
     }
     /// `InfestedMobEffect.onMobHurt`: a 10% chance of one or two silverfish at
     /// `at` (half the bearer's height up), thrown along its look direction.
-    pub(super) fn infested_hurt(&mut self, at: [f64; 3], look: [f64; 3]) {
-        if self.world.random.next_float() > 0.1 {
+    /// The draws are the bearer's (`mob.getRandom()`): `bearer` is the mob,
+    /// none for the player (the world's random).
+    pub(super) fn infested_hurt(&mut self, at: [f64; 3], look: [f64; 3], bearer: Option<u32>) {
+        if self.bearer_random(bearer).next_float() > 0.1 {
             return;
         }
-        let count = 1 + self.world.random.next_int_bound(2).unwrap_or(0);
+        let count = 1 + self.bearer_random(bearer).next_int_bound(2).unwrap_or(0);
         for _ in 0..count {
             // Mth.randomBetween(-PI / 2, PI / 2), then the look direction
             // scaled by (0.3, 0.45, 0.3) and turned about the y axis.
             let half = std::f32::consts::FRAC_PI_2;
-            let angle = self.world.random.next_float() * (2.0 * half) - half;
+            let angle = self.bearer_random(bearer).next_float() * (2.0 * half) - half;
             let (sin, cos) = angle.sin_cos();
             let (x, z) = (look[0] * 0.3, look[2] * 0.3);
             let velocity = Vec3::new(
@@ -552,7 +569,7 @@ impl Game<'_> {
             let ids: Vec<&'static str> = self.potions.effects.list.iter().map(|e| e.id).collect();
             self.potions.effects.clear();
             if !ids.is_empty() {
-                self.effects_on_death(&ids, bounds, true, None);
+                self.effects_on_death(&ids, bounds, true, None, None);
             }
         }
         // The omens act from inside the effect tick (BadOmenMobEffect,

From e3f6f9d4dce851c501c20d40a0212c5afebc19a7 Mon Sep 17 00:00:00 2001
From: levzzz <86072227+levzzz5154@users.noreply.github.com>
Date: Tue, 27 Oct 2026 11:01:50 +0500
Subject: [PATCH 458/475] Test the vex's small held item

`VexModel.translateToHand` draws the held item at 0.55 scale, so the
vex's sword is the tiny one vanilla shows. The test checks the scale of
the item's transform; it fails without the cull-scale (it was 1).

Co-Authored-By: minimax-m3.1-flash (Claude Code) <noreply@users.noreply.github.com>
---
 crates/horizon-client/src/mobs/render.rs | 36 ++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs
index 8b316d8ba..3e26d0689 100644
--- a/crates/horizon-client/src/mobs/render.rs
+++ b/crates/horizon-client/src/mobs/render.rs
@@ -1430,4 +1430,40 @@ mod tests {
             assert!(vertices.iter().all(|v| v.uv[0] >= 0.5));
         }
     }
+    /// `VexModel.translateToHand`: the held item is drawn at 0.55 scale and
+    /// moved by the vex's own offset, so the vex's sword is the tiny one
+    /// vanilla shows. It was drawn at the full size, like a zombie's.
+    #[test]
+    fn the_vex_holds_its_item_at_the_small_scale() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client/26.3");
+        if !root.join("entity-models.json").exists() {
+            return;
+        }
+        let types = super::super::MobTypes::load(&root).unwrap();
+        let kind = std::sync::Arc::new(types.types["minecraft:vex"].clone());
+        let mob = Mob::new(1, kind, horizon_core::geometry::Vec3::ZERO, 0.0);
+        let data = MobData {
+            states: Vec::new(),
+            placements: Default::default(),
+            heightmaps: Default::default(),
+            animations: Default::default(),
+            biome_tags: Default::default(),
+            entity_tags: Default::default(),
+            villager_hats: Default::default(),
+            pois: Default::default(),
+        };
+        for left in [false, true] {
+            let t = held_item_transform(&mob, 0.5, glam::DVec3::ZERO, &data, left).unwrap();
+            // The model's own part scale is 1, so the item's scale is the
+            // renderer's: `poseStack.scale(0.55F, 0.55F, 0.55F)`.
+            for axis in [t.x_axis, t.y_axis, t.z_axis] {
+                let scale = axis.truncate().length();
+                assert!(
+                    (scale - 0.55).abs() < 1.0e-5,
+                    "the vex's item is drawn at 0.55 scale, got {scale}"
+                );
+            }
+        }
+    }
 }

From 937dcba5b8d7cc71b3ebd37672b7499fc15c093d Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 07:02:05 +0100
Subject: [PATCH 459/475] A TNT minecart's fuse blast uses its horizontal speed
 only

MinecartTNT.tick calls explode(getDeltaMovement().horizontalDistanceSqr())
when the fuse runs out; the vertical-speed branch has no vanilla source.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/minecarts.rs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index ceff3f127..6e27b6cbd 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -587,12 +587,9 @@ impl Game<'_> {
                     self.particles
                         .add(&ParticleOptions::simple(ParticleType::Smoke), at, [0.0; 3]);
                 } else if c.fuse == 0 {
+                    // explode(horizontalDistanceSqr()): a rising cart's
+                    // vertical speed adds nothing.
                     let speed = c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z;
-                    let speed = if c.velocity.y > 0.0 {
-                        c.velocity.y * c.velocity.y
-                    } else {
-                        speed
-                    };
                     self.explode_cart(c, speed);
                     return false;
                 }

From d77569c6720a9ea593460b7fc0398f1328e009c6 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 07:02:35 +0100
Subject: [PATCH 460/475] The dragon's ambient pitch draws from its own random

LivingEntity.getVoicePitch uses this.random, the same random the
ambient roll draws from.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/dragon.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index 96c8ef478..d8a7f84d3 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -1670,8 +1670,8 @@ impl Game<'_> {
         if roll < waited {
             d.ambient_time = -AMBIENT_INTERVAL;
             let at = [d.position.x, d.position.y, d.position.z];
-            // LivingEntity.getVoicePitch.
-            let r = &mut self.world.random;
+            // LivingEntity.getVoicePitch, from the dragon's own random.
+            let r = &mut d.random;
             let pitch = (r.next_float() - r.next_float()) * 0.2 + 1.0;
             self.audio.play(
                 "minecraft:entity.ender_dragon.ambient",

From e42a82e9b99335f58aae3011f153db96ee908f3e Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 07:03:08 +0100
Subject: [PATCH 461/475] Name the difficulty id field as #2239 does

#2239 adds the same LocalDifficulty field as `id`; with the same lines
here the two branches merge without a conflict.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/mobs/bee.rs      | 2 +-
 crates/horizon-client/src/mobs/spawning.rs | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/horizon-client/src/mobs/bee.rs b/crates/horizon-client/src/mobs/bee.rs
index 741a78df6..92c11544c 100644
--- a/crates/horizon-client/src/mobs/bee.rs
+++ b/crates/horizon-client/src/mobs/bee.rs
@@ -324,7 +324,7 @@ pub fn sting(m: &mut Mob, who: Who, cx: &mut Cx) {
         Who::Player => {
             cx.events.push(MobEvent::AttackPlayer(amount, from));
             // Poison only on normal (10 s) and hard (18 s).
-            let seconds = match cx.w.difficulty.base {
+            let seconds = match cx.w.difficulty.id {
                 2 => 10,
                 3 => 18,
                 _ => 0,
diff --git a/crates/horizon-client/src/mobs/spawning.rs b/crates/horizon-client/src/mobs/spawning.rs
index 57ecb1692..bbb8e2e46 100644
--- a/crates/horizon-client/src/mobs/spawning.rs
+++ b/crates/horizon-client/src/mobs/spawning.rs
@@ -37,8 +37,8 @@ pub struct LocalDifficulty {
     pub effective: f32,
     /// The world difficulty is hard.
     pub hard: bool,
-    /// The world difficulty id, 0 peaceful to 3 hard.
-    pub base: u8,
+    /// `Difficulty.getId`: 0 peaceful to 3 hard.
+    pub id: u8,
 }
 /// `DimensionType.MOON_BRIGHTNESS_PER_PHASE`.
 pub const MOON_BRIGHTNESS: [f32; 8] = [1.0, 0.75, 0.5, 0.25, 0.0, 0.25, 0.5, 0.75];
@@ -51,7 +51,7 @@ impl LocalDifficulty {
             return Self {
                 effective: 0.0,
                 hard,
-                base,
+                id: base,
             };
         }
         let global = ((total as f32 - 72000.0) / 1_440_000.0).clamp(0.0, 1.0) * 0.25;
@@ -64,7 +64,7 @@ impl LocalDifficulty {
         Self {
             effective: f32::from(base) * (0.75 + global + local),
             hard,
-            base,
+            id: base,
         }
     }
     /// `getSpecialMultiplier`.

From 80751276f33f23023956e959d70b31936f6e3e10 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 08:37:40 +0100
Subject: [PATCH 462/475] test: run the full content-root tests only where they
 matter

The five mod_content tests that load the whole content root took minutes of
every `cargo test -p horizon-client --lib` on prepared data. They are now
#[ignore]d; pr_ready runs them when the diff touches what they load, and CI's
verify job runs them filtered with --ignored on its existing build.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/ci.yml                       |  3 +++
 AGENTS.md                                      |  1 +
 crates/horizon-client/src/mod_content_tests.rs |  5 +++++
 tests/test_pr_ready.py                         | 13 +++++++++++++
 tools/pr_ready.py                              | 11 +++++++++++
 5 files changed, 33 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b2fd9fa48..227d810d6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -72,6 +72,9 @@ jobs:
         if: steps.rust.outputs.required != 'false'
         run: |
           cargo +stable test --workspace --lib --bins --tests --features horizon-client/mods,horizon-mods/pack
+          # The full content-root tests (#[ignore]d: minutes each on a laptop). The same build as above; they need the
+          # prepared vanilla data, so without it they pass at once.
+          cargo +stable test --workspace --lib --features horizon-client/mods,horizon-mods/pack mod_content::tests:: -- --ignored
           cargo +stable test --workspace --doc --features horizon-client/mods,horizon-mods/pack
   # The launcher is its own workspace (launcher/Cargo.toml), so verify's cargo runs never build it. A pull request that
   # changes it or a crate it builds is checked here, and so is every push to main: two pull requests can each pass
diff --git a/AGENTS.md b/AGENTS.md
index 0eb1fe8b5..3804ebae8 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -66,6 +66,7 @@ reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` an
 python3 tools/pr_ready.py                  # the self-check: fmt, clippy -D warnings, touched crates' tests, harnesses; paste its block in the PR
 python3 tools/pr_ready.py --quick          # same without harnesses
 cargo test -p horizon-client --lib --bins --tests   # skips the 104 examples (pr_ready does this); `--doc` separately
+cargo test -p horizon-client --features horizon-client/mods --lib mod_content::tests:: -- --ignored   # the 5 slow content-root tests, #[ignore]d; pr_ready runs them when mod content, assets, blocks or items change
 cargo build --profile fast -p horizon-client        # optimized, quick to link: use it to play or run lan_e2e
 python3 tools/parity.py --changed origin/main       # the harnesses your branch can affect (CI's parity job)
 python3 tools/parity.py --changed-files paths.txt --list   # which harnesses cover these files, without running them
diff --git a/crates/horizon-client/src/mod_content_tests.rs b/crates/horizon-client/src/mod_content_tests.rs
index 3d38fae4d..aeeab3016 100644
--- a/crates/horizon-client/src/mod_content_tests.rs
+++ b/crates/horizon-client/src/mod_content_tests.rs
@@ -114,6 +114,7 @@ fn ruby_mod(dir: &Path) -> ContentMod {
 /// new blocks behave like their templates with the overrides, and vanilla's
 /// states are where they were.
 #[test]
+#[ignore = "full content root: CI and pr_ready run it"]
 fn content_root_loads_with_every_table() {
     let Some(base) = prepared() else {
         return;
@@ -352,6 +353,7 @@ fn no_content_keeps_the_base_root() {
 use horizon_world::registry::BlockStateId;
 
 #[test]
+#[ignore = "full content root: CI and pr_ready run it"]
 fn shared_behaviour_document_matches_independent_loaders() {
     let Some(root) = prepared() else { return };
     let assets = Assets::load(&root).expect("assets");
@@ -414,6 +416,7 @@ fn shared_behaviour_document_matches_independent_loaders() {
 
 #[cfg(unix)]
 #[test]
+#[ignore = "full content root: CI and pr_ready run it"]
 fn independent_reloads_read_changed_behaviour_json_and_report_invalid_files() {
     let Some(base) = prepared() else { return };
     let scratch = std::env::temp_dir().join(format!("horizon-json-reloads-{}", std::process::id()));
@@ -535,6 +538,7 @@ fn independent_reloads_read_changed_behaviour_json_and_report_invalid_files() {
 /// A built root is kept for later starts, and built again when a mod's
 /// files change.
 #[test]
+#[ignore = "full content root: CI and pr_ready run it"]
 fn content_root_is_reused_until_a_mod_changes() {
     let Some(base) = prepared() else {
         return;
@@ -571,6 +575,7 @@ fn content_root_is_reused_until_a_mod_changes() {
 /// set, pool and templates join the bundles, and its biome tag keeps only
 /// what the loader knows.
 #[test]
+#[ignore = "full content root: CI and pr_ready run it"]
 fn content_root_carries_a_structure_mod() {
     let Some(base) = prepared() else {
         return;
diff --git a/tests/test_pr_ready.py b/tests/test_pr_ready.py
index 87373cb31..ab17340d3 100644
--- a/tests/test_pr_ready.py
+++ b/tests/test_pr_ready.py
@@ -56,6 +56,19 @@ class PrReadyTests(unittest.TestCase):
         self.assertEqual(by_name["doc tests"].command, "cargo test --locked -p horizon-client --doc")
         self.assertIsNone(by_name["doc tests"].status)
 
+    def test_content_root_tests_run_only_when_what_they_load_changes(self):
+        def content_step(path):
+            with mock.patch.object(pr_ready, "affected_here", return_value=[]):
+                steps = pr_ready.plan(args(quick=True), "origin/main", {path}, PACKAGES, LIBRARIES, DEPENDENCIES)
+            return {step.name: step for step in steps}["content root tests"]
+        self.assertEqual(content_step("crates/horizon-client/src/game.rs").skip, "content root untouched")
+        for path in ["crates/horizon-client/src/mod_content.rs", "crates/horizon-client/src/mod_content_tests.rs",
+                     "crates/horizon-mods/src/content.rs", "crates/horizon-assets/src/lib.rs", "Cargo.lock"]:
+            with self.subTest(path=path):
+                step = content_step(path)
+                self.assertIsNone(step.skip)
+                self.assertEqual(step.command, pr_ready.CONTENT_ROOT_TESTS)
+
     def test_shared_rust_configuration_keeps_workspace_coverage(self):
         for path in sorted(pr_ready.ROOT_RUST | {".cargo/config.toml", "crates/unknown/src/lib.rs"}):
             with self.subTest(path=path), mock.patch.object(pr_ready, "affected_here", return_value=[]):
diff --git a/tools/pr_ready.py b/tools/pr_ready.py
index 89a529192..b741e475e 100755
--- a/tools/pr_ready.py
+++ b/tools/pr_ready.py
@@ -290,6 +290,14 @@ def mod_features(crates):
     return f" --features {','.join(features)}" if features else ""
 
 
+# What horizon-client's full content-root tests load (mod_content_tests.rs). They take minutes on prepared data, so
+# they are #[ignore]d and run here only when one of these changes.
+CONTENT_ROOT = ("crates/horizon-client/src/mod_content", "crates/horizon-client/src/assets.rs",
+                "crates/horizon-client/src/blocks.rs", "crates/horizon-client/src/items.rs", "crates/horizon-items/",
+                "crates/horizon-mods/", "crates/horizon-assets/")
+CONTENT_ROOT_TESTS = "cargo test --locked -p horizon-client --features horizon-client/mods --lib mod_content::tests:: -- --ignored"
+
+
 def plan(args, base, changed, crates_of, libraries, dependencies):
     """The checks for these changed files, in the order they run."""
     rust = any(workspace_rust(path) for path in changed)
@@ -323,6 +331,9 @@ def plan(args, base, changed, crates_of, libraries, dependencies):
              skip=test_skip, summary=tests_passed),
         Step("doc tests", f"cargo test --locked {doc_selection} --doc",
              skip=test_skip or (None if doc_crates else "no library touched"), summary=tests_passed),
+        Step("content root tests", CONTENT_ROOT_TESTS, summary=tests_passed,
+             skip=None if crates is None or any(p.startswith(CONTENT_ROOT) for p in changed)
+             else "content root untouched"),
         Step("tokens.css up to date", "cargo test --locked -p horizon-theme --lib tokens_css_is_up_to_date",
              skip=None if any(p.startswith(("crates/horizon-theme/", "xtask/")) for p in changed)
              else "theme untouched"),

From 523280e781e35f4d86f68852a3f125baf8f30c8f Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 09:07:42 +0100
Subject: [PATCH 463/475] Draw the new level-event sound pitches from the
 client level's random

LevelEventHandler plays 1501, 1502, 1046 and 1047 with
ClientLevel.getRandom(), not the server level's random: drawing them from
the world's random moved the level random in use_item_on's respawn
anchor cases (12 of 4000 differed).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 23e28eab7..ac567483a 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -3112,12 +3112,19 @@ impl Game<'_> {
                     };
                     if let Some((name, volume)) = sound {
                         let pitch = match id {
-                            1009 | 1501 | 1502 => {
+                            1009 => {
                                 2.6 + (self.world.random.next_float()
                                     - self.world.random.next_float())
                                     * 0.8
                             }
-                            1029 | 1030 | 1042 | 1043 | 1044 | 1046 | 1047 | 1053 | 1054 => {
+                            // LevelEventHandler draws these from the client
+                            // level's random, before 1501's and 1502's smoke.
+                            1501 | 1502 => {
+                                let r = self.particles.level_random();
+                                2.6 + (r.next_float() - r.next_float()) * 0.8
+                            }
+                            1046 | 1047 => self.particles.level_random().next_float() * 0.1 + 0.9,
+                            1029 | 1030 | 1042 | 1043 | 1044 | 1053 | 1054 => {
                                 self.world.random.next_float() * 0.1 + 0.9
                             }
                             1019 | 1021 => {

From 42c653be0047a953ed37da7970cc1bf2560fa85c Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 09:18:56 +0100
Subject: [PATCH 464/475] refactor: sprite_mipmap_limit lives in sprites.rs

sprites.rs called back into gfx for this one function, one of the edges that
keep the client lib's modules in a single cycle. The function and its test
move to sprites.rs; gfx calls it there. No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/gfx.rs     | 14 +-------------
 crates/horizon-client/src/sprites.rs | 19 +++++++++++++++++--
 tools/bench_sprite_mips.py           |  4 +++-
 3 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index b2dd58247..b22a66280 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -3197,7 +3197,7 @@ impl Renderer {
     /// The Mipmap Levels option: block textures sample at most `levels`
     /// reduced copies (0: none).
     pub fn set_mipmap_levels(&mut self, levels: u32) {
-        let levels = sprite_mipmap_limit(
+        let levels = crate::sprites::sprite_mipmap_limit(
             levels,
             self.sprite_textures[0].width(),
             self.sprite_minimum_size,
@@ -5479,11 +5479,6 @@ mod tests {
     }
 }
 
-pub(crate) fn sprite_mipmap_limit(requested: u32, size: u32, minimum: u32, available: u32) -> u32 {
-    // Only the atlas native minimum determines how many resampling-only mips to skip.
-    let upscale = (size / minimum.max(1)).max(1).ilog2();
-    requested.saturating_add(upscale).min(available - 1)
-}
 #[cfg(test)]
 mod sprite_upload_tests {
     use super::*;
@@ -5544,13 +5539,6 @@ mod sprite_upload_tests {
         }
     }
     #[test]
-    fn mipmap_option_keeps_real_16px_reductions() {
-        for levels in 0..=4 {
-            assert_eq!(sprite_mipmap_limit(levels, 32, 16, 6), levels + 1);
-            assert_eq!(sprite_mipmap_limit(levels, 16, 16, 5), levels);
-        }
-    }
-    #[test]
     fn prepared_texture_uploads_preserve_layer_order_and_settings() {
         let size = 4;
         let layers = 5;
diff --git a/crates/horizon-client/src/sprites.rs b/crates/horizon-client/src/sprites.rs
index 6d754894a..b720c5bfd 100644
--- a/crates/horizon-client/src/sprites.rs
+++ b/crates/horizon-client/src/sprites.rs
@@ -342,10 +342,25 @@ pub(crate) fn test_frames(layer: u32, frames: Vec<Vec<u8>>, metadata: &str) -> S
     }
 }
 
+/// How many reduced copies a sprite atlas keeps: the Mipmap Levels option plus the
+/// resampling-only levels an upscaled pack needs, within what the atlas holds.
+pub(crate) fn sprite_mipmap_limit(requested: u32, size: u32, minimum: u32, available: u32) -> u32 {
+    // Only the atlas native minimum determines how many resampling-only mips to skip.
+    let upscale = (size / minimum.max(1)).max(1).ilog2();
+    requested.saturating_add(upscale).min(available - 1)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     #[test]
+    fn mipmap_option_keeps_real_16px_reductions() {
+        for levels in 0..=4 {
+            assert_eq!(sprite_mipmap_limit(levels, 32, 16, 6), levels + 1);
+            assert_eq!(sprite_mipmap_limit(levels, 16, 16, 5), levels);
+        }
+    }
+    #[test]
     fn identical_still_textures_share_a_layer() {
         let root =
             std::env::temp_dir().join(format!("horizon-sprite-share-{}", std::process::id()));
@@ -398,7 +413,7 @@ mod tests {
         assert_eq!((sprites.size, sprites.minimum_size), (32, 32));
         for level in 0..=4 {
             assert_eq!(
-                crate::gfx::sprite_mipmap_limit(level, sprites.size, sprites.minimum_size, 6),
+                sprite_mipmap_limit(level, sprites.size, sprites.minimum_size, 6),
                 level
             );
         }
@@ -408,7 +423,7 @@ mod tests {
         sprites.finish();
         assert_eq!((sprites.size, sprites.minimum_size), (32, 16));
         assert_eq!(
-            crate::gfx::sprite_mipmap_limit(0, sprites.size, sprites.minimum_size, 6),
+            sprite_mipmap_limit(0, sprites.size, sprites.minimum_size, 6),
             1
         );
     }
diff --git a/tools/bench_sprite_mips.py b/tools/bench_sprite_mips.py
index 68024d6d2..e2456e3e9 100644
--- a/tools/bench_sprite_mips.py
+++ b/tools/bench_sprite_mips.py
@@ -52,7 +52,9 @@ def main():
     baseline = subprocess.check_output(['git', 'show', '89b58991bbc02eb79b6965fc4ca56357fe2297d9:crates/horizon-client/src/gfx.rs'], cwd=ROOT, text=True)
     code += '\n' + function(baseline, 'animate_sprites').replace('fn animate_sprites(', 'fn reference_animate_sprites(', 1)
     if args.test:
-        code += '\n' + function(source, 'sprite_mipmap_limit')
+        # sprites.rs holds it since the gfx -> sprites cut; older refs kept it in gfx.rs.
+        code += '\n' + (function(source, 'sprite_mipmap_limit') if 'fn sprite_mipmap_limit' in source
+                         else 'use sprites::sprite_mipmap_limit;')
         code += '\n' + source[source.index('#[cfg(test)]\nmod sprite_upload_tests'):]
     modules = '\n'.join(f'#[path = {json.dumps(str(ROOT / "crates/horizon-client/src" / (name + ".rs")))}] mod {name};'
                         for name in ('mipmap', 'sprites', 'fast_hash'))

From ae713f7bd8c5a0f15987838aa130a8a3d8f96ad9 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 09:27:51 +0100
Subject: [PATCH 465/475] refactor: item_render's error-order check lives in
 item_render's tests

model_library's test ended with a check of ItemRenderer::load_with_library,
which made model_library depend on item_render, one of the edges that keep
the client lib in a single cycle. The check moves to item_render's tests
with its own fixture. No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/item_render.rs   | 27 ++++++++++++++++++++++
 crates/horizon-client/src/model_library.rs | 13 +----------
 2 files changed, 28 insertions(+), 12 deletions(-)

diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs
index 8188eb712..320988f5e 100644
--- a/crates/horizon-client/src/item_render.rs
+++ b/crates/horizon-client/src/item_render.rs
@@ -759,6 +759,33 @@ pub fn cluster_poses(state: &ItemRenderState, pose: Mat4, amount: u32, seed: i64
 mod tests {
     use super::*;
 
+    /// A bad item model surfaces only once items.json has loaded, so a broken
+    /// items.json still reports itself first.
+    #[test]
+    fn item_model_errors_wait_for_the_item_definitions() -> crate::Result<()> {
+        let root =
+            std::env::temp_dir().join(format!("horizon-item-model-errors-{}", std::process::id()));
+        let model = root.join("assets/horizon/models/INVALID.json");
+        fs::create_dir_all(model.parent().unwrap())?;
+        fs::write(model, "{}")?;
+        let library = crate::model_library::ParsedModels::load(&root).into_item_library();
+        assert!(library.is_err());
+        fs::write(root.join("items.json"), "{")?;
+        let load = || {
+            ItemRenderer::load_with_library(&root, library.clone())
+                .err()
+                .unwrap()
+                .to_string()
+        };
+        let broken_items = load();
+        fs::write(root.join("items.json"), "{}")?;
+        let bad_model = load();
+        let _ = fs::remove_dir_all(&root);
+        assert!(!broken_items.starts_with("item models:"));
+        assert!(bad_model.starts_with("item models:"));
+        Ok(())
+    }
+
     #[test]
     fn rendered_amounts_follow_the_count_bands() {
         let bands: Vec<u32> = [0, 1, 2, 16, 17, 32, 33, 48, 49, 64]
diff --git a/crates/horizon-client/src/model_library.rs b/crates/horizon-client/src/model_library.rs
index 018bc6af2..5edf0f5a4 100644
--- a/crates/horizon-client/src/model_library.rs
+++ b/crates/horizon-client/src/model_library.rs
@@ -232,18 +232,7 @@ mod tests {
                 .block_library(&fixture.0, vec!["horizon:nested/child".into()])
                 .is_ok()
         );
-        let library = parsed.into_item_library();
-        assert!(library.is_err());
-        fs::write(fixture.0.join("items.json"), "{")?;
-        let load = || {
-            crate::item_render::ItemRenderer::load_with_library(&fixture.0, library.clone())
-                .err()
-                .unwrap()
-                .to_string()
-        };
-        assert!(!load().starts_with("item models:"));
-        fs::write(fixture.0.join("items.json"), "{}")?;
-        assert!(load().starts_with("item models:"));
+        assert!(parsed.into_item_library().is_err());
         Ok(())
     }
 }

From 86d90c38a9c1794a14a59eccda6203f4f9f16016 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 09:34:22 +0100
Subject: [PATCH 466/475] refactor: the pack filter regex lives in
 horizon-client-core

packs/pattern.rs is self-contained; atlas_sources reached into packs for it,
one of the edges that keep the client lib in a single cycle. It moves to
horizon-client-core and packs re-exports it under its old path. No
behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client-core/src/lib.rs                       | 6 ++++--
 .../src/packs => horizon-client-core/src}/pattern.rs        | 0
 crates/horizon-client/src/atlas_sources.rs                  | 2 +-
 crates/horizon-client/src/packs.rs                          | 2 +-
 docs/resource-packs.md                                      | 2 +-
 5 files changed, 7 insertions(+), 5 deletions(-)
 rename crates/{horizon-client/src/packs => horizon-client-core/src}/pattern.rs (100%)

diff --git a/crates/horizon-client-core/src/lib.rs b/crates/horizon-client-core/src/lib.rs
index ca40141d1..2030165c5 100644
--- a/crates/horizon-client-core/src/lib.rs
+++ b/crates/horizon-client-core/src/lib.rs
@@ -1,8 +1,9 @@
 //! The client's lowest layer, below commands and gameplay: chat text and
 //! translations, SNBT and NBT paths, text components, the scoreboard, boss
 //! bars, game rules, block entity NBT tables, and the registry, particle and
-//! sound source tables commands name. horizon-client re-exports each module
-//! under its old path (`horizon_client::text`, ...).
+//! sound source tables commands name, and the `pack.mcmeta` filter regex.
+//! horizon-client re-exports each module under its old path
+//! (`horizon_client::text`, ...).
 #![forbid(unsafe_code)]
 pub mod block_entity_nbt;
 pub mod bossbar;
@@ -14,6 +15,7 @@ pub mod key_display;
 pub mod lang;
 pub mod nbt_path;
 pub mod particle_type;
+pub mod pattern;
 pub mod registries;
 pub mod scoreboard;
 pub mod snbt;
diff --git a/crates/horizon-client/src/packs/pattern.rs b/crates/horizon-client-core/src/pattern.rs
similarity index 100%
rename from crates/horizon-client/src/packs/pattern.rs
rename to crates/horizon-client-core/src/pattern.rs
diff --git a/crates/horizon-client/src/atlas_sources.rs b/crates/horizon-client/src/atlas_sources.rs
index 1eea24666..fbed22fd2 100644
--- a/crates/horizon-client/src/atlas_sources.rs
+++ b/crates/horizon-client/src/atlas_sources.rs
@@ -3,8 +3,8 @@
 //! `filter`, `unstitch` and `paletted_permutations` sources run in order
 //! against the resource tree; a later source replaces an earlier sprite of
 //! the same id and a filter removes the matching ones.
-use crate::packs::pattern::Pattern;
 use horizon_assets::palette::apply_palette;
+use horizon_client_core::pattern::Pattern;
 use serde_json::Value;
 use std::{
     collections::BTreeMap,
diff --git a/crates/horizon-client/src/packs.rs b/crates/horizon-client/src/packs.rs
index 1e012fd90..28952ba2c 100644
--- a/crates/horizon-client/src/packs.rs
+++ b/crates/horizon-client/src/packs.rs
@@ -4,9 +4,9 @@
 //! and an overlay resource root that layers the enabled packs over the
 //! vanilla resources (later packs win), so every loader sees one tree.
 mod cache;
-pub mod pattern;
 use crate::text::Style;
 use crate::{text::Text, zip::Zip};
+pub use horizon_client_core::pattern;
 use pattern::Pattern;
 use std::{
     collections::{BTreeMap, BTreeSet},
diff --git a/docs/resource-packs.md b/docs/resource-packs.md
index 783c381dd..8b22e816a 100644
--- a/docs/resource-packs.md
+++ b/docs/resource-packs.md
@@ -31,7 +31,7 @@ harness named checks that loader against vanilla).
 | --- | --- | --- | --- |
 | Pack metadata: description, icon, `min_format`/`max_format`, old `supported_formats`, compatibility warning | `pack.mcmeta`, `pack.png` | works | `test_pack_screen_parity`, `test_pack_selection_parity` |
 | Overlays per format | `pack.mcmeta` `overlays` | works | `test_resource_pack_parity` (an overlay for 26.3 applied, an older one not) |
-| Filters | `pack.mcmeta` `filter` | works | `test_resource_pack_parity` (`packs/pattern.rs` regex subset) |
+| Filters | `pack.mcmeta` `filter` | works | `test_resource_pack_parity` (`horizon-client-core/src/pattern.rs` regex subset) |
 | Folder and zip packs, order, built-in packs | `resourcepacks/` | works | `test_resource_pack_parity`, `test_pack_selection_parity` |
 | Server resource packs: the prompt, the server list's Server Resource Packs setting, download (250 MiB, SHA-1, `downloads/` keeps 20), applied on top of the player's packs, removed on leaving | the server's `resource_pack_push`/`_pop` | works, no download toasts | `tools/server_pack_e2e.py` (against vanilla's server and Horizon's), unit tests in `server_packs.rs`; `test_server_resource_pack_parity` for Horizon's server |
 | Other namespaces | `assets/<namespace>/` | works | `test_resource_pack_parity` |

From 07e935d0bfee8d652520e8ce8a931d1512b1d280 Mon Sep 17 00:00:00 2001
From: FusselTV <github@fussel.tv>
Date: Tue, 27 Oct 2026 10:29:53 +0100
Subject: [PATCH 467/475] Mobs: drop the unreachable second rabbit arm in
 mob_to_nbt

#2585 and 0d496fdc8 both added a "minecraft:rabbit" arm to mob_to_nbt;
the first writes RabbitType and MoreCarrotTicks, so the second is never
reached and clippy -D warnings fails on main (unreachable_patterns).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/entity_nbt.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index c65f35f5b..b2d1401da 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -498,10 +498,6 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
                 Tag::Int(i32::from(m.extra.variant.min(4))),
             );
         }
-        // Rabbit.addAdditionalSaveData (the legacy id; 99 is the killer bunny).
-        "minecraft:rabbit" => {
-            map.insert("RabbitType".into(), Tag::Int(i32::from(m.extra.variant)));
-        }
         "minecraft:parrot" => {
             map.insert(
                 "Variant".into(),

From d50a5e1f640a03fb15d3379e39ea67e0a4a3bf4d Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 11:11:39 +0100
Subject: [PATCH 468/475] refactor: ChunkExtras and RolledLoot live in chunk.rs

The chunk stores them, but they were defined in save.rs, which made chunk.rs
depend on save, one of the edges that keep the client lib in a single cycle.
They move to chunk.rs and save re-exports them. No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/chunk.rs | 57 +++++++++++++++++++++++++++++-
 crates/horizon-client/src/save.rs  | 54 +---------------------------
 2 files changed, 57 insertions(+), 54 deletions(-)

diff --git a/crates/horizon-client/src/chunk.rs b/crates/horizon-client/src/chunk.rs
index 7cd375343..f3df1ea14 100644
--- a/crates/horizon-client/src/chunk.rs
+++ b/crates/horizon-client/src/chunk.rs
@@ -2,6 +2,7 @@
 //! threads can mesh and light immutable snapshots while the game thread edits
 //! (copy-on-write through `Arc::make_mut`).
 use horizon_core::paletted::{PalettedContainer, Strategy};
+use horizon_world::nbt::{Compound, Tag};
 use horizon_world::registry::BlockStateId;
 use std::sync::{Arc, OnceLock};
 
@@ -155,7 +156,7 @@ pub struct Chunk {
     /// positions, applied once by LevelChunk.postProcessGeneration.
     pub postprocess: Vec<[i32; 3]>,
     /// Saved data Horizon keeps but does not simulate (save.rs).
-    pub saved: Option<Arc<crate::save::ChunkExtras>>,
+    pub saved: Option<Arc<ChunkExtras>>,
     /// Entities read from a save (vanilla entity NBT), spawned on arrival.
     pub entities: Vec<horizon_world::nbt::Tag>,
     /// Structure starts reaching into this chunk (`structures.References`):
@@ -432,3 +433,57 @@ mod tests {
         }
     }
 }
+
+/// A container's loot table and what Horizon rolled from it. Vanilla keeps
+/// `LootTable` and `LootTableSeed` until the container is first opened;
+/// Horizon rolls when it generates or loads the chunk, and saves the table
+/// again while the container still holds exactly the rolled items.
+#[derive(Clone, Debug, PartialEq)]
+pub struct RolledLoot {
+    pub pos: (i32, i32, i32),
+    pub table: String,
+    /// The saved `LootTableSeed`, written back unless 0 (trySaveLootTable).
+    pub seed: Option<i64>,
+    /// The rolled `Items`.
+    pub items: Tag,
+}
+impl RolledLoot {
+    /// Puts the loot table back in place of `Items` while they are still the
+    /// roll; false once the container holds anything else.
+    pub fn restore(&self, map: &mut Compound) -> bool {
+        if map.get(&"Items".into()) != Some(&self.items) {
+            return false;
+        }
+        map.remove(&"Items".into());
+        map.insert("LootTable".into(), Tag::String(self.table.as_str().into()));
+        if let Some(seed) = self.seed.filter(|s| *s != 0) {
+            map.insert("LootTableSeed".into(), Tag::Long(seed));
+        }
+        true
+    }
+}
+
+/// Save data loaded with a chunk that Horizon keeps but does not simulate.
+#[derive(Clone, Debug, Default)]
+pub struct ChunkExtras {
+    /// Chunk root keys written back as loaded (structures, PostProcessing,
+    /// InhabitedTime, blending data, ...).
+    pub root: Compound,
+    /// Block entities Horizon does not model.
+    pub block_entities: Vec<Tag>,
+    /// The NBT of the modelled block entities as loaded, to restore the fields and
+    /// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`).
+    pub block_entity_sources: Vec<((i32, i32, i32), Tag)>,
+    /// Every saved block entity's position in the order of the save's list,
+    /// the order `SerializableChunkData` puts them in the chunk's maps.
+    pub block_entity_order: Vec<(i32, i32, i32)>,
+    /// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the
+    /// save time. Registered with the level's tick scheduler on arrival and
+    /// replaced with the scheduler's pending ticks when saving.
+    pub block_ticks: Vec<horizon_core::ticks::SavedTick>,
+    pub fluid_ticks: Vec<horizon_core::ticks::SavedTick>,
+    /// Game time written as `LastUpdate`.
+    pub last_update: i64,
+    /// Containers still holding their loot table's roll.
+    pub rolled_loot: Vec<RolledLoot>,
+}
diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs
index 39456e865..a90e443fe 100644
--- a/crates/horizon-client/src/save.rs
+++ b/crates/horizon-client/src/save.rs
@@ -339,59 +339,7 @@ impl SaveTables {
     }
 }
 
-/// A container's loot table and what Horizon rolled from it. Vanilla keeps
-/// `LootTable` and `LootTableSeed` until the container is first opened;
-/// Horizon rolls when it generates or loads the chunk, and saves the table
-/// again while the container still holds exactly the rolled items.
-#[derive(Clone, Debug, PartialEq)]
-pub struct RolledLoot {
-    pub pos: (i32, i32, i32),
-    pub table: String,
-    /// The saved `LootTableSeed`, written back unless 0 (trySaveLootTable).
-    pub seed: Option<i64>,
-    /// The rolled `Items`.
-    pub items: Tag,
-}
-impl RolledLoot {
-    /// Puts the loot table back in place of `Items` while they are still the
-    /// roll; false once the container holds anything else.
-    pub fn restore(&self, map: &mut Compound) -> bool {
-        if map.get(&"Items".into()) != Some(&self.items) {
-            return false;
-        }
-        map.remove(&"Items".into());
-        map.insert("LootTable".into(), string(&self.table));
-        if let Some(seed) = self.seed.filter(|s| *s != 0) {
-            map.insert("LootTableSeed".into(), Tag::Long(seed));
-        }
-        true
-    }
-}
-
-/// Save data loaded with a chunk that Horizon keeps but does not simulate.
-#[derive(Clone, Debug, Default)]
-pub struct ChunkExtras {
-    /// Chunk root keys written back as loaded (structures, PostProcessing,
-    /// InhabitedTime, blending data, ...).
-    pub root: Compound,
-    /// Block entities Horizon does not model.
-    pub block_entities: Vec<Tag>,
-    /// The NBT of the modelled block entities as loaded, to restore the fields and
-    /// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`).
-    pub block_entity_sources: Vec<((i32, i32, i32), Tag)>,
-    /// Every saved block entity's position in the order of the save's list,
-    /// the order `SerializableChunkData` puts them in the chunk's maps.
-    pub block_entity_order: Vec<(i32, i32, i32)>,
-    /// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the
-    /// save time. Registered with the level's tick scheduler on arrival and
-    /// replaced with the scheduler's pending ticks when saving.
-    pub block_ticks: Vec<SavedTick>,
-    pub fluid_ticks: Vec<SavedTick>,
-    /// Game time written as `LastUpdate`.
-    pub last_update: i64,
-    /// Containers still holding their loot table's roll.
-    pub rolled_loot: Vec<RolledLoot>,
-}
+pub use crate::chunk::{ChunkExtras, RolledLoot};
 
 fn tick_list(ticks: &[SavedTick], name: impl Fn(u32) -> Option<String>) -> Tag {
     Tag::List(

From 8601d34f2064e47def7adcfd61a4cd23fdfb0571 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 11:13:01 +0100
Subject: [PATCH 469/475] Merge main into fix/particles-option-level

The shulker's teleport particles (event 2016, from main) take the
engine's own particle level like the other block_teleportation calls.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/game/level_particles.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/horizon-client/src/game/level_particles.rs b/crates/horizon-client/src/game/level_particles.rs
index c972a6476..000b77e9a 100644
--- a/crates/horizon-client/src/game/level_particles.rs
+++ b/crates/horizon-client/src/game/level_particles.rs
@@ -15,8 +15,7 @@ impl Game<'_> {
     /// Event 2016: `Shulker.teleportSomewhere`'s particles between the
     /// shell's old and new cells.
     pub(super) fn shulker_teleport_particles(&mut self, pos: [i32; 3], data: i32) {
-        self.particles
-            .block_teleportation(pos, data, [8, 8, 8], self.settings.particles);
+        self.particles.block_teleportation(pos, data, [8, 8, 8]);
     }
     /// Event 2017: `TeleportRandomlyConsumeEffect`'s directional particles.
     pub(super) fn consume_teleport_particles(&mut self, pos: [i32; 3], data: i32) {

From 83bdb31eeae4199e89e573cfba8cab0b18ffbf02 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 12:09:52 +0100
Subject: [PATCH 470/475] refactor: SavedProto lives in chunk.rs

streaming's ChunkGenerator trait named save::SavedProto, which made
streaming depend on save, one of the edges that keep the client lib in a
single cycle. The plain data type moves beside ChunkExtras in chunk.rs and
save re-exports it. No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/chunk.rs     | 124 ++++++++++++++-----------
 crates/horizon-client/src/save.rs      |  17 +---
 crates/horizon-client/src/streaming.rs |   4 +-
 3 files changed, 73 insertions(+), 72 deletions(-)

diff --git a/crates/horizon-client/src/chunk.rs b/crates/horizon-client/src/chunk.rs
index f3df1ea14..b0dd377c7 100644
--- a/crates/horizon-client/src/chunk.rs
+++ b/crates/horizon-client/src/chunk.rs
@@ -310,6 +310,76 @@ impl Chunk {
     }
 }
 
+/// A proto chunk saved before it became final. Decoration writes into a
+/// chunk's neighbours, and decorated chunks wait for theirs, so the chunks
+/// past the finished ones hold writes that generating them again would lose
+/// (whole structure pieces, trees, ores). Vanilla saves its proto chunks too.
+pub struct SavedProto {
+    /// Blocks, scheduled ticks (in `saved`) and post-processing marks.
+    pub column: Chunk,
+    /// Decorated itself (`features`), not only written to by its neighbours
+    /// (`terrain`).
+    pub decorated: bool,
+    /// Block entity data in placement order, with `x`, `y` and `z`.
+    pub block_entities: Vec<Tag>,
+    /// Entities placed by structures, with absolute `Pos`.
+    pub entities: Vec<Tag>,
+}
+
+/// A container's loot table and what Horizon rolled from it. Vanilla keeps
+/// `LootTable` and `LootTableSeed` until the container is first opened;
+/// Horizon rolls when it generates or loads the chunk, and saves the table
+/// again while the container still holds exactly the rolled items.
+#[derive(Clone, Debug, PartialEq)]
+pub struct RolledLoot {
+    pub pos: (i32, i32, i32),
+    pub table: String,
+    /// The saved `LootTableSeed`, written back unless 0 (trySaveLootTable).
+    pub seed: Option<i64>,
+    /// The rolled `Items`.
+    pub items: Tag,
+}
+impl RolledLoot {
+    /// Puts the loot table back in place of `Items` while they are still the
+    /// roll; false once the container holds anything else.
+    pub fn restore(&self, map: &mut Compound) -> bool {
+        if map.get(&"Items".into()) != Some(&self.items) {
+            return false;
+        }
+        map.remove(&"Items".into());
+        map.insert("LootTable".into(), Tag::String(self.table.as_str().into()));
+        if let Some(seed) = self.seed.filter(|s| *s != 0) {
+            map.insert("LootTableSeed".into(), Tag::Long(seed));
+        }
+        true
+    }
+}
+
+/// Save data loaded with a chunk that Horizon keeps but does not simulate.
+#[derive(Clone, Debug, Default)]
+pub struct ChunkExtras {
+    /// Chunk root keys written back as loaded (structures, PostProcessing,
+    /// InhabitedTime, blending data, ...).
+    pub root: Compound,
+    /// Block entities Horizon does not model.
+    pub block_entities: Vec<Tag>,
+    /// The NBT of the modelled block entities as loaded, to restore the fields and
+    /// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`).
+    pub block_entity_sources: Vec<((i32, i32, i32), Tag)>,
+    /// Every saved block entity's position in the order of the save's list,
+    /// the order `SerializableChunkData` puts them in the chunk's maps.
+    pub block_entity_order: Vec<(i32, i32, i32)>,
+    /// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the
+    /// save time. Registered with the level's tick scheduler on arrival and
+    /// replaced with the scheduler's pending ticks when saving.
+    pub block_ticks: Vec<horizon_core::ticks::SavedTick>,
+    pub fluid_ticks: Vec<horizon_core::ticks::SavedTick>,
+    /// Game time written as `LastUpdate`.
+    pub last_update: i64,
+    /// Containers still holding their loot table's roll.
+    pub rolled_loot: Vec<RolledLoot>,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -433,57 +503,3 @@ mod tests {
         }
     }
 }
-
-/// A container's loot table and what Horizon rolled from it. Vanilla keeps
-/// `LootTable` and `LootTableSeed` until the container is first opened;
-/// Horizon rolls when it generates or loads the chunk, and saves the table
-/// again while the container still holds exactly the rolled items.
-#[derive(Clone, Debug, PartialEq)]
-pub struct RolledLoot {
-    pub pos: (i32, i32, i32),
-    pub table: String,
-    /// The saved `LootTableSeed`, written back unless 0 (trySaveLootTable).
-    pub seed: Option<i64>,
-    /// The rolled `Items`.
-    pub items: Tag,
-}
-impl RolledLoot {
-    /// Puts the loot table back in place of `Items` while they are still the
-    /// roll; false once the container holds anything else.
-    pub fn restore(&self, map: &mut Compound) -> bool {
-        if map.get(&"Items".into()) != Some(&self.items) {
-            return false;
-        }
-        map.remove(&"Items".into());
-        map.insert("LootTable".into(), Tag::String(self.table.as_str().into()));
-        if let Some(seed) = self.seed.filter(|s| *s != 0) {
-            map.insert("LootTableSeed".into(), Tag::Long(seed));
-        }
-        true
-    }
-}
-
-/// Save data loaded with a chunk that Horizon keeps but does not simulate.
-#[derive(Clone, Debug, Default)]
-pub struct ChunkExtras {
-    /// Chunk root keys written back as loaded (structures, PostProcessing,
-    /// InhabitedTime, blending data, ...).
-    pub root: Compound,
-    /// Block entities Horizon does not model.
-    pub block_entities: Vec<Tag>,
-    /// The NBT of the modelled block entities as loaded, to restore the fields and
-    /// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`).
-    pub block_entity_sources: Vec<((i32, i32, i32), Tag)>,
-    /// Every saved block entity's position in the order of the save's list,
-    /// the order `SerializableChunkData` puts them in the chunk's maps.
-    pub block_entity_order: Vec<(i32, i32, i32)>,
-    /// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the
-    /// save time. Registered with the level's tick scheduler on arrival and
-    /// replaced with the scheduler's pending ticks when saving.
-    pub block_ticks: Vec<horizon_core::ticks::SavedTick>,
-    pub fluid_ticks: Vec<horizon_core::ticks::SavedTick>,
-    /// Game time written as `LastUpdate`.
-    pub last_update: i64,
-    /// Containers still holding their loot table's roll.
-    pub rolled_loot: Vec<RolledLoot>,
-}
diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs
index a325a455f..9d47f819c 100644
--- a/crates/horizon-client/src/save.rs
+++ b/crates/horizon-client/src/save.rs
@@ -339,7 +339,7 @@ impl SaveTables {
     }
 }
 
-pub use crate::chunk::{ChunkExtras, RolledLoot};
+pub use crate::chunk::{ChunkExtras, RolledLoot, SavedProto};
 
 fn tick_list(ticks: &[SavedTick], name: impl Fn(u32) -> Option<String>) -> Tag {
     Tag::List(
@@ -1476,21 +1476,6 @@ fn decode_column(
     Some(chunk)
 }
 
-/// A proto chunk saved before it became final. Decoration writes into a
-/// chunk's neighbours, and decorated chunks wait for theirs, so the chunks
-/// past the finished ones hold writes that generating them again would lose
-/// (whole structure pieces, trees, ores). Vanilla saves its proto chunks too.
-pub struct SavedProto {
-    /// Blocks, scheduled ticks (in `saved`) and post-processing marks.
-    pub column: Chunk,
-    /// Decorated itself (`features`), not only written to by its neighbours
-    /// (`terrain`).
-    pub decorated: bool,
-    /// Block entity data in placement order, with `x`, `y` and `z`.
-    pub block_entities: Vec<Tag>,
-    /// Entities placed by structures, with absolute `Pos`.
-    pub entities: Vec<Tag>,
-}
 pub fn encode_proto(
     proto: &SavedProto,
     registry: &BlockRegistry,
diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs
index 619a0202c..6588ac32d 100644
--- a/crates/horizon-client/src/streaming.rs
+++ b/crates/horizon-client/src/streaming.rs
@@ -75,11 +75,11 @@ pub trait ChunkGenerator: Send + Sync + 'static {
     fn light_view(&self, _proto: &Proto) -> Option<Chunk> {
         None
     }
-    fn saved_proto(&self, _proto: &Proto) -> Option<crate::save::SavedProto> {
+    fn saved_proto(&self, _proto: &Proto) -> Option<crate::chunk::SavedProto> {
         None
     }
     /// Put a saved proto chunk's state back onto `proto`, generated again.
-    fn restore_proto(&self, _proto: &mut Proto, _saved: crate::save::SavedProto) {}
+    fn restore_proto(&self, _proto: &mut Proto, _saved: crate::chunk::SavedProto) {}
     /// Save proto chunks decoration wrote to, so that they come back as they
     /// were: generating them again would lose those writes.
     fn save_protos(&self, _protos: &[&Proto]) {}

From 84c631a88b15a0f3fca6613c297dcad2addb1457 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 12:11:26 +0100
Subject: [PATCH 471/475] refactor: the villager Poi enum lives in
 poi_sections.rs

World's POI sections are typed by mobs::villager_brain::Poi, which made
world depend on mobs, one of the edges that keep the client lib in a single
cycle. The enum moves to poi_sections.rs; villager_brain re-exports it and
keeps its methods. No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/mobs/villager_brain.rs | 9 +--------
 crates/horizon-client/src/poi_sections.rs        | 9 +++++++++
 crates/horizon-client/src/world.rs               | 2 +-
 3 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/crates/horizon-client/src/mobs/villager_brain.rs b/crates/horizon-client/src/mobs/villager_brain.rs
index 2052eef4c..724829354 100644
--- a/crates/horizon-client/src/mobs/villager_brain.rs
+++ b/crates/horizon-client/src/mobs/villager_brain.rs
@@ -789,14 +789,7 @@ pub fn golem_detected(m: &mut Mob, now: i64) {
 
 // ---- Behaviours ---------------------------------------------------------
 
-/// The POI types villagers use.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Poi {
-    /// A job site, by profession index.
-    Job(u8),
-    Home,
-    Meeting,
-}
+pub use crate::poi_sections::Poi;
 impl Poi {
     fn max_tickets(self) -> usize {
         match self {
diff --git a/crates/horizon-client/src/poi_sections.rs b/crates/horizon-client/src/poi_sections.rs
index 79ff0441d..a806706a1 100644
--- a/crates/horizon-client/src/poi_sections.rs
+++ b/crates/horizon-client/src/poi_sections.rs
@@ -79,6 +79,15 @@ impl<T: Copy> PoiSections<T> {
     }
 }
 
+/// The POI types villagers use.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Poi {
+    /// A job site, by profession index.
+    Job(u8),
+    Home,
+    Meeting,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/horizon-client/src/world.rs b/crates/horizon-client/src/world.rs
index 00ff04ac5..9eb8946df 100644
--- a/crates/horizon-client/src/world.rs
+++ b/crates/horizon-client/src/world.rs
@@ -92,7 +92,7 @@ pub struct World {
     /// (`ChunkHolder.sectionLightChanged`).
     pub light_log: Option<crate::fast_hash::FxHashMap<(i32, i32), u32>>,
     /// The villager POIs of each section (`PoiManager`'s sections).
-    pub pois: crate::poi_sections::PoiSections<crate::mobs::villager_brain::Poi>,
+    pub pois: crate::poi_sections::PoiSections<crate::poi_sections::Poi>,
     /// Moving-piston states removed during the last tick; retained until the
     /// final block mesh is visible.
     pub moving_piston_fallback: Vec<([i32; 3], horizon_world::piston_shape::MovingPistonState)>,

From 90a3fc82aa56d764e6a988e706c9cce1ff80571c Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 12:11:14 +0100
Subject: [PATCH 472/475] refactor: HealthRules lives in world.rs

World holds the health rules but they were defined in health.rs, which made
world depend on health, one of the edges that keep the client lib in a
single cycle. The plain data type (and its Default) moves to world.rs and
health re-exports it. No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/health.rs | 24 +----------------------
 crates/horizon-client/src/world.rs  | 30 +++++++++++++++++++++++++++--
 2 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/crates/horizon-client/src/health.rs b/crates/horizon-client/src/health.rs
index 31e4e8104..2cee71a31 100644
--- a/crates/horizon-client/src/health.rs
+++ b/crates/horizon-client/src/health.rs
@@ -25,29 +25,7 @@ use std::{fs, io, path::Path};
 pub(crate) type Attributes = LiveAttributes<Box<dyn FnMut() -> i32>>;
 pub(crate) type State = HurtState<DamageTypeId>;
 
-#[derive(Clone, Copy, Debug)]
-pub struct HealthRules {
-    pub difficulty: Difficulty,
-    pub natural_regeneration: bool,
-    /// The `drowning_damage`, `fall_damage`, `fire_damage` and
-    /// `freeze_damage` rules `Player.isInvulnerableTo` reads.
-    pub drowning_damage: bool,
-    pub fall_damage: bool,
-    pub fire_damage: bool,
-    pub freeze_damage: bool,
-}
-impl Default for HealthRules {
-    fn default() -> Self {
-        Self {
-            difficulty: Difficulty::Normal,
-            natural_regeneration: true,
-            drowning_damage: true,
-            fall_damage: true,
-            fire_damage: true,
-            freeze_damage: true,
-        }
-    }
-}
+pub use crate::world::HealthRules;
 pub struct HealthResources {
     pub damage: Catalog,
     pub ids: PlayerFloatIds,
diff --git a/crates/horizon-client/src/world.rs b/crates/horizon-client/src/world.rs
index 00ff04ac5..9fe83bba2 100644
--- a/crates/horizon-client/src/world.rs
+++ b/crates/horizon-client/src/world.rs
@@ -53,7 +53,7 @@ pub struct World {
     pub chunks: crate::chunk_map::ChunkMap,
     pub random: LegacyRandom,
     pub revision: u64,
-    pub health_rules: crate::health::HealthRules,
+    pub health_rules: HealthRules,
     pub air: BlockStateId,
     /// Sections whose geometry changed and need remeshing.
     pub dirty_sections: DirtySections,
@@ -170,7 +170,7 @@ impl World {
             chunks: Default::default(),
             random: LegacyRandom::new(seed),
             revision: 0,
-            health_rules: crate::health::HealthRules::default(),
+            health_rules: HealthRules::default(),
             air,
             fast_lava: false,
             dirty_sections: Default::default(),
@@ -377,6 +377,32 @@ impl World {
     }
 }
 
+/// The game rules and difficulty a player's health reads (`Player.isInvulnerableTo`,
+/// natural regeneration), kept with the world they belong to.
+#[derive(Clone, Copy, Debug)]
+pub struct HealthRules {
+    pub difficulty: horizon_world::food::Difficulty,
+    pub natural_regeneration: bool,
+    /// The `drowning_damage`, `fall_damage`, `fire_damage` and
+    /// `freeze_damage` rules `Player.isInvulnerableTo` reads.
+    pub drowning_damage: bool,
+    pub fall_damage: bool,
+    pub fire_damage: bool,
+    pub freeze_damage: bool,
+}
+impl Default for HealthRules {
+    fn default() -> Self {
+        Self {
+            difficulty: horizon_world::food::Difficulty::Normal,
+            natural_regeneration: true,
+            drowning_damage: true,
+            fall_damage: true,
+            fire_damage: true,
+            freeze_damage: true,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::World;

From 35fddca7e656ea44213a9a7922436ec263ae18dd Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 12:15:36 +0100
Subject: [PATCH 473/475] refactor: the options screen's Opt enum lives in
 settings.rs

graphics_ui named options_ui::Opt for its rows, which made it depend on
options_ui, one of the edges that keep the client lib in a single cycle.
The enum (the option ids) moves to settings.rs; options_ui re-exports it
and keeps its methods. No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client/src/graphics_ui.rs |  3 +-
 crates/horizon-client/src/options_ui.rs  | 91 +-----------------------
 crates/horizon-client/src/settings.rs    | 90 +++++++++++++++++++++++
 3 files changed, 93 insertions(+), 91 deletions(-)

diff --git a/crates/horizon-client/src/graphics_ui.rs b/crates/horizon-client/src/graphics_ui.rs
index d55e44d99..cb097c114 100644
--- a/crates/horizon-client/src/graphics_ui.rs
+++ b/crates/horizon-client/src/graphics_ui.rs
@@ -5,8 +5,7 @@ use crate::{
     graphics::{FarDetail, GraphicsApi, Overlay, Pacing, PresentMode, Preset},
     graphics_style::{Cost, STYLE},
     hud::{HudAtlas, HudBatch},
-    options_ui::Opt,
-    settings::Settings,
+    settings::{Opt, Settings},
     text::Text,
     ui,
 };
diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs
index 85882009f..d4793be85 100644
--- a/crates/horizon-client/src/options_ui.rs
+++ b/crates/horizon-client/src/options_ui.rs
@@ -4,6 +4,8 @@
 //! OptionsList screens and drawn with the shared widgets.
 use std::time::Instant;
 
+pub use crate::settings::Opt;
+
 use crate::{
     gamepad::{self, GlyphStyle},
     hud::{HudAtlas, HudBatch, rgba},
@@ -14,95 +16,6 @@ use crate::{
     ui,
 };
 
-/// One option instance.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Opt {
-    Fov,
-    RenderDistance,
-    SimulationDistance,
-    Sensitivity,
-    WheelSensitivity,
-    InvertY,
-    DiscreteScroll,
-    Volume(usize),
-    GuiScale,
-    ViewBobbing,
-    Gamma,
-    MaxFps,
-    Vsync,
-    Fullscreen,
-    SmoothLighting,
-    Clouds,
-    CloudRange,
-    Particles,
-    EntityDistance,
-    EntityShadows,
-    BiomeBlend,
-    Preset,
-    Mipmaps,
-    WeatherRadius,
-    ChunkFade,
-    Vignette,
-    Autosave,
-    CutoutLeaves,
-    ImprovedTransparency,
-    AttackIndicator,
-    InactivityFps,
-    ChunkBuilder,
-    MenuBlur,
-    ToggleCrouch,
-    ToggleSprint,
-    AutoJump,
-    ChatVisibility,
-    ChatColors,
-    ChatLinks,
-    ChatLinksPrompt,
-    ChatOpacity,
-    TextBackgroundOpacity,
-    ChatScale,
-    ChatWidth,
-    ChatHeightFocused,
-    ChatHeightUnfocused,
-    ChatLineSpacing,
-    AutoSuggestions,
-    ReducedDebugInfo,
-    HighContrast,
-    ShowSubtitles,
-    MusicFrequency,
-    NotificationDisplayTime,
-    Narrator,
-    TextBackground,
-    ChatDelay,
-    DistortionEffects,
-    FovEffects,
-    DarknessPulsing,
-    DamageTilt,
-    GlintSpeed,
-    GlintStrength,
-    HideLightningFlashes,
-    MonochromeLogo,
-    PanoramaSpeed,
-    HideSplashTexts,
-    NarratorHotkey,
-    RotateWithMinecarts,
-    HighContrastBlockOutlines,
-    ForceUnicode,
-    JapaneseGlyphs,
-    /// Horizon's controller settings (`horizon-controller.txt`).
-    PadEnabled,
-    PadVibration,
-    PadAdaptiveTriggers,
-    PadLightbar,
-    PadLookSensitivity,
-    PadInvertX,
-    PadInvertY,
-    PadToggleSneak,
-    PadMoveDeadzone,
-    PadLookDeadzone,
-    PadGlyphs,
-    PadMenuNav,
-    PadKeyboard,
-}
 fn tr(key: &str) -> Text {
     Text::translate(key, &[])
 }
diff --git a/crates/horizon-client/src/settings.rs b/crates/horizon-client/src/settings.rs
index 09d7ae3ff..0c59c18f9 100644
--- a/crates/horizon-client/src/settings.rs
+++ b/crates/horizon-client/src/settings.rs
@@ -608,6 +608,96 @@ impl Settings {
     }
 }
 
+/// One option instance.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Opt {
+    Fov,
+    RenderDistance,
+    SimulationDistance,
+    Sensitivity,
+    WheelSensitivity,
+    InvertY,
+    DiscreteScroll,
+    Volume(usize),
+    GuiScale,
+    ViewBobbing,
+    Gamma,
+    MaxFps,
+    Vsync,
+    Fullscreen,
+    SmoothLighting,
+    Clouds,
+    CloudRange,
+    Particles,
+    EntityDistance,
+    EntityShadows,
+    BiomeBlend,
+    Preset,
+    Mipmaps,
+    WeatherRadius,
+    ChunkFade,
+    Vignette,
+    Autosave,
+    CutoutLeaves,
+    ImprovedTransparency,
+    AttackIndicator,
+    InactivityFps,
+    ChunkBuilder,
+    MenuBlur,
+    ToggleCrouch,
+    ToggleSprint,
+    AutoJump,
+    ChatVisibility,
+    ChatColors,
+    ChatLinks,
+    ChatLinksPrompt,
+    ChatOpacity,
+    TextBackgroundOpacity,
+    ChatScale,
+    ChatWidth,
+    ChatHeightFocused,
+    ChatHeightUnfocused,
+    ChatLineSpacing,
+    AutoSuggestions,
+    ReducedDebugInfo,
+    HighContrast,
+    ShowSubtitles,
+    MusicFrequency,
+    NotificationDisplayTime,
+    Narrator,
+    TextBackground,
+    ChatDelay,
+    DistortionEffects,
+    FovEffects,
+    DarknessPulsing,
+    DamageTilt,
+    GlintSpeed,
+    GlintStrength,
+    HideLightningFlashes,
+    MonochromeLogo,
+    PanoramaSpeed,
+    HideSplashTexts,
+    NarratorHotkey,
+    RotateWithMinecarts,
+    HighContrastBlockOutlines,
+    ForceUnicode,
+    JapaneseGlyphs,
+    /// Horizon's controller settings (`horizon-controller.txt`).
+    PadEnabled,
+    PadVibration,
+    PadAdaptiveTriggers,
+    PadLightbar,
+    PadLookSensitivity,
+    PadInvertX,
+    PadInvertY,
+    PadToggleSneak,
+    PadMoveDeadzone,
+    PadLookDeadzone,
+    PadGlyphs,
+    PadMenuNav,
+    PadKeyboard,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

From cf9fb96efac3f396b5d536241a68a2ed96212575 Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 12:26:41 +0100
Subject: [PATCH 474/475] launcher: a vertical Sculk card for the sidebar,
 readable at any size

The sidebar showed Sculk's wide banner shrunk to 228 px, and its baked-in text could not be read.
It now shows a card made for the sidebar: Sculk's characters and logo cropped from its banner, and
the headline, "Ready in under a minute", a "Get my server" button and the HORIZON15 code drawn by
the launcher, so they stay sharp and follow its language (French and Russian added). Where the
window is too short for the tall card, a compact one puts the characters beside the text. The
Partner label, the 180 s before Hide, the link and the hover lift stay; the Servers page keeps
the wide banner.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/design-system.md               |   9 +-
 launcher/assets/sculk-card-art.webp | Bin 0 -> 20598 bytes
 launcher/assets/sculk-logo.webp     | Bin 0 -> 5140 bytes
 launcher/lang/fr.json               |   5 +
 launcher/lang/ru.json               |   5 +
 launcher/src/main.rs                |  24 ++-
 launcher/src/partner.rs             | 261 +++++++++++++++++++++++++++-
 7 files changed, 290 insertions(+), 14 deletions(-)
 create mode 100644 launcher/assets/sculk-card-art.webp
 create mode 100644 launcher/assets/sculk-logo.webp

diff --git a/docs/design-system.md b/docs/design-system.md
index 0b171d4c2..aec060457 100644
--- a/docs/design-system.md
+++ b/docs/design-system.md
@@ -170,9 +170,12 @@ of the main action. The game's menus keep `LIGHT` and `DARK`.
   all rights reserved, so it is not shown.
 - **Partner banner**: the one exception to shipping no third-party pictures. Sculk, a server host,
   sponsors Horizon: its banner (`launcher/assets/sculk-banner.webp`, `launcher/src/partner.rs`) sits
-  under a muted mono "Partner" label at the end of the Servers page and of Home, below Play, and opens
-  Sculk's page in the browser. The website shows the same banner the same way on Home and the hosting
-  docs, as a `rel="sponsored"` link.
+  under a muted mono "Partner" label at the end of the Servers page and opens Sculk's page in the
+  browser. The sidebar of the other pages shows a card made for its width instead: Sculk's characters
+  and logo cropped from the same banner, and the text drawn by the launcher in its language, so it
+  stays readable; it keeps Sculk's dark card, cyan and rounded corners in both themes, as an ad does,
+  and turns compact (characters beside the text) when the window is too short. The website shows the
+  banner the same way on Home and the hosting docs, as a `rel="sponsored"` link.
 - **Pixel art drawn in code.** The stone behind the pages is close shades of the page colour
   (`TILE_SHADES`), never Minecraft's stone; the landscape is a banded sky, a sun cut in slices like
   the mark, hills and square trees (a sunset in dark, a dawn in light). The launcher bakes them in
diff --git a/launcher/assets/sculk-card-art.webp b/launcher/assets/sculk-card-art.webp
new file mode 100644
index 0000000000000000000000000000000000000000..13b9e10e441e9fff40006be94b837c07f954dbe0
GIT binary patch
literal 20598
zcmb4~<8mg95`<&h+Ss<Uv2EM7ZQHiFv2EM7ZN2Bag;O>2qi>*}s_7mjNii`y1t1`G
zQ6U921x^hZARr*5|8@)*$Ql?(P)0$53mgat7`Zi;luGH3@-OrrUx&Tuvp+}y!(^P2
zy}h&M?9|Wsl0Q_q#8%nU-Pb)QaZ+nEmmR5OqSb;w>KwxL856D8Fqlk0x%E~Y-)5_A
z-Ws3ehU-S_O||<E%1=PGbxU2E?N+Pp)~o7~OqJ91S10Q$2_;2OL`Fc&o6V#OsX(}|
z7CMM+f~Q0yfOtK1RWm|BNI0!M_uAYd!jKR{GFgC8_YYE{0np|T3>kar0P7QDq5xcz
zC!93;8%d6<A~Z@mYl0kVV1SK#*@k;R#FS(L^QN){YSz3$!4!&+34st9f+SvyWf`2@
z%`$WdA)&SbQc86L{ZbDU`ur&nU+j?)Q{Cl67I{}T!nDzh5c5(%LUlNC#8mUPHB|q;
z2F;lrR=6<-kM|SL_UHZ?{{n@^e29yHBGQs%@ia*WO<uvc4j}~63Sa0)0%wf)t@D>Q
z0gp?C*!vLf-s98I*r=lzBX$Ax&QX=J6i_fwM^PjWu=$8mDo|1n7|Dc`{oh~3Y+Cro
z7mgkPfq1-4TrANL61~niE5eY=`TgLa2&2w`s5!6*dh8U8$!(q>&`^H|OMI}HLJ;O(
zz+?QHC8nj9>5q={^ZCZs&UG3GU>`F4h~@$W3FH#JJOBhVLdl4d7$pP;P9pRgx<V+5
z+kb7wEVQ=keGN1JZH9#64>tSSt@9bnTl>kukvPIfynN687Tz-D0211RRAB)GbOi>M
zs3MVx0`wwIKVN_V66&3MUc*kw`vcGJOEqeE*oD5l-(n!B^>le)e(#k$poR^#u01p&
zB(sH9LQ#dR3QHF`NT6hcg;tZ_Q(tK-X#eob-e;~u`Al8^Nkbwbf;O%O@ZoPw!-_%)
z0@9I#h8!%SNP{C<rI1iK%_^78VN-)|5wi}Z2hcRq<jd(=ay&#JWcGcp&HwodE*nN6
zOk#T<r}?`zwqa9NnS2Yj_-sn3KqxILDjH#>Nh$>Ye0pj$9mvAba~3%FeYKvV7ZL;S
za>i}1hoeT%yH7Aa8~lAo$Dp|(kOm9!@ut1^KD1KoyZf9W$3f&WUV4mTO3x`y8l|d0
zC@iS2L12CJK4a&*rk&5_IkwWq|He^{k?UAg4$(Q`np>1ct9G|lsS9M(`=r|%1H=s2
z$lm=ZC$WxZ+A-eR2_*Hcgo1$)EP#O*7NCn_PNCtp&C!Pww|DO1*}XW<LY3zKoW9F5
z8enxRLon$ix9&!+F&e+m*WQb9bBAio9+;``c@)m3&>+R`y0{e(9*ag628Y$u(<KW+
zfrNqi$6RqVN={>L=l#{SV`%$tme=6kTK;3ZGBwdLE2At-W=$hA^^NJk=hEw*8<VLW
z7U|;&a`$_PyBmvVM>#1kfK=x?393M%u%JSTQYrM<$NT<W*3P|N+u;{PfMk;Q_xysu
zjM!2lxMS4loY9LQ#4{^AuHAbp#xA_%eQZkaCx6M+(8~Kd0a<9VtE>pDz`<<z#A3NI
z>gg&Qzk6fn&h^bZkJAgQATjV}6!7=!qt#}~x+-P>Z^z|cNZahhUk9aeX+PATP7Nv%
zD5P|Q&y6<m1VWQ~{!iG7aQJEf81}m3+9yBs+G^X*s9l;zJZQT0aTI}q8;6tZExqpW
z*78)yaTNLZh)kX3HhN|kE?JqTyNXe#t2bGhPMfmPrfW5da{ZSqS($#i%wTN9s0k}N
z$7=PY$}r%2?*AT>>{3N5YG$DSJe3eZ8VKlK5I7f@dK}mW_%9z`v~UqoAqllI&ba|(
zq%mey)FCIBRl{nhT=cK}hy9MdtsTov*LuG1Pxu4!Pu^=6!;Eo$->HAfcjt%u@7FKj
zBi@T($$uO$`+fTf_nZAo@Qe9D-vtmL00Wfx=lwLj*#U~bjPGc^{44aI<e&1tyZ-b|
z0<K@NenWrn0DyY&TmE5+m%C4bHosNC7vpkA`Pb~R-jUz63q)l4G(V=_)01)XUcOe8
zpZ1UT563A3YU%)B>Js_(Zn<v{;P)u8B79mu2iSiD{!s@wpHv_Hya2v_`}=14M*QZy
zS^RH)msa%809Sn<-f;l-UjV@UTmDY|59ZCm4p)RkyE0&r_t7_{&8{%+omsXm?qin&
z|M(vv>(ZIW4z%@(3#Jllb(W~cixHHrw3Vv9RdT>1{^V-SH>;IMh3G0JKIiYNKO1M~
z6boX^{0Ml$g+Jqa=lee9js9|z<Zh()Kw!4{%LES9j-R!A#sVaY*2{d%(m9ew;TzqU
z7wwsp0WYN7AxpLJa0-X$`Y7q!AVv_nF*GE@Lebs7G7kCaMM<9Ou=>vG*9VmGw%X95
z602FJ!7$kz(f7#n?<LJAN7>0|N1xo$w7H1_Bc*uGX<4u1IQ8YL(_Krg&KAp;^cTO@
zcLJ3VnoV_n$~6F>d%VyyTbl^532i!mQLBF0adl#8qsRdy%ej_F!k@57HoYTHvFSF)
z0YmWZbU`gfY89f$sGj_c#<vnnKlme7;5rLCY{`3Bo+m}Z2mYoSs%Xx%GO@4Y{>~pi
zq@-B?L|m%tS*~2(!NCdX=mSOiz?Nj_Zq7r|hQkr42qUN$;&l4@Tbi3dp}u=4=2n0(
zK6_U0dI3wp(DiVejh`ly@>S2fAjQ{6d73IIGQUC40FPkBwR3c)J2Ja$R6N3tkN$5v
zJXwR6-%kS{SM9JBza(=>GAw!%^5ry^?O+fvZ*DAvvwmZ<(06D*it=g}p7M&R3T4XU
zkW22XT8ATqT*kfS_PQeO(^;~Qv(jlIXVxql>+e>(>ZA7fus2z42l_Z9HiAQR74Ae!
zKXax1D8Q*gt$JA}W2*QaJkmsp@0?c0T*FukdeA2Lu}5j&#z$BjuV8`aSaKQYo~|7k
zf(A;qvl@HPKOQIW&mqWhNY`;K4|WKIgT4a{BB_=|<TIr4Zwz|T>C4n=58A}nCp1ol
zn&}0HKljCQA73;9TFafG(yK9sZQS9AsEWd6XEl!=W=s4)mf(&MpDUsVtoy6wpArAL
zR0|X$$8!!q51w(dDbywnEc)f~;09K~_uGs99j5;qg+6}Y5wFCAPmfG=0l*W@8xIzD
z2&O`m0oyWMNygUCUR|lNx>!!l6&35TvAM+M)>~=Da^Nx_-Yj>3^T6qcD!I>Ok%!h>
z<Kem4)025;9B?zQX9Vi4@IqdYV1lI!h`3&V#cyxMmlUQNZ=VAs$zWYbTvgRo?;z27
zX<tR}f!vj>D;A(fMq3)+0Vpl4XjzGZ86%=4j#7g;cd(mPI?91o8j#$xfyM&GYCGwG
z*Ykm%*R^!MW`wE1{*g`}89QNp8bN`E%Okz5L}U+HTyBYn7?u@2s4}+9v_^HI4&eH7
zex9wkv9Eu=gZ!F3yjEBV*cs7<LQh68l$el*A32=Te~hKPdX{$?i5y_^<6YFYEJQZZ
zWH?=z;kqvNjeAqWnUwQQR9tixi%3tVp19l?%!pbXUBt>U#9mT{A}!;~G0=Cq^tT%+
za4_sZix%<U_V>y=y++r(r}&!Bqt9KWVaf&f6Gz5dUn;0et<Bd1YTM`#2M}*x)|BcT
zK(>JD(K<J$aa_BnJ%(*enGy?Nkld(uDp-*VO5Fb5V)h%uR2iDF4f~xO@wLhFDZJiM
zYqJQo+Z{k>WC0`KW(TnL+a><(^IQ@rTJUtaw#QHMJ>qZ4<py@4wovoGJ*o2Us>6$c
z%SLzn_z%g+qI8plBMPcc(lSZ>3Xle&Xb#Mi5Xp5P={(t6dMN!q!6^Iw^v%t$E8bSK
zU-*kwjuDZg<dg_|@qT9#T{(V6i<o|Daus5>2etS9dz+^E!_h*nC`}1Q^}a9Z*t(?`
zsYebRmU_cQ7%BLlAC?9JS5NfkdY8nu=C#>0Z?#0UO`PMzPw<d>s2G~IZARq5tE~IN
zqxDSa(fV-qdX*tk=y=5;ZTQ@?Xnlm`(bJ7jOv;xr2dR2SNLN4B?n|0OXF(VahL_G)
zTY!LnxTlPMWMH7ukP(xe482U^Ceu>zdNcHvBy?O4U-=5b^~QR3^D3-IGVA!LLU!5U
z(QUC&zcuc<d~Lg(Jn}b(76b92uCiZ5&(f|1`S7E5!ebqgy|cA~xVtg)e4K-(v>ZS)
zt6;R{>bibPO*D%5gZQOS_C&dK!Lc1j7;&4j7<}C{iBVtWj4KpIpRHbc(~3Bhh_tE8
zyR!<a{pfy{`oUVi?@?bM^i_FwJfR$pXN<MS^l1Wwc9Ila%L|Dl&vt1||G^Pk-e2M!
zFDmNIufpmG&ZUCHoSBK6voquIHG>rvG3L~5jfu_5M{4LnJ8Kw1ddE3IRq_i`Dz<uI
ztnduX9%uYOYR#Z03)IgNoPj5qvxVRZgG;A-l6nm>+A~QAy{!36JN|4Kr#qxDSn|FP
zY}KE<6KEFF`PZ(N;yu=2S16~AWuaz#i19*3063>Dlwhmfe0ci4m#OiUgOmZ#U*~dI
z4GT8+$!+P=roU%p>`AjH2cc~Wla;SGp<3(A=Q<Tm>gvDm4wYOTN=q~K2a~5rIJtiz
z;|q4AZ!Jk~#7Mk#xaWOfOd;|(LEG1RzIKP4RWlSmWi2R&KSohoj=;U5h)(Ju10BVC
z;myslWV4<_;n$Y+`xU*OScS<AUi?f$gegu7xT5dPtA}uY&DKisyh>BwFz4aktO?(M
z?zJ&;rAloI*bAVLQ<)e}mEsGNQmfx>2jm~x^KWFFHSRNNo*ljV5UaLyce}DQgCAx9
zXG8}t`|P^TF<QLhXcIFn{KP_*K{r|f2m?QE>nKKLxHR4FKHgYiOJn~4j&>D;A5O|@
zac+$-hz1C>tlY2nD?ljFDinV;LMBz)?U*QM7|<q_`<Hm9A-31I3t1ZkghGNdlQ70`
zWn7NAWcTOumsS3oCBq8Z)EAVFv8u`{vn*Bc$A9x2r$`_<e{q9f-nMt|f_ECL-`jWj
z$X9kJOzRCz{AfPkZOxv-bq1s@!P{@$zKlX_sTJ3eb~+d_`_2~!9c2t7E)n_s>geg<
zEP|i{3PrbGOFUo6Te%fjU)x1)@YNiGT>gsQEcQs-<KdFzygIMmfjPK}E!yH_Om~os
z`^8Wu*gig?YR>+Xv8jNx2%B4a?L``u7__vz+t9@?zDrHkoL5Fpd-U~2LofeKPggn^
zwcqy)PNsSr==Zmj9SDj5=C*{VM<-QFdY-;ads)^zm}n+KsFeW`Y2rXgT!3r~fl7Ia
z9qDN>&p_Thvt>zn)u716Q1$1KSovYgjSn-ITfsR;>*TdXyNm8v3wCqBaR86@=X(~|
zwoA!VE*HVxX{ef{!=z+S@=v(nN>woLJkpYY0Jx_$UCO0l_}x`@sbP1P5<K5}uHWx)
zFOL;KzYJiw9^7Rp^hyPb-DOo<aPYlZvRcNi|NP%^AjGHrb-fUu(!40@KLrG3d3;f&
zn=a!0HfI<ZQc^wQdjYEoM1yns&az>f-!<E_=W9$!8IAnS;ffaIP0BZ!x1PJn*Au`b
zj<CV|lLWfWGgCb6MMz6YRw{NkMux0^A@OM%U4gFLITzpbj%TIOTVceCk>0Jga8qnf
zcnVKSB$f4dFveud0D$bakt?1D00kXfQ5BR_%oqs?;Xa(#B1@H2<yIiv$pX351|(Gs
z$~UL}gq!sr?tY5+7HOd$&$klCqwEdRd%+D2FsM5;9y`?O#0-qZvVD`|F*EnaO#~hk
zs_STRGo>6cf&Z{a6+A3}Wu>|+2V)TcO7m3`X`>nkGw<I24frv%cZ&?6JP<Ecb9AE4
zS~wW+a=2dk@^a?eAD-IQ*iNII9fO)nLl=4_R+dJ+;m>yG2+fQq^B_`yBU}D4r0MrE
zcuKdH`l420TliU$Q2zL7HnJnhtm1iV+MYw(^l8^q#AoJD;iFE_+(}nzc6m`>P8X`Z
zeOvbU*@q|STk=ua;U~+Q^$t*=vvggJ4DzlMxl*jC=ft(;Mq^pg?@}E-3X+X}xyfWX
zSCCZYSlW{Re0o4qArK?UrV9I_>pzZtr_%uDN&pUxG7Eq&a6d($ML?LAwwr9YF))dK
ztc&l+**@tQ%k4WC43GODx&MgTT$O^n!7$F#Mxn=9EoMBtMW_Eb-^{hXs1AHPVn6#k
z+0B%}N<}14G+uY)Eh<3KhYi)evP-l6V?<3z()<cYq}sdGj(6FumpV(1n@6FigX}3Y
zCST1)+qqn(LCuxgs7C0E=sduBpXrj0kj8nWPujq8U@1xSR5(q@-x9bcVrh@ujn}_q
zaDQx@%JeW+63*>Lf|X(m?1rr%Oxwc#8f@VmJTk(@lq6jizmUkM#haRp28Rf1E_K_3
zEner_<-jJE))As4`xn3dHhc)o{KsnwV4w}3?zX5$;}!E*wFgjfi6Ek|uZCp`v_bI$
z3EDYt2Z;s%#)!sT7kz4?5PggGfA#Zb3L7PXoBr8*x|WpF&{p0b$5MiLT?H8I(IGvb
zYpi`Y=oXQh6t@YDc%NCw7_K?Vfvx>Hu<?I8b1A)LFziiC;gMI%Bh&q?UwbA^MfubA
zp7G^?Zf!8qCk?qB$tcu*5Z(Eh%Kc8td9hxh+TMX%#XXDp?m-0`x_4ih#vIxGwEu}|
zb=%JCkND3$Y>tgP`X}Op^<B_~5kW=Xo+k)md>w7N(nyBWvm`R$YwOqHU+F@-|4(RV
z$8If~52XjA84(&`?uK=}#fR(*i8jZI_GwYDs@pS#RXLmWFJ*$(Gz}~DxBsXFp~<}A
zUr>T_WUgZ;PVDSLFCgJ9j=h4kqD)COsHQ&z9GAf%thy_l7@gS~r?2_^h(Olvy@iR6
zE#38;KIYI_j-v?1vhcx0J2`ThuFS?<L&NYeWEeHgzv0IV4Cn1<@S7!nQITby?1tS6
zTnP#X>PKxYROkQJLlUPC_s!>WkdhI~)wNhNPO$#DaOgBdIxlCC&~RFoHab5fM!yuB
zE^=;RL>H#Ho(uhD<aqvL-(f%o)2~d{%=>SomfX)@O!%0B8}q}Ccs+-}*+~$v1c#!$
zM-=f3wKM3l(X5!Iy%GvB32{PbaC!Q23pzzg_7G0X0-Nb;PwD+}l%&E*pr{gMh6MM}
z`nu(><N7Ki;iokgcQ2mSC^S-;X45SBk9YIpcf9)=yc22NF9loc7}jga*PLQRL{7-Y
z5&UK@;jg@eMJrk4?FmOcE#i<Bcbb`6Shr{sA2z3IVs&2Jqs@bdJ+5lSO_RaP%<Yq0
z@pE6uNqBHv<+FazT+SQ?r;pi5R)pzgY$M#}!By{qcd>VM>~APz{ix&|jCIn_o-(wK
zc|D&|G)N|xULFJdyfc?HfEw|A)OGz~i~%!}JdqlMx|hHR_$_4aeHr#J`B?qDpo!VG
zQ2S&1#L~OU+HY_uYB=wVuzL3OUZc=!Git<N*iFlT(}NZC_>!@G>}O)_s>+AE%-aeZ
zTkAxaRV+{y4fOQkrAXTK!H2P6U%Dc$02}EmwZXESk@q5`>E55em5xos?3t7itkPoU
zqFuc0VRp^u%PvQRh~*tql!tsacBi#fdjuBn7XNEQDh-lO?nCe*bv5IX4$9yGV>}7N
zGw*ZB=x$#qsLD?SJP*UGqVuoN?VZ8|(@(JfKx#`lo-EfUlD<J&(w1>9;`Zpqntgix
z53uFA=pyAa(~>s`A`GoWt=$2I)+KX)_Z36%Xx6y={lgU%yeq<0!;|&BL|#5Q-_yL)
zjIQON?XY=3VC}l<fjGR$&Ik=0^yMv)EM_E{$@uTz0|a-wzgk=J%Axv&<pd+dB2<Mw
zPdLdb=?=>LgvDlj+)!3p;H-!%Pzb1)jT2Cq1)^fA`+sk<UKwiMO3aLeb&eytFDiw^
zgB!8E$}&&T5f&%U@zhkEmr&$;C&Q)B5)jess`9i@`Qh&sCdh4g){feqweO~F%$fuJ
z3nm#4uoe<BvwmN@&p!UJ;ni=~GVkaQYL6mRA_GCAS$oR&%0v(s2p4+Y4iO0(jZfuL
zi$ftuvagvd{>k(+Z*)Lt{XCR*W5P_){&09VhPv9Vv%Sr_;SVbfS$d=h!ts6}n9tFJ
zN=hC<6st0%PC(o5#WHi1{ZLQOZ7|a<;H#Cg4uf_OSE_HHamvFH;%l<|xJEkeAeH45
z4u1yg8FYbUX|v`t6pkCr<%E;?M|v{lecbcK9}QW6)nb+X@#ssa>PZC3QO_Gf-CZxW
z&xQeUZfT#97DcnqpG>EWk6|l&hh@9MWSio?t3cP0^wGAm&05y|8!qq!hX_e--Q<ec
zhiQ8~2$8)C!aN#d_6uP|)cvoB?xILlFrdyiH8>B0nd91Ab7wLwiRv>#a2$b4eKkH#
zXkr~Y+T-hbmw_r&58V}Wdf&Ss-Wj>YICLMVjL31$Wbt$UE#f%h(vR7}<kcdi9!Y*{
zy2&mL%oV&bPeUCG=a+V8RG^SHvP1NQCLP9z854ccV|@_r8_qy-ZZYH*O{XlJp`A0F
z9@l@j=a5f{C+xr+X+eJ<fDbsZwDajd0vypw`<kv=<qwImIynDk^@l5NAmX51>}=<f
z!(6aSi4ZR0cI_wIhBR3T^Nk51ts(*i3u3Thxj;xAzM1bj=3Z}W8z_K93?^04U9fmY
z)hjWK#s)d7+6dy5Rhk9j9vu4xlac=EU$!CMj|B%icj*6zXlq3^a>p76Wcm1j1y6P)
z*C9prQp^-L=K<Hcnbx{-_tIJ3t!C5Xyte;1=WD!|^qZO%m_Hue$8>{?&t>uhf4vC|
zfv4t~W{hP#!Gwr96UID1+zgHPjUZ+=OZNhctUGpAQUPEdYO>VHr*P%ddRdJ6SMwY1
zF4V=IZr@-8LBim$)2$Rr@bYJxWNa9Son}c)BgfU5g?{5jSUrZ3^AsKy2^QAh{$0e*
zT%hR$*qo&2jU#~)&LDST^9!7jg1B_|aiu5sMC8!);6AzYV+5hMshQ#%*0Tf51UVL9
zVK=lh>`*8T_UJ^jiv;>1<*e=PfzzDm;xpyp(*R4aV3^qE+$*oEYQYg(`uR-kR`@B=
zD~%GK<fDmH4#k}tFA7yJ*>o|S?m(34pYg99I=<aT*2SD=`1Fk`IT+|lIV_f)nkcS{
zr9xFJxv>BrD---A6NCSs;XmIoiqJ>!g0Qg+P^B@kYJW$()ef!~Jc=mH4uHyvt&{Vl
z7Jd9B1WoetX<#u-uBu13c%jdq`S6&LNk<FJkBS3tyrjKNJNa&LcEdL0v00lNv*eNZ
zNR7C{Iohd81zWVxh6mT=EZ2=MWY}baCirO?hbnvlIQW!(zqA7VE-25Z&3-IM>o#Yq
zhtfnys}LbADLQf0HXpv{jS0K9d`#K4d(KU$58s1$8V2bSM-4Gj@Iw@@{F7(8=SOWi
z_7B?Yhn4}knE{22&Z7Hqy{gv<hy(u-d{OVbS8X$gl~1>t(nm5i&Zj5s70F2q#8>pS
zp%!70oh8rcHF{-z6o&$;MRih@=z_tz82yqII&ZNjaek2=5smDZ{FdZEtWV{Wf^05J
z8r<IS$R|Qnb9D=M2J62#(6oa+Uux2%9j!lLTs<6IFAKka;BjqndkiN`A1<;5<@gIV
z4~(}u9(+~2A>{o@5S6Xm1i3Kgw1=RV^DH!i_r&iEhgkYFHTky&<ApN9knp$?z3KS<
zu*;NPmL+8wM&*_z1Y*Hwl3P@Q_wp+vN~5iThOy5}a(gli#)h}xz+vdHXbrkf9BCJy
z2Nmr$i1kr5ts<?{DZjN7!%L0;7K{1sCYV<;(}AVT>iM8h5T7p7*1|%7!RL%Ym#jat
z@;=+Hgd2oU(NU8(avqDx#E922)IrP@Xl6a3usoklmAytrxX<dS#$uRZ&o?Ht1!~6M
z2s!zulxLo0?>OSc*Q>Z!<G(A0SV;w|Ca5WT0<#6dDw0k$Jw|HMM2oj+p4KR2rq(4a
zVy%CV=<@Q5#nHQyettOzOX%_17PkXWtI}!CVOiu!_}w(@aZP{L@Y|ipDEAAEjF)ta
z*=25%r_kN7Vesrb^S{G8PGyzP1@9@H;44LG1?0u)ccpc5^fTJCRgTU171Va^2>R$<
zDv46NQrWANzi%Y4URC4|8okj*@hM7r(Ib;ycx`QN#%a@%0+IC7-j4I5_mjrEFmbrH
z#j`C<!J(7)O0{bsv)9o$!wCu268FiiP+QSa3lma{uQo2yr9Q4*+nanzm8h&8L3$+5
z|2n8JhO-uEtzrCOAw`E_>W}H>=A#9oT;D!`3}7}n`QX9mw3Gxpcmzo=)De{xwj7af
z59k2D8g9rgFA|r_Pz&n*^YE{>tQFgW%1UvbisN5_oU>jsX#v5JvK@I?pGBY5Fdldl
zi5-lgUm@?GWVhklBFr4<8|xH;Qz&CkU$J3)A&tKGAe0Xn%?^Yff@H-?>9KSRT1#B3
zI8}w<0(u6;i>DPya!|S0)+0Bj{3UQkU&9_;P5s=rAxM@Om%nYu!cL=@)^RctK*dw?
z4tY8ZlDf|*&NAIQ!_Wa50rpmF!xb}9_%5->77aW9Iz5VDvfs#$X|T$9pTvUcrlHJ@
zuIjsfUZ*uqoX}QEU<n(H9BC@+%yE7iLWPJsKcN=0eLbLPoLtAJ4Q483NvPIG`B7*t
zVfWm``yQ>MG_$Df7LDH9vmcApy(NlvB%DS;N#j_L`I2_<#)qAbO195g(VTy}A^gUG
zQHI6DgnKK&OeuzBPG)*`kMve|*uZi)gtpEU7ioJ^JT_K;n(7n8T;JuI*bB5D6&(uk
zhEHoXgYD0om93CiAT9EQ-HAghF>>)bdZHw^K^hPfl&jCwJuBl*WSR75MEQR2G{t7@
zg3qmgocT)-Ik#SXt`n(n&SNK^#r!G8Hg_E)pkGCtj^44+(B-3Dhra%vOjK3A#eUT;
zGoKNzoM%2$>vdd=I4oQ@3+8-Hq7%?(mm!x4JmP!)H81Djy5hy7$L|($`;3p|&Z?ae
zg0A3T983DmZq|`;*jdiEQdH2EvJ>M>qa8T>V%fSF{Th|`XF%?N#%#}e#jTH7_~qi?
zW>|<mM1j}pY|!f;qUB5W()?58h#4dcnfv0$5%tj>btvlEk44kMK$*+IiG4Lcfufg?
z;lRe)qt&<}27ze`huCefce%K{ugO<@du2>lN+Th04iL6xfe49wg|{$Rv_F@^moMG1
zt>f`#La8IL*>Rtk4x~b-Fqg4`HlZvFLaY&nbvC9WP@y2dPBkq1b9n|x?t&(DuZJqw
zp06qSCsxeUxGQ%R&ze87Gw6G@DoV_TJ&s{2h`D&r!lQYk**bUd)+rgk;k%W7LT`KO
zCyj;WPqtmazw>81g}!d44bif3w%xQ-$@=?y1VTgeg1PG5V?;^7qgb+1oJZx?*uY!0
z%q(Yn$I-R)2-<h&3fKVAm^eY}QtgQ%&l?`-`U0Wg=z~qsOI?#E((AE{lcIA}e&(X9
ziIo3{z2Nwh)IMQzN{gTQkO*N4sFwT!ceLKQnK@Id*@x0o!wx!!Gv$xYaf*1+Hpkxr
zMTTMv?f-a0I16U!M@n%7o_G#of6_@|JQwa~HZA|U52m3gqL>}Jxr4xfAw`F4-0DK2
zkp&$7=-<0<qIqVP#E{68y%ULjp3DrZU;!mjLQ!$?cQ#boYIP?I2GMx-@b=O&45N((
zqT!f)s7Ch|@&N*SB+Emw*kk*QeWOW*FbAA6ZfQ}g{CGo(S&Cjd&d!Liwd~`qB^Gl*
zjz4<kcfpD#)?X3^1fBN2z0&oq5#ASczt8h*XOJxD8Nziy*5M{=h;epTAR*y`{I=?P
zuqTyna#vCKYaoB*9Dd$lQ3x2rerb2&MIY9e!zg=sQG*X>o6G*t@LyaG6h6x=m=%5e
z>Rlr4Ae#dcBU;pIF8+Z{{PJyYKTb92V?UMXn+po&qONh)MDs>&jC_Z9T$9HN@cclG
z=t_Q7^YN}sp}+Pj1mw7wK_G0cGUN}_?wycn6D3hHkHl69Zh#<MbaA&kPqjK7Jvl*@
zcD#tzxtP`krgU|5mfkOPQ<1(SzMaQ-YyuMpZKo!+LwYgxoSK>PTY0tBJ+11qUFOJw
z`91m*ZzjNV&}4r_WAv})Yb41&`kef;U_?9#OkGf_g*Fc>gAcAa@7QEFi;V4sMN?Vs
zf`2oE$=dTXv`xWoN8KoAcr^RF^h(OrDsjniTzs)j!dF_BwJ|O;0^2-7f>0j72sIqZ
zwlBY)N5j4m7RW?GAA>t~uc}TMjF+s47F*)HuWW|zWiW7i#kTk+T9G?teKVV}HJg_p
zYxbx;<8jsT^6akb$0Q14QEvmMVz@RtexNk<r`;zCQZ)(f1E=W)B*Z}cECHP_f=Osl
zG%5c5H^T>`(z_v<oQxxYF-^M9gF~=BI^W=Pa`{>q(oDDp6;a*4Rr+xvcMEL(Et(~g
z1sUO0XIvliF-5@#%Q9ZQsNBmmvVoa}H{P*e$UOV*w@$JCYao)5DF8mLBzFS5%DR99
zU;ozf>TX9#*7z34#FJ?BccIBf*`Wm`l@yCCu%!r2)`tdO{6LuI%>|>O94OcdHzNOp
zYCPS&+6L2SBMJ`01zpE|AwN@b;FQ(;TQK$mU9<4awG{HVI2fLN$%FnT5Rld<^+sYU
zYF+E;`xvgEh3w9-FX6P9tJy#zTvY_8q$Qg02SvB;(H1-Z7h(_Ph<`{ocRp2^r{YnM
zVP_)>8doe3Y`Uw+a&Xe1A1Or79Knp8Bj10VO>7Pux)_8f@{4@`AqawvYrdI}$62{?
zkOhwLokJzVNx}bdms`<U0|C*y%>5WDCpg3NHhwJzFFYRZ1asNh7jpUqyfpE=;v}k!
zYZ$js8^I|2t2e2Q%@2VKFPuT#y$SJh3^OPU*PRsUS83c#Bfy<@zD1qkj2}?r%}zZG
zwee<jg^H6#Gt{RG#d)hz;w}yKb2b~+ilM#*(=U=6=`h9mo-k-m99GYAA-@XK-3Lki
zB<88%_t%6~X~T8CGOT}DiW1E^v%y&{yrf6iq5zw0CGvhZ{)QH8;$_<k=_!KuQA9qP
zmZ^b%tDH=93-g(I8h;>_39D27Be!@Z)N+aTBB4w@<r6fiLS^t)HGG4n98{aQ=&@$Y
z_a}%M3yl@bV4CHl-HiE`1)-fUjfCaTH>Sk)@FjIsRwC?Ikzc~w*RR$ppW3ySQE4ms
z7)NH5vV{H}s;^u)$`z8WpRP1xAx1Nanj+=oRMrkTRndqVAJkPv(wkKCLVTjwAiM~V
zbpWE{(Xj9oRVuIMR}Ct1dflg*lub9?8Fia0=O)hye$7KWFs?<VV#dF#7KgKG%Y&~Y
zq!99N3ixBgh*Ea?6LnHLp9k!(fneR{0;LN$SSFP-m=P{ff@$@1_;;tG1IjtS>Bn%Q
zb4aC+I`)aI3-7GYW^bI|0^Fl+Fbw3WQkD{vz9{1pL;0Jn(ll3c{*vcmt))rgA*8zA
zQ`utZs^u}NyU%<!J3aU1$j!p#QE{8O@sU7xz6HF7g=A=bo|Ra6G@oHQm;Ub{a&OE}
zyi4V{a{MSSUs52L^_Y4J#=x{FOQmOc9n;hUQ-d8TSvch1dT}nd7|^d(>VBXz9b0l-
z{O!Kuf&i#0TI8sli1FO(IjO!FAvn+mV^N_sb}7v^e}DruBx<uPHIP*Dn!=z08>MN9
z8T{$>0+>Z&oB>k-sP!yytfUs{t5L$b_6^Axo&yIgsJKLHHV_l#jT_`sXNM<rMA$au
z=Mczj*(+a%i~okiMH$qP=G9-lFZU3L9gmCeYf1kyt~P0o520(~PiK!R?<PZ(R>FZd
zRGbQE$w}BOv(@lvjOR3RJdZdSs;wk4Xki{qFiHV(y%tVick7`B(q>~XfRzZG?(O10
z6*?CVYR*P#sB)}X2YW=;k<3|yfoukWhcx>)&yo4}3VuD4B)&f3pUw0yc0Vj5;!caQ
zV>lAwqG>>@0Is0Y%fB_X3Kv~wt+wxWchdFMUa){0t|Z4BxAP2kLZ)qVXuv?!Ttu5S
zexs)=h^ZnS^4UJ3X7}5hw-I|-rC~<0b&JgmK}9;$pdS+_YIUKU3EIvy4_y-4J_o!N
zqCe#geYYN&fpy6c?v~B(S;BN`tV{Bw&5wR9BvcV2e2`kRs2|dOy>NqlusFz5V}!C&
zZ;XS(m*=l9!SQ}uANG;7ve7DmV1i1A{AWCq(C68<ULY=JGR_)dm`&Ari)f>z>^{$9
z)6Q&#0X;0`9V2SzQE9u-V&!BooHRi$7gn-8O!LtJK8-qOJ*ZUq&x(7t$or6Pds32t
z>JveDy7I{mXWu69Ou^EgAw&?*KQ-dBE5nSL+o-&__K+DZ*WZ}qIO9-lU}T=DPN-(8
zhfG*YJV+=k=XkP`e+qnKF+zut-V`4Mbb%Pn7bMRKk}hgMHD?>QE?tPWuOhelpU9<)
z+T=@K`FkHy%t(?0ADlt{jT&p*#-F9P5uo0N=AQ}rZmIlavh;ZYJl^llvl5{(>jiJQ
zF78Y(5q04njo4X`m#%tMi#Z!Ap)gA0<CN*dl|~{+F~B&q2rRY^oLUmCgd%*dQa>?p
z83Qv8OW%{&SiZlfqL&AVBMMcj*}E_wnd`+zXi%1+wftB0D*De{<Ia4tr$Q&VFiS3o
zW$!=6K?}G2%+93LFI9Q_x&_8}&EHDt>MBQ|=pARLiyCZZVcY*G3Z{I+7O!#VL4NbA
z+5XInXV?CQpqCNMEKYir-X<JsKE^fH5QDvVJSSR$;WWS@h<%0z8(=E0Bl8AgCI+s;
zjiwbV=5SY~U;RV@8BvF|f1m~!+w=+MHk^UvS;G{%R?>BI!(Q4xN-fffHT@OPD1;y+
z=vvq&Y+7C%8EZaRckQo{=PM%m-pc6QyI$M3B!y7W<hv2Yd`WL<G%R$fIn~P+QtI+#
zl;ztx_0MTlc_zf<r6)y8LszaW<9Ge)0HWpRc)ey|F?Fehu`@`eZ@UW!{TuD$6CBTI
z_V>iJVa}xh(Rt9Zk1d#Es1$0gBbx1QGutm=E{IZ`tP@M`P9kD6IgF?~4)x5`q60n%
zOZS51n;sUtR27l?;t9~#w$70Is|(j|+==LCe=<*P+yUaxVxJb#5x(PlWijF5yb0+?
zY61YC!e+cGNz3~Nryq<E(x3!MNmyc$DzIMCvZ5AR&P9JOXv8K`(2Ir)D<r6F2sAWK
zppcCt71V~nOhZr?qe*O_)-S{Wd9VM;Y7Phq5LIZc=*fmK%upLP{1ts+OZGX~@DF7&
z`bc_Q=~cd}fqHG%$0}Z3AJdVR!S6+9cIbgPZd~o4TTN(xg3aNN%S`*3n7VgvRIDd8
z%Z6;Az)-mErn;mVp10w?GDL_<!R&e@7qgE1&N*3Y$Z0SoH?PtCcRzRBlL{u*rYlp#
z5l@?@DXOfHHa|m7uUsoj<zWDVPux;u2OSzUvh0&8O!mbFv439HE?Kh3AI6JKxbe|C
zlURsh@qnt7i913^C&L3~LkHtWo(y^4D?;gXjAq6GI0jSrjQI0i=COuE#1d=#qQSvm
zF%T5Cz0Z+*3XsA4VhxtFh%~_VPUI?4Iwn-)*B$^sHn>W1_$0f5M!Ue{h^>+wae^y1
zFYz8<1c4b8!@kmE*H!HGuCn#CB?4c94oOUf)vU_S>1;T_Ey+YnyJWx#%KqLA6;oD;
ztTP<Y7ddI`)MOl9M>k5eAR=_yFt0tL<WQ8irZ(~RyPQ#b7trsHHz)PqoZXD@9D~Lv
zK=eBoEtDHh#S4!|KE%@(Bj2FB-l()#P1F`g>gWwE=qWSEqj`2M-+*dx0BwfOgfFrq
ze0uF%y-sqcug-WL{3)XZ0s>ts=hk83c}BJUmmAH^#)o{F^BIi0$<a`A%-N=RK;XL^
z1VYTBy;&#iu!Lhjj<e3)@>9LIxlpvlF%A*7DB>CTRf-}I-PMdWirtAH=OacxA`I<$
zK=rqq_g&Xy$NWibOn_Or>z6$8w8YlR?xBzbvitUmIk0~5tm{33;Skyu+@Xy+LJzfc
z^fy}1ipBCMgOnmrP(?pb0M)&VBVY<F2tcBnb9phI$ELj#6b!Wjq@zP~%G(U+agvSf
z2TBo^xzJ(2ANGEPZzPyOCxwV3ub0HKCK2K4z8bQC0|jIyy+{}?mzw*Fk_7dDrud&u
zLC-%>Z^x0?2#>;0k8F?Ae4ABUAW9oA{$l(ZZWtk(*576n;(q5}e(>^~<r%+a;mf6D
zOoiww*e&@URzq}eW>QD~4ya82wgA_jF+lke41o*f=TN^gZD@<8sX?^_e3r%0F4(6Z
zYrQ#*sO9h?T8l|y771o-i<b89I-_>XYzHXxjh{zmv>FoEY}3}H#QgDzh(Y-=3UQ(K
z!2tg|tiMeHra}F$@XYP6Zj2{_+at-t+ZW6c$(p^K{q>0&Bf9jEa!eqdMm`5#0{_NU
zxsn%D@+XvBk`yW0b>$01<-N;)9TH|Nd;cu(X{S2Hr)|^1_g4IbiH(2yczDHfQx&b8
zmFp@me*e~3CzXm*J{9u5>Koq*4z%tfU*~30*e_{{sEK6gkM;Ou7MNXmgAw-HBY6D}
zw`~W98J@|e_~mkeG+o#SJ$eR;V5eq+y0wlLbRGZjeI3bjmn_Vq=GA8G!!;{9ole8C
zS2kDY>%p{=B|5=BnYTQyF~2eOEo&*knP6j{#h{Dlu|1Tj2Nqvy!*W3%Bw*y#Gq}YC
zOqepmB%kWFN;l8Y?#GrzlD$b4<YLGXEL;q_O-%8%=TXZ=74k7Y1|iBmN-o;Mf0xGc
z=B>4*RaJK|`$@Zm?gHh}aw4%B`F4FuC)HZ0V#?bjuCx{!235Lg1OP!OT=<d9AxZ%i
zdn<~)YptM<to>Lqzug&YSC!wW@{G9(EtempPSJxA7^KAjz5Gqi0nNH7oHxd-xb?61
zng2)`<D!KY)QtQ3$?Rfi^`k={dd=u#!A%$+9&EplUy7{%i=xV|1r{uecAI7>(KH1)
z@(f%W!wl&Nuw)+N5a<-{2)Xt2ntre;K;@93D-a-?oNS1quF4+OuBf%u?PP|&T>qoP
zerA2*DZ`0Ki9tT8R1_ZFMZtlzg>oJh#mbT0BK|a}q9>WCPJb!@L^Qx{8`cTnXhiFu
z$EuUcjD}~o9BwUBY)8}27a^}!yIG3Oz}cEBlRrwM&Bw)P3*gM`w29vS3C9$mW*N^~
zR5RM>u(LRPKS4JaMf$ye*-vl*r|ZoLIIV;~vO_rf%$_I{|L}U-1&g;_D+!cA0gkPN
z^0pns@f9LDMb9j#@&nqON-9c<B_O%ZFsQg?4BHl&nHh`b^yK8>2QUcp^)5F-2f!jm
z=v7lhL_D5arGDuAH9vYoJF%x-1_FMAWA&ew8YUsAf*`+<hJQIpQu3QQag5yFshA8_
zl^?@AVK7zuJHebnL9y?ir)RcP^UcW-LCwS1^Y1rBSWL~{<Ikb^`3cuvF}4kzwSo*5
zFxtva2E{HOc!jU)w3NJV%E~XoUNod7!PoO^+_bi*qg>s8SqzMenXSzx<?E47t@fS^
z{w^{eFUD=J;R5UY;62oawMweXnG|MQq{)XWy-{=!vwXdKg2>Nx;F*P>ro((CZgJg_
zp^WgS-@wr26;=#FxNuO1Y>%&;rKm0Eu<rgTFCXplD*qKpIUBEZGeYr3wND{(4(?g<
z<;}D8VfwOSyX5T4EA5?Ar>|0x$?tyK1?M)y(C$0F>_wpksN6WRCmD|(xMyS?LSO(D
zA>oS7kGoumvilUFfqyBgfCLUby89pwaj+eb+O!Dd>feFcfiM!@6oH1ZlM*9`gC>&H
zZR^R8@i?d{P)a<Ms_)rRY9W|uxqz2VNXm)p01#<uF8Pil0z%Z=PMx)>R0+7LBv2aT
zqYvchucFsamxwhlhRn3o4Iy2V;R1e4v+w+4YJgPv`x6XC3JyS;r`55L*luT-ggq<N
z8YGg#Pa~0U;+-~iR@c)L5QS>qK^YjppAD4`at*RA?ZSW%=t^8`#Zg*Ui^MrfG*@&n
ziX)FkC*6NHH3){r1W7>wCgOf)p-~iw9bqS|);TA?HN1h-7H$Ck&AVqo(o0+Tt?HD+
zWq7NfOcp+Y7*FREMJoD}U`t~CP<nqo;<#?lgy!24^}$0dM&>Wv?2;%h`X+1SDgzHz
zK99wBOJ<cDD$u-1TqQc%xd%x}RFJ6*mAiFS&$&xI-DA`VG05KXiJ*{JT9vhi_rPL#
zBURxrQ$z)0x-6m1dr~pj78VPU6{aEX0;(5$oJn3*CMV0ar*AL0#42sa6zRR{rdd=J
zysx$$MhC4UC@i;6{8F4aQW9K{V`LTeccMGJu(M?-{w~OG@*cPc%E#-<k%}sW@T4l#
zP#CkjadG9sGk{3zka0;blGj*t;VEjU#`Sl%eeJlD_46f%6PQ|`u$@*?Hgt1C+Va_|
z?Cwb;M{o$T<9b~Bx_RswEKOOb)b9LJhEHLBUK~q{&zLW61YL~}uZ?}#PWaFhkQ(@J
zbZ+RNTe}fZ8I#54sXR|5kY@w$2mYA~p<9c;{+5aV;S6i4zpfM3Nv+`Vd}&h3yPjEV
zmx?<=qWW_e@D9qUiEf<w?&Uz){poG$nF9*R;Y)B}vzV2Gkg<(&t<t4}h!!YuvN05S
zny2r0^+Sg)2aW9;&DeMaZjlV%=;+Po(pwe3pJgy6vVREqg%m~eRx{89sy3|O6*i%=
zzKn1M0Zu3U^z?5=qRGiyVe4k=mfPu4Pb$M@XHn!(;*V#F)N~pHH!76X8T;Js<13~z
zjkh?E;M&O4)U-a9btc-%c#rQh6MZx%a?2J#l-IArQU3NX4Scah4?Dg{pT6J3(O!Mx
ziQb4x@fwRUY_-mIoV;t;z?t?z*QO<psf&UP9V`7sWoqLVNFwhWvo-+J_l@k5y5iKw
zaaKGBJc6xq*3mN!-8Me0%*rDAlQCL~5s5WnUpr}biHYwj@WIn326M1NGAP=9-p!B+
zTHQoEvpaB}Xj(bVhf(}V&~Fu+d!UcttNC*x{_Pm8;lo0)J((@|u`OR5Uod`9_Te5i
z{A*nke88(WKGTEz8ld+QI5kF$x&BKNy}nx$U?@74;f`u;#nvQ2eKia689FaxD7sqA
z`f(o)c^<`kcnj<`jS)cS{%%t4Y`5Q?uVzNidNoQ-B<{P44#-?u8P(1KyuuXkeaVae
zYnPINZU2~ZUrKTP-k6>)5r-JJ>BP=wMMA$fF5OS&I4*rA!rA$qu@oi08;-%X81tUx
z66PVsft_1(;B)Q5(06;8<e=z)f;j)Sil*bpqB=@1Y9xr4csjdTn|mLPV0S$4s?^x`
z0Q}hjh%co#K$_^%MTEn~r&;Mo;MU)1sm9Vxei^FBa!7uEUYAErdHt(X12^erdNja`
z@aiR`xKPNaUARSkY9x(0iP};UI;d(-4S~Ha<={>@#5es)qxlk`nwHb?m%PM^a@grd
zouK+GqDmaY>9{ulc>)L5Y`gPnE$gP<*>hSynyAf`rADE(uZK-x)+d3!qPS1_ZHs3n
zfG}f={c{F3v7F4cGA=!{FHiMu#xcFStz^B*de!<zdZ9;=kxe@!(}r`9qXxH?5jK#1
zNas{!u>UuWZiY-5%y0mqAi>DEtq&xTP?crLY~$Ck5SdwhmrD}6ccTDx^w1JL(=Fow
zJzUjS-1LUrXwrt6=YS{uxjMH_4`K{(Lh|ru)ME_<UM`ljnkg2m2&bQ)L8HIxg7Q&-
zLHH22L;##25tk+fbtg>JVk;C}rd7>;kzZ3wX!D+o&^6+AYEhRsQl<O6TKmMieH~k>
zb(&BI*BIeX+{r=8w&{~tHT|G^qZ=gd0{&`2xq37%Vpw?qaSFoUGwh_^tWO8;xhRP<
zEtyP9kEr%)@kLB!4tpFUZqf4VMVmAGAZ|9Rq?PebL5*zOY^+W(-Vjqlz8~;7du_|h
z>Z^D4%n%cgZcNhSghbYe5ROlhdTutt{rtyh*6IpQ=!0@V1~NSSlS>+L=~+A6(%H?n
zY0KQ0^3h}yOTxvie^ZNki0hQQExr~bOIDfyad;EY&=O6x@B6a=HibZ=s@)Gp0ZO88
zi=Q4HsQ+a5FviNEmn6IMB?Pxw{#im%7S|!Xm9j4lt9y{ebKv~ENS#@XiqwKhMofgN
zRK<`z5sYyreR;~WOtLrMGZi(axL65_q6+yCry#{<@*u`yazI~B!0lO|_&>ESc8UM~
z8ODGtsK>4^cxVsLG?k0K;XSynZje1<b{O7k3%>vv@uACsF7vSt&ezs!=<&gDUJQ3N
zBGgsX{}K>6Ce9pnp=6oNF~JlwK@}U8Z#4qMgCH;IQ~@<xBfT|K!!#d)dl#t|F<!r?
zNi~5zMw<B~!4>|1_BHQ&WUd0|PkTwI0+n>wh|G6C4&f`-Qd&~_UpCF@;;~MtL+NMz
zl%F@q7aRI-Jf}_YdO8#Z3a{BDx&!$p@!Gx8)S|ydKFR(%TiV1}6j!C2NRJ8)uZPIf
zIob`CqF;^|ni5^*7sK133j|B>o;`1A(osJ*BoAbk&P4?Hakw*RJ`y~dMV|Y6TYlO5
zMm?Rt1x}D+XgA||{1?4yIKnp_T8Y_>Pd7MYhR9<Ao5?cQB%M@+aNu{mV3}w+;)7zp
znD?#&%6=c-*1WbRq4w3;pXk;C54o9cW~bC3z4*fVth?xaGpB0n<%@@51e*QKUECcf
zTYu$n*P0&*jY}w-SNPJspNbnbWisLKLJxn9p)7_=iLuQ0{??9^u`z?h$Fy4Zs%v<c
z%xNc4a`y$w-8ukib}hm!_ZiJG(D-5xL-gO<<q;Tm>FMmFj&Vx^_h+L!ol5H=Hl#Vu
zTQ{<J)U-f|e#LbL@{hc)Mu~Z?I2j|2TJ*_k2iEu$s&6b_ncESj#(Ac3eC0jhzzAw`
zao?x>%|-1+Ux%p=EYP&Im*(ms2$nDx?ay{6C0s)L+t3l(91{LMD*cn}P@IjJGB8!Q
ze_--DART>F7f`>)iL}TGP4AGNtx0KR5Q<qJw9LTC5@i9?S-k|=9QD)Rl+bqqlG?IS
z`Y8`-UfpvLs9hR<S6sn?iFjY{sZ7h`Q-(%zzuyfESAWdaKyF3<N@sO^WGg9x;M<X4
zlt?=0y_(M>LRT1wYX=&eF6G?IxtqHn_C2RR|6r+3``TTk%KTrVv&-ke$E=e?JS>di
zC}iWMh*v3*@*$l_FJnR|2j7n9?mwBww>$2`lSqF|wuq903<c)~wp!?M!ZsK<>Gv;x
z$}y5boRVFnhAg`7*1k)sm6WZ3lbmSbxqm@YhQPrnudu+K>|~N+A&(FDTac3}7H>Ur
z1dGYu;pDbT7f1iFPZ~YWzasTta$7u?xO@sb=~K#b`U@}DAM`grBP*npSmvc$a!8lZ
z_5R;grFe)gypmt~3XV(U(z&$HaBxod+moQvLb7HweO0v_>DttW3M_<{r8mo##LHND
zI<K3B!ngf+e}T3@6+vPwu>tzmQs$869L#&~xeGljB)?Lu{Y(yltw9B)JKqekC3;%9
zQJ}9ttQael6)*Ij6}jClOw}TyUSyJyWkvmT_*f#=sTEpCeWf*z`8Q4YP$!x6$>#e~
zLLd}Ha=W><@|UB|M#!LNho}jI%P#KVko9#TMd$!UZ+*X~>c^S2bIWh2xgwE){(wC?
zk^CJKy80yyU%fz?D)+%t-`^a9=K`GSn_s;QI3bWu8+-kSGkX(r57w&twYrzCROrw{
zB>9E08TD>yDp5}8!tI8r5_FjV1u+oL@5Isw13Ki%!!{$WIb4@z(g?IenQ`0fmI1S<
z6=+tsal|a_9)$zHlBJhx9@BtwW`ieM3r-cISUAk5!5j)=P(g)S?>1j_2V!K;eQTo0
zyUEbhh&H9*XNA2k`6HPkX!CRVG(oOyOHzzD59mq=OIZ|ot}#7)HcPg-dGbx~=;Qp@
z$miX;#cSXHYEkSTbvQ!W@=iQ@5BmZiDrGtH$LO`1O~|jX_SaF$dh|t2fHFyV`S(^N
z%zlYZdL$^s^d4f;O2QBum;?V;M@!}#sMZ0LA9caxSg?Hagd4?ikS%CiRZ-f&Wqo%U
z!5SOM8V04f1&|k6@)2vi?VI(lg?yKjv1&J;O?@p-$XF(5T#4om6PleM5#k_&+TJF!
zMkfitc<!lZ5>7GHiBEKlg<UAn@qv~ViIn8N$1pCCVmlogE+|oIz!CkY2%Jy^{8_DM
z)HMALX7Dn-q55VI-!mzh{|Kd^n>_XHUs7%XCFo3SIl^91yll2UR5Xvs!n$|?jDLXT
zm{j?0C=bFsk<s@xAim)SVbHZ^4{sBUIn25%hvRgpq?89SBh&wt%s4`R`Zd7EZ2C%M
zLhhvNsr?ms;ujt5AeQ;Z#@c<^vz+?K>g5C|4}@U4P6dMcCUVwt`<#*$rkXa#MJp<T
zTD;D&t|nhR9f(vt<Mp9dseH86-H_uFdP%2q_>aBO)-)~}U)KApncEnmQ=-9p=)+X(
zlh;nP#KOhmakF7iuEV@t1w5VK?M#aN3CBa{COl+ppn=l}r^blVjn|0JJqWRu6^L4s
zoD#%N4+PRU(@9`98e&7|_KLPa-jQflPbD@dv7)#8Z3OtLHcr-EaGRLh+d9hn3A92x
zTp?PU-oMa!j?NzuuHg(wo`SFx<uMg6moRw25S?^12b;)L1x<@z;lXsN&jOuh1U}6)
z;*I%^ee|45#~iW`9;E4g|BZS(+Q1nS+5JNjZSKIei5^?}i85}pn#y#=Pa*_u>`Gso
zfG#11O<ORa>r7H2zos0t;I~!FyUVXWdLmD;FHi^Vh!ZbfoXdPgXXiP~JwXO1>(xru
zNVMEvKUM-44=g*g7)JqpmI`(w{zWhU?oMJgXSkRm*C$g@g4yr44~f+i{BDJl=Dsn0
z!~jr^nqkJ)g2H>s*EoXV&6FP2JTH3TnfMlfBQTkg^yms4E8h%e3M^{!bd1x2Flfbb
zLpgqE1DB`J_<9p&x2`UbZ%a1$?1IxaB>|sAU=YlXikw1H6a<OMpXWe!n{gS!!TAkA
zJ~Ocx)Z4(gsUY4W27w=CfaL1_$|f)_`%Qt{<PG)uHD(JzYS+FiEHPnic>j_*B0yzH
z5->-BbE8}{F`ZdK5U4kr$MoHrxBw^Y7Kmb$9h6|HNRr<beT-0w#$k$G!Qaz!pzAk;
zIS$Ff7}<E(yQ@$2qb_-$GWuCB?Oy4AR3I6@v1VoE4+X#~NJF_%bWgk*%)G74-(hwp
zy$Xt16`wKMK~<bcwb?WErWeOI=jvT6nIL)|K@aK=Hu{cCTeG_ym4b03I|QUnxBORm
z7DUr2vNaB9l^W>&R{=&PmZ-;AvDD6a8|oZ9?*L=01o;mt?6J1~qAM67Kn6?m53Vti
zJ0Z=}3-uTV*zH;T!(cxPU6I16jj7T8s=hi7Wp_vdiXa(HFd5~6bUZfG+X+;ABF<fj
z0XV`Skca=5Y0NxIl<kQ6{7idzT#a{aC#%eSis;XEz#&enXSK`Z%(bm0Z^-aYmF;_9
zlE@z>XQIt-$8$S0*1C-XwaE@HZ=~<PES)48uSmCX%%5eF8$3<~X4$c$%>v1#c$a&N
zfhpRT1PC>}{WJ}ZGJC74MY?EnqkZ2Fmz9~AZSTDe3xBAHCpLb)hbuMwv3ni^fOKCM
z2@0M|c>m%Fm9r0Z-%%?64bFUnU(YKMB!Vpx6ktO14{&!PvOlbLm-YRptUW6QTQufs
z<qai3@lq-q5rNI&4mI&Vf)HY32d1y&g6m$e&KK`ksxH(cJ?OIb@-65-as1C{E*9A#
zomQ6NY07BoB>LDAfBDMv!||)U53NL;3`$xEz{lQBw<BY}&R12Ovl_dQu4YRXo(dcr
zX%hXobHl9Aw_LbgjeVd3q<T?bSXYEt85IeFG;gl5OjzDObY0u~8rj|8Jv&HUM$`u`
z#@v~8Ot^R&V1W)aCe0L9M7qSeMi?{9kB#rN5Gh`_zTN<NlZ0fy#?aLBHJ-X6c2m{w
zx+Yc*nIBW=_s>|<$MH$>O!p9`F}sDJ`e}97IlB-nBHu);0ArAz3lg@cxn9O?9?|Te
zJdq8opciRB|L^0)P6@vTB)f_M4JnbR2*#E*LdT;By_G?GIq#OisS+b3Lh;5j?=vw@
zANRya6fJ1j5a93o`wjOh2g{3omQc!kHligaw0Li+k|tV12Vwm#E2?7C?6D1HVknBk
z8{ECR!?fB@7Z)K8eZF+jy}$qH3m-ls3Z)3@zNMT2mWhnS#RK#OG1M_ONHX9Xptv)n
zqTaqSt1-}=+<r5gFAw!g8?n>~_0#O0c$<|P7aXV_I*QAK+TXiOz3}yFtD53sA>A4o
z<2Ufl$-l&yA}1NK#*%(DnOFWSzg|~`23#AW?@2zfuYIO}darSmrM?pYFz-#1rk~OU
zM4Bix)pAlOje-sk!lT50-DsS#q`F+gMf#UZQ|A+_$_+Q2A?lK-N{uv1p@fi(c!uMu
zWlF<lsqM3__J7#@g)M2}i6(pS6&qOY$SglLTWS#mC(E&|_^jf;Q@CqT2F;`2hdmO_
zhh4E+CdPSU_lTc5B_GN)C_wv6Ad(*0R2F_xy&a$x&wo+@Xb{{4>o^l?w!|ASqcCI7
z>A}muhD<%Iv)GZKwHlCZ=h8*(wQZyV{#<(e?L~d?eEpe~uXn=B!6G?nA`Nyw`#2pj
zgW1-Wq|P>hvQ4OHj7+CfyxEMTfxf&klka7iS`Xtih(Js;1Yx79wLK}33Pd|`LWBe3
z?aUA~+Vn@xekTVIz(M>qb<F2luTV_IGa0wiEuD|5uPCY53->s>{%z9GQYj_gf0@eO
z+qqXO7%;G_F_s;@ac7~~xf!={$c?OU(;`Fkz^VN%{LpO&68Up5>=3*Gxplo$4AhjI
zc>;K?C|xDykB~j2<eUDe6Fw=-mj#vj5bQC1#K1tz<}tW`!BIg2lD6bhyRIx<_25hv
zt;AgwfW?__WLOB2yfh6|x>FUihB5f-1xyPW3*fI{<#3-+cwnW<e$vicea|-Gxk_0L
zHTk%RT@MTL<aGs=oj{sjd}Ru=$O5OgQi?ta&x{1r)%>P3*8)tPDiFxIRtnlfxs4&(
zhFE&Dmbra@1PB+6f=-+%z8F9JzNkwt+v%&a9JSXLO*=1`B0&4&P2-4p+OqsD5(P!m
zF1NvH`@t(7KX_P@-(m=GEn%?HN;2L|qBeQ-%C*q;o4h!Y*qbAq;GH4_*ucU?m&4jq
z?6M7@CtNh3&cwWSKI}D0vV}u*)~}?Wv#WREhq=F#o!7Tn8Kst<v+7I{GdMnc{(ZBD
zJI>d)PY^)A!X<8I6T2^Wswb5M20<$+qz{%ErW6QiVP{yC$&9Atb2_K38ocOwz1HQ^
z2f1&LmB^P{Q1*+kn{{*c;UavfyWM7q;@!t4al;H5o;c2VG;2*y>TM-7f{D(q>9IyW
zffl0?v~hk*4*Gz=vT0w<H%RuwX|iJenqs9eNSgvTdLJ!dM{z&D2WM-g8?(EX+2HsB
zt1jxtu@oazy#jjm?>&V7eCMAk&{ceb%wYF}Jhx1gYlLU6C<w$vv>PrvZ1jDMRgdc)
zpbKVzUD)7m2F(Lm`kiV3PK7C)4e?<wL((sUw)%B+s~QFix*m-!d>);OkE8C`Ahc32
zLzsT_s@%8-=qH2>6tW#*wTQ;_<Bz>?#wLBBN7N>-$7<TB%Jg%q=Y(Pe;QQLA1>Xk&
zZ;IuSJ|z`00&sVNam!ppPfG4c3K3i*_P*d0v2~#ZV2!y~V6)Sby?}&L27;nobQ0-3
z`9XL3<FktrXc5#I{Tzay>)sMn?q^SZze37cjH9bV6Zi#IDtYRbx(RV73{v?ak7WSA
zv->h(<OOOzg4?u<;hIBPNn<fCuHb{|m1c#a9d5$n@rXYPUo)9ShT!IaB^k%C`Pp*f
zsYU9+?qsM#)7eRVs<Jbnh-wvrJ+=DEVc6x#5!2Y5|5jG}hWRO;{bd1~KnS*|!?3Hz
zxM41pN%}wx#gKmhOQ#NB!@1pT^Ms#XpmK4RH~R0?NjhR+^j7ck`^k~&t9B!v?~8H7
zpNdj0DcXA!C?bJ<fFPF;YinrPpZG5=!OF95O2zHkWYYB|&RbO?H2wS8S@jYbY@BU=
zx6j##Hj^-0YBo*rwd4^I3A~`z_0mHYx=;D)&*Ji%dfxllr{F|%at|z#lpU?bU&wll
z%=ZsIoi<_$r>EtoK0`5C2`RsvTZiY=(4CKv+{gU7`C68dM#LB=9U-DXf()c_@0M!S
zhv(|^6x&IwT$%PuY2+&KxBD-WYC&E1VhLsWbWEm?&R4kr5z{6oC~okUHkRJ{mCRmi
zmi57(OGXxF8OkERU5y$L8#>j;J|gX{>{Ye-=dl`Hf?>OCd6x>v1_Sl=#lT4nT?DC%
zrI*L%7D{y>+Y+JK<x(QgT{Nve8m7XhV`cu@==&J-%KwI4Z}Z1$u&07TZSf~xeV)Rr
z8o48E7eSRo1Id6Zm#r$FQ;vn^$2uM@>xVX-VFDp6v58I4n4bEcl9qktW|f-iS0}D%
zqbt`&vyZ#ply7GXbVrlhFUj<KzrQ%<A$HUOjHmT1P3<G4RZTb+1l_Hll0$Ftu*ux4
zS#k1Z(VL;-`ph2`YQr^AqZV6qDrn0F{RBiU)3J_hWd`+5^3d_wtG&+ybNN=s%1|Ya
z8?;~afugZJ)l$Q4Ae<z8gG!XIX!f=v{M?2@-cVptLQY<9tN9v9o~iOAb_`c19$pOo
zVLr2mON#$d6Y>jxj|(R&g80Hv_F}(EA99x>I&4VTQ@4^d?zK`55h?~6c0ecEvFHMS
z$EUTQz-%jiqI(k|b+e_wnE`sa8tnnkye%zxR2(tVOj8xShq6Sq&rXUHRoq7waAfL@
zNIU{^`U5D73HsLgdB6}D?iwTiSFIoI;*Q^fc0p8gfh;i&0(PnW(=<ZnmIjRCylho!
z4<(U%xDicq^pD16GJ*9INT``;=7Raww2}e8d#qc|Ojv9>)P!Zcip}(lx5em^D7vr%
zYwQ{$y^dW`#-GPEt9x_l4jps1LD!lxT&?%g^YMziol>Y^f%Ps1jQj}D!@mUlPi;7j
zYR`N}87sH)kU@^h)GU<&#`pS_Mj>MG!OI6G=+7olWfS3d^om%xjoP_YbSy|v6@KqP
z00HzQMY?g`adM6WI(fYo%*f;b3i1-(R{#J3c>#~R?IdbZ?BbJIQa}IzAz^Y^2R&&@
N7*84k629<&001G5VaEUf

literal 0
HcmV?d00001

diff --git a/launcher/assets/sculk-logo.webp b/launcher/assets/sculk-logo.webp
new file mode 100644
index 0000000000000000000000000000000000000000..8877cd1d9638e2ebaf55aa2f4f8e1698bc9786ba
GIT binary patch
literal 5140
zcmV+v6zl6!Nk&Et6aWBMMM6+kP&iEg6951&zQ70&RRe>zjU>hVVeh>~5D^nlXxinF
z+dV#jt&eZoy@;I-nx<vD)wV5@<Wv%iVrFKhC2PkLGcz*|Gcz-u>ODh8r>S75x&OcZ
z?yY9-WoD*2^Ve73Up3Mx`w>{Oev!LJKBpj4R;N&rbVM^5d?9oQ<BKYjNuhjYFmZ@O
zpa?LQo*2g5RFuJZqJ=t}gUF*WCJUM9ZvYd3tVv|d^~T#2l)`Jx8CwzjA=KFfG)btF
z7^Og7Sry7AFrG{%y9B0^paA|5R<10`ktD0OQ|CPXLIW5)kb~a^S-`umJ*}7}1DKf}
z{mW;%Dc82G+N%1TYrm_wyAuHk5E==RfkV+L^5s5h)V7_CbZR#pPcpV`^Viz8ZQHhO
zd&jo5-fg~QJZC$$JIU+7ZQDqaW{SDt?$LDj3396cf9~YUW6Bm0bl5uS^xk`~sc(92
zFT4po?Jc+WntDJ%hntD{drrn{A?Ipf??nSsXT-ugAv8+v#2N*t=t!x4u7ltO15HID
zfGHN(P=E*|+$jpMa8=+17nopT$3{kq4`g)#taqo1L07a;CeD#&YkS&8o|VlmW;tcc
z`dki^9Y#r?0*;!P#!zO)`9<p(*tKm%Vb!r#zUD;bjiB-#!!uQ+ipYW_*|e=V7tgkB
z+qP}nwr$%szHHmJZEI_0N|D>P4U=^D+`a)kS8FK*#69P1Iib#&pKi@~S_)zHj}$Ht
zj9vXLg#gSx;f^cj{K6?1<y1UTNV_JT|KtHYySNt4IYAdALQ7!?*Z#w2UQ&9I2m6d;
zp^RtjLdC_2%F#x?k{{_2&g}B?CJuyxENwvBrxYL4&yJM*kWXr+sxCp;u!uz#^_Fm?
zlml6}Z~wL4yD|GFFW(B#CW7nA(^6zwf@7C0^m5WM^Z_PcV8f*gy;aT*TD@jj&5jy)
z^b<iC$l-C9m=}oG{=+wy+Vh4R`iu$ZR7v5|WjhKLY{xtn$R(Ybe2G=i^>2;Nk9f!m
z#lI>>J5Ir7#VXYfA?l$V{goNw-1h%ULcqF*7cB4EK}0k~IVC)HRH?S3+Oc8>RqXTP
z*qgWH7=4BLM1gK%=0Z6?uuD~oEM~(ZO&9W&-XRj`z|&F~TH?WQX@B#M<x?NtP#`%z
z1{XQ<%8trU?`tboz2M1R^1Jx-=nl*~+iEF1x^9+AePeaw1H+^s_3_}uhgU<PX~+Yf
z&_GzhGc;mo$GR}2Q4R!yR+J@#@Pm+GiHKUX`R%J8nVD||MZY)}ttz_xPVrMCTDn4!
zdK@Tfm8!43r3|p3A`ST1jFYW6cv^}`NO;iVrTl2Bw_(AGs&-U;NIM+xLz+AM36mnu
zB@tMU{2e7d;J&bq&%Up~Jn)n4YcK;74ViFcW{}dbodd^bM$9_>F3b;bmu9Lw_;U2M
zle3hu%<?1Atccb|yh1XJzQatJ5ig<U`pbsJ?%7bW%BshYNj$vzLgN*BddqTt?k)w-
zBqSChxsW7p*swuDQgic`EzOc77LDASi-l_-c<WA(W@1IrD0hCk#j9jV-f)GMEICOE
zUOKS#aTOz<#lSHB=w#+Tl=8&6(!^P@1#yjT%*AS#66a##((=01o7*xra@usJxoCzY
zsaftTD;Er4`28x)!BLq>m1st$dhv;nXuN#`;gg^Hu)xxC(<Dnu!rmk!ohD6yi#$KZ
z8#kKKbovy8Dvdy^4`ez265q5L5sjaCNKCPwe2HgG<ASI0wf92nk_Ep=NpK)<HHBf$
z3C=W1#epJLS@2n8kqWkJp^~>e?Jt7g%^7rKt<&HEXnKNyWEs6D|G4@t0wWPyBHvH(
zIgqAqqsC$eLhS4E95xQs4iKfQB@hN5r;|pcxbRdC1O$+TJYJ`X4sph&_FG4U{5@*{
zFN^*qa+9WqG)y@iOuz!sY<jAWv=I@NGQBq0)E+`vp^Y_cHfUHvLqM4U4Iyf>VCjRP
z)E`dbwG)t(LjProUtg&AzHTgI8M7=%eL9}~la}Wz`C}KtJ)iHQCtsBpJS|0VKYn{*
z_Q3?mgJCT^81X<$GWpgM1PnG-C$<hH)=sgA2C)cL(ZQi*MIp)X47T<qMC-xm>0oSX
zh9>jeuczlSTZ`PDXK}z;<ncPX)dS{G>z>?g9ReWFDf4h*wz>)V=mz0K0vN+tkQ~W7
zg#bn9P=f{X@folOWCb5<*fd&p?V@0rpMel=`QC)E?c{_(DS?>h*VNe|Ei87#X>y?0
z(Ho~fl?bHOXTzdaS#6yHr7t(p2(;&-zU(%7z{co6GE}8#%ADph+Fa%~GnPBepRAyo
z{hZEI3@Ac#mB&c3<fq)Bh)D-vq{h*FkV#dpG^@E9oYvzAkWP!}w{}ObsDxlBA&duO
zB>4Yw+%2aYPgES~?^45Al-#34hq%3gki%3EmAL5P4HE_-aBaxv$ni#Jfb<wC<o~3w
zd^wT~41G|O1xuIw_p|g@HDn^mcbU~|8~V>Y4W^z-X@SqjlryDN01hEy#ljnhkl^W;
zrk`#kFqIj16xcAyO2u%545%3OtPy|gSHo9z;efAPwd#+5?8g!B)3cwcb@>oyNY|^B
zrf0V-*pcg=T-0|fU1s=nfFn}cACX^O)vG!fe{|(XSN5xqc(3ZFanJfd46YG<n!Q<y
z){cXuKO8-jz|_fE1d;)vc=~(&X3XKR&>JX=n-Fuf-+aa9(TbA|C_)DrWGe4p1B9SL
znIS5&$U7V!zhvJS2vkPE&?UuYm|tl;)bPvxaYp~@2h2UiRwADsKX(YRr#_zp1=8jB
zVvjyw_qs8I?m88$ewYKpi>aDJSgP`w=tu`fhJ{D~Aq<;tylN<zX0bv(aGwD*O!Yc`
z27#EFfzyHDWa3r2{Dre9+0g*WQz}%RRl@-QcZES3xzuPQq?_a-)njA{kTBqdrpwoD
zbp++{CT79q<~MDIpwxc{gP~@YM!*&91Zg!tJ9SvAqTkbZ{G<rx(T-wA<>Duq%O?h1
zey2}N^2&#Hq5dYd2OraNx10(lb~u5lgVoS7W%$=6PkB^;xAX9FauJA-mvLjk4TKF-
z4&8!F1<yosuQls@rKg5KjRSL|*AWV=@i|<a9Z`42uyqKmDJC_$!fN?a3&cyuv7J~z
ze!q(%w6AGXnR^fBXv7?4pdbP@StiT(KLd`mB8E)QO!3XOMUkDpPVcZZtfkltW$2??
zeX!(U%Iu!4j95=$5qCL-)MvMZBfmX-pT{93hV^bFF%|*)I}kN%ouQnOM^$CERu0`>
zuI{K*x4)^nv#olt?M-j09BltsMVW2iRH9o_G>h-m?kqS@9<vbCKp;#dG4n(c;1{TY
z>}*E&+{dtSwXQGe0)aJM_m4&#4wK%=9fyF3HX7qdDa+1H&q~Q&lw`~&-}fafg-vof
z^cZG5bCf|+@Ui+$*HbhsqhUd2#`^{BHYNN8Vqx^8mdUF0HB0sfT7AIM;4MvOpx<;d
zET;$F$;X}lq?38<t|N45=8=>L*0}+369}Am=*_I<aR&Rk4Yu3^mh%L{U>H9ZsNx<h
z^0zz&(D2whpAHipLVL&e8^?flqQtt@+@EM|a`2h^48WUJ$nrkLzN#=Z{AL=$0t`H4
zRs6}cp7#W%4ZLQmWhWLNEc9CrLnBa;sp+-mL?}o$=x$59p1|Yja8LB-w`vi6ey{_i
zNsNvMq}p)^PE#~kw4`~rdRzPIXw2do_prJ%x#O?|AagObq-zYb61Wt;B)6<cPTB6#
z@Sr9O8baRE5E`IhkzVVkCJ(NPz^u;QJiFqLip{{Zag$lKzYz?QZ9wSJH1_~t7-v3i
zIg;&`W<~23sg2E9k;dlcEVbc+3)JhfH2*7<=EDK8aJ95Qr(=hZFQvT&hUU%ywsu3<
zcn)RbJ`(y|ga%@s8^?Q4Q9d13cm5d|N0PB}rFC1m+FYhKS1Bz=6QC%a1jwbIyY~M$
zLvRwd`IVy1>D1A(eE+oX?x|vP8B0SR=N%4`nznJk95SPJGHWC9GUHW7&4`;?(*7@!
zrfLMn9@;qD#-{@d^66lDw&h{a#~Q;c0K+hrFP}}XoeYQ^Mqy%fF?-wa`3g}fz$#n_
zgJWA_DqHLP(DSWo0<+0Y-X+;I3ki$QIh<5T!saO?DpvY@aE%>SnYz!>xGQ*umfYLi
z4%)LuV2xpcU@B*;>YWyf>QrqVGw4S3pusT4?Ww~)a%>Em-suV3mXMhd+-GU%TMCx$
z*Xjc@Ge6C5+>^sTA~pt3O6uu->l&YjSTP@zUha~!iHYmR{ra2mO2ByoF`Zd;h5^w`
z)&b3V;Iy#pcmw@dV`pmCBI#wsV)@n)2ve3@1udUXk5SA_qZim%Pl1h_4x45JZF~${
zD+us>FpSD0?IsnfgY7HEEJb67m`g+;4=SPP(G3CsFa#EP%Io6*q|=Fjf{@y0;NvrK
zC2SwFFgwmqWOpNA!r-hTEcM+h_7+-w@TfTyU}zvI^y@SG)&{_kJIHjcip`XI<9Q$%
z&?AksX>81l`}`ui>@gC{$;V>LxfdeKIiia#5T13`C6`=$RbGe&utF6Dg+0(7V9e0b
zOhf_@c<f?tT4ICd>0p0tCr_ROyIUTAD7gZ}SB2=Mn_k-5`qI{0LUL;;Qbx1*Ag4DR
zJ<1?uykflk5O;;VD&-sL-_E63eI~qa0_kOWAZcyAD(^%WwW{9r%U4O?ipL@+_cTD%
z%u&%@f0F|~9BO@idma`D-qLynK8yeLFE!Yvi(3D+X_Mt7u?1o-Zb~uL-UA+Bm8EqA
zkvi*Wkgf%qojd#@LsC6RW_^rng~-iJ(k$CJL7s(y>HVuKzwD1r1}O-A%g~U0`MZlW
z%XZD_U!^eM9x_)AgazE3NDAq6hy(dfy^T<I7dc$g;gGL(Dr!5Ueyg3Ljc;AxR`2T!
zQH&IadN6c_0FX4K><#HARgw;;QvLmnUhNLG(P7BuP<f=`=maQ6`2;-)`e0(g>0Ukq
zpqo@f`s_?ylijFg4nhB0wrtt|=Q%YE)=OrL?CyCa8H)1hAVrTMtkY?-3u$v`o6xU&
zU8X~468dZF)~(C%RA)HVnJ)b!n}TeqwN|V{8>d`;njM-19uAWQ^7bfbDMDu$<f!>0
zSm8hdvZ9aC=_X3@_&U9#$j$#V2R?7`>@yKMUhHw^wy&x3Y<D=8{+hpzHI|q+E(p7S
z?mTYshMjXd-fbr~C4oV+t>Zpur-<gGB6K8RBC`fbHr7y<-~LVy=`rFP*69F;8O_XQ
zV;RPi*qceDlOj6t)gz?1n$9g7gcy{u{ilJ|*ODKmCU21NVgWzb%Ga(fan#(YVhUzf
z5)DOlY9!i};=*=+zR3Yau1_#++(wzpYYFbks`$HU0~^Bo{uhA>tmaN=+WOqggrm&I
zZfmxtW>npam5_WB*KAn4iqS5Gs=RUYQJ*+ovBjbxZR^QMO70GXe8=QDVM4XjN!nIA
zLo=f*A$(K!V?`_EA8A`yRF5jcAi&_xrz7N_X}NEZWSTtpH&GdBc;tU(Ob^(D&+h)(
z*mEBpYCuF(A!v4(bmqKP8&I@82rv**x0TD^U8Gz6;<Vw_7#JzedW!74t|8MX2+`=1
zbjzGC8@)Hl39K#Upe{jLIogo;bn_1QOSg`FZeHgUO^H&9lu~N75~Z4&lrm^_lS`#n
zHx&&*ic~1{+SpbEKUS}vXHLrbqEMhj$;Gi&tWfu4wb~U!$uaa#R>+#~irnnaiiC%7
zc(MBaW3o`)Uyvu;6(L<E^e<fny?OI5H~&&qj*zk^YrY(6Un39#i!ID^DgPw-E=PX;
zN{;@N)ZdcwTMmC@^^c_aD=Giv$UiBnmP^#Ks(!PiL7yq~P_j!(YVFM2oop^6J$grS
zYowBTyXS3tC}HqEfUxScNQo3mN=<=EDT>;qX_^(SnA~%Yh#=OS&fQ5;7<Xwis0rO>
zjnKg2g9%~Tp-KI-GLr2!#<<y_Y4{E4mbrU3LPW4})$oe~rN8(AEuVS;nISZa9<KlE
zw(PF&VIR8d5_Z?+RqR9O@3MS`o!@SCMfJtAcUfM=&c4H+TXOJAMEl)0Twtdkq#ru_
z>@S{ucDohT*<aj+tJocQqWa?dufcT%kkm;1yIq#Bv%k20{n_go+kK>3%1ymykGDUS
zxBmA-aqE8+FMI8tuf8j84aLo&^m=oyDfjqK`Kf>W<0f3i{_&4Ha7A?{SReM1U>9Jw
z<+9ElPCXH841xj{NPhF<JFKW~viyY&{7;z*5%8qD7xkxIdvrxu^nW!<W2wJ|rC}VI
z88WxiW)qfecuYeCH5)2py9r&MisYCkivrm@;^D0zKZ>??F&7Dq0X)!HA<rJ3_7Ct7
zUU2&Kkogm7sB;%s&}#dyHf*i)2U!{{-CyjYAZ&djcgb~e#3}gy%F#D`muF(m(-prK
zEdrVvo`e$@BCfWoapA{butr>PHT;Mr0*DniJSiMQ-Shh2xT^Sz5WHUd(+5NRj13cS
zLG9$BHcP9u8w@;fp*k8u83=Y!uxvf4&;QGKwlbDkyrA#%;#><r3xcFafX>lRy!ggF
zQd$^q8<g}RM47<`2Hi<oh07E>3_qmJqpvU@KEFWl^k>_E?l<pP&b;{ae(r^r!`w6f
zZ55f8QMLa)Fegts?MY_dyY+J7)4St<ID)J3_IF<Mfx*}BL}t|dNYQriPiZ`|CB5eK
zRF)QiXhG2R2W_Z*A};v7UwH@fOMI&>jBqr@i<TAx!Psp;9Q#N-hM(<6@uLtnuK@u3
CF9>-6

literal 0
HcmV?d00001

diff --git a/launcher/lang/fr.json b/launcher/lang/fr.json
index 68ef9f744..189577fb3 100644
--- a/launcher/lang/fr.json
+++ b/launcher/lang/fr.json
@@ -151,6 +151,11 @@
   "Not played yet": "Pas encore joué",
   "under a minute": "moins d'une minute",
   "PARTNER": "PARTENAIRE",
+  "Your Minecraft server, {online}.": "Votre serveur Minecraft, {online}.",
+  "24/7 online": "en ligne 24h/24",
+  "Ready in under a minute": "Prêt en moins d'une minute",
+  "Get my server": "Obtenir mon serveur",
+  "15% off": "-15 %",
   "Not prepared. Horizon needs the files of your own Minecraft {version}.": "Pas préparé. Horizon a besoin des fichiers de votre propre Minecraft {version}.",
   "Prepared for Minecraft {version}": "Préparé pour Minecraft {version}",
   "Prepared for Minecraft {version}, without its sounds: the game will be silent. Prepare again to copy them from your Minecraft install.": "Préparé pour Minecraft {version}, sans ses sons : le jeu sera muet. Préparez à nouveau pour les copier depuis votre installation de Minecraft."
diff --git a/launcher/lang/ru.json b/launcher/lang/ru.json
index 48051bfac..a992ef819 100644
--- a/launcher/lang/ru.json
+++ b/launcher/lang/ru.json
@@ -151,6 +151,11 @@
   "Not played yet": "Ещё не запускалась",
   "under a minute": "меньше минуты",
   "PARTNER": "ПАРТНЁР",
+  "Your Minecraft server, {online}.": "Ваш сервер Minecraft, {online}.",
+  "24/7 online": "онлайн 24/7",
+  "Ready in under a minute": "Готов меньше чем за минуту",
+  "Get my server": "Получить сервер",
+  "15% off": "скидка 15%",
   "Not prepared. Horizon needs the files of your own Minecraft {version}.": "Не подготовлено. Horizon нужны файлы вашего собственного Minecraft {version}.",
   "Prepared for Minecraft {version}": "Подготовлено для Minecraft {version}",
   "Prepared for Minecraft {version}, without its sounds: the game will be silent. Prepare again to copy them from your Minecraft install.": "Подготовлено для Minecraft {version}, но без звуков: игра будет беззвучной. Подготовьте заново, чтобы скопировать их из вашей установки Minecraft."
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 1bb96fc0d..2cb1bb775 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -1702,7 +1702,7 @@ impl Launcher {
 
     /// The sidebar: Horizon and the imported modpacks, the player's servers, then the
     /// launcher's own update, the community links and its version.
-    fn sidebar(&mut self, cx: &mut Context<Self>) -> Stateful<Div> {
+    fn sidebar(&mut self, window: &Window, cx: &mut Context<Self>) -> Stateful<Div> {
         let t = self.theme;
         self.load_packs();
         let heading = |label: String| {
@@ -1751,12 +1751,14 @@ impl Launcher {
                 this.open_instance_dialog(None);
                 cx.notify();
             }));
+        let items = self.instance_items(heading, cx);
+        let mut rows = items.len();
         let list = div()
             .flex()
             .flex_col()
             .gap(px(4.))
             .child(heading(tr("INSTANCES").into()).child(add))
-            .children(self.instance_items(heading, cx));
+            .children(items);
         let servers: Vec<_> = self
             .servers
             .sidebar_list()
@@ -1766,6 +1768,8 @@ impl Launcher {
         if !servers.is_empty() {
             list = list.child(heading(tr("SERVERS").into()));
         }
+        rows += servers.len();
+        let headings = 1 + usize::from(!servers.is_empty());
         for e in servers {
             let up = self.servers.is_up(&e.dir);
             let open = self.page == Page::Servers && self.servers.open.as_ref() == Some(&e.dir);
@@ -1855,12 +1859,20 @@ impl Launcher {
             }
             _ => {}
         }
-        // Sculk's banner, small, above the links: seen without scrolling, on every page but Servers, which
-        // shows it large. After a while on screen a "Hide" beside its label puts it away for good.
+        // Sculk's card above the links: seen without scrolling, on every page but Servers, which shows
+        // its wide banner. Tall where the sidebar has the height for it besides its rows (about 60
+        // high each, under headings of about 40) and the links, compact otherwise. After a while on
+        // screen a "Hide" beside its label puts it away for good.
         if self.page != Page::Servers && !self.settings.partner_hidden {
-            let mut side = div().relative().mb(px(8.)).child(partner::banner(
+            let free = f32::from(window.viewport_size().height)
+                - theme::TOPBAR
+                - 40. * headings as f32
+                - 60. * rows as f32
+                - 110.;
+            let mut side = div().relative().mb(px(8.)).child(partner::card(
                 "partner-side",
                 theme::SIDEBAR - 20.,
+                free < partner::TALL_HEIGHT,
                 &t,
             ));
             if self.settings.partner_seen_secs >= partner::SEEN_BEFORE_HIDE {
@@ -3659,7 +3671,7 @@ impl Render for Launcher {
         }
         let stone = self.art.stone(t.page_rgb, t.dark, window.scale_factor());
         let topbar = self.topbar(window, cx);
-        let sidebar = self.sidebar(cx);
+        let sidebar = self.sidebar(window, cx);
         let mut root = div()
             .id("root")
             .track_focus(&self.root_focus)
diff --git a/launcher/src/partner.rs b/launcher/src/partner.rs
index 6242f9228..ae82ebd7f 100644
--- a/launcher/src/partner.rs
+++ b/launcher/src/partner.rs
@@ -1,8 +1,12 @@
-//! Sculk's banner: a server host that sponsors Horizon (Ludovic, 2026-10-26), large on the Servers page
-//! and small at the foot of the sidebar on the other pages, where it shows without scrolling. The picture is in the binary, never fetched; a click opens Sculk's page in
-//! the browser. A "Partner" label above it says it is an ad.
+//! Sculk, a server host that sponsors Horizon (Ludovic, 2026-10-26): its wide banner on the Servers
+//! page, and a card made for the sidebar on the other pages, where the banner's baked-in text was too
+//! small to read. The pictures are in the binary, never fetched; a click opens Sculk's page in the
+//! browser. A "Partner" label above each says it is an ad.
 use crate::theme::Theme;
-use gpui::{div, img, prelude::*, px, ClickEvent, Div, Image, ImageFormat, Stateful};
+use gpui::{
+    div, img, prelude::*, px, rgb, ClickEvent, Div, FontWeight, HighlightStyle, Image, ImageFormat,
+    Rgba, SharedString, Stateful, StyledText,
+};
 use std::sync::{Arc, LazyLock};
 
 pub const URL: &str = "https://my.sculkhosting.com/ref/horizon";
@@ -51,9 +55,256 @@ pub fn banner(id: &'static str, width: f32, t: &Theme) -> Stateful<Div> {
     crate::keyboard(el, &t)
 }
 
+/// Sculk's characters (Steve, Alex and the wolf) cropped from its banner at 2x the card's width.
+/// Above `ART_TOP` (in the card's 228 logical pixels) the picture is transparent but for their heads
+/// and the pickaxe, which stand out of the card; its foot and right edge fade into `CARD`.
+const ART_WIDTH: f32 = 456.;
+const ART_HEIGHT: f32 = 364.;
+const ART_TOP: f32 = 11.;
+static ART: LazyLock<Arc<Image>> = LazyLock::new(|| {
+    Arc::new(Image::from_bytes(
+        ImageFormat::Webp,
+        include_bytes!("../assets/sculk-card-art.webp").to_vec(),
+    ))
+});
+
+/// Sculk's mark and name, cropped from its banner, 2x for a 18 pixel height.
+const LOGO_WIDTH: f32 = 191.;
+const LOGO_HEIGHT: f32 = 36.;
+static LOGO: LazyLock<Arc<Image>> = LazyLock::new(|| {
+    Arc::new(Image::from_bytes(
+        ImageFormat::Webp,
+        include_bytes!("../assets/sculk-logo.webp").to_vec(),
+    ))
+});
+
+/// Sculk's colours, taken from its banner: the card is Sculk's in both themes, as an ad is.
+const CARD: u32 = 0x0b0d12;
+const CYAN: u32 = 0x5dd4fb;
+const CYAN_HOVER: u32 = 0x8fe3fd;
+const WHITE: u32 = 0xf1f5f9;
+const GREY: u32 = 0x9aa6b2;
+const ON_CYAN: u32 = 0x062330;
+
+/// The promo code: Sculk's, never translated.
+const CODE: &str = "HORIZON15";
+
+/// What the tall card needs of the sidebar's height, label included, with room for a third line of
+/// headline: below it the sidebar shows the compact card.
+pub const TALL_HEIGHT: f32 = 410.;
+
+/// "Your Minecraft server, 24/7 online." with "24/7 online" in Sculk's cyan, in the launcher's
+/// language.
+fn headline() -> StyledText {
+    let online = horizon_launcher::i18n::tr("24/7 online");
+    let line = horizon_launcher::i18n::tr("Your Minecraft server, {online}.");
+    let (before, after) = line.split_once("{online}").unwrap_or((line, ""));
+    let text = format!("{before}{online}{after}");
+    let lit = before.len()..before.len() + online.len();
+    StyledText::new(SharedString::from(text)).with_highlights([(
+        lit,
+        HighlightStyle {
+            color: Some(rgb(CYAN).into()),
+            ..Default::default()
+        },
+    )])
+}
+
+/// "HORIZON15 · 15% off" in a dashed cyan frame, as on Sculk's banner.
+fn code_chip(size: f32, height: f32) -> Div {
+    div()
+        .flex()
+        .items_center()
+        .justify_center()
+        .gap(px(6.))
+        .h(px(height))
+        .px(px(10.))
+        .border_1()
+        .border_dashed()
+        .border_color(rgba(CYAN, 0.7))
+        .rounded(px(6.))
+        .font_family(crate::theme::MONO)
+        .text_size(px(size))
+        .whitespace_nowrap()
+        .child(
+            div()
+                .text_color(rgb(WHITE))
+                .font_weight(FontWeight::SEMIBOLD)
+                .child(CODE),
+        )
+        .child(div().text_color(rgb(GREY)).child("·"))
+        .child(
+            div()
+                .text_color(rgb(CYAN))
+                .child(horizon_launcher::i18n::tr("15% off")),
+        )
+}
+
+fn rgba(hex: u32, alpha: f32) -> Rgba {
+    Rgba {
+        a: alpha,
+        ..rgb(hex)
+    }
+}
+
+/// Sculk's card for the sidebar, `width` logical pixels wide: its characters standing out of the top,
+/// then its name, the headline, a line, a "Get my server" button and the promo code, all drawn by
+/// the launcher so they stay sharp and follow its language. `compact` puts the characters beside a
+/// shorter text, for windows too short for the tall card. Hovering lifts it a little.
+pub fn card(id: &'static str, width: f32, compact: bool, t: &Theme) -> Stateful<Div> {
+    let t = *t;
+    let label = crate::text(crate::theme::MICRO)
+        .text_color(t.muted)
+        .group_hover(id, move |s| s.text_color(t.ink))
+        .child(horizon_launcher::i18n::tr("PARTNER"));
+    let face = div()
+        .relative()
+        .flex()
+        .flex_none()
+        .w(px(width))
+        .bg(rgb(CARD))
+        .border_1()
+        .border_color(rgba(CYAN, 0.22))
+        .rounded(px(10.))
+        .group_hover(id, |s| s.top(px(-2.)).border_color(rgba(CYAN, 0.5)));
+    let logo = |height: f32| {
+        img(LOGO.clone())
+            .flex_none()
+            .w(px(height * LOGO_WIDTH / LOGO_HEIGHT))
+            .h(px(height))
+    };
+    let face = if compact {
+        // The characters beside the text, their faded foot melting into the card, the code under both.
+        let art_w = 104.;
+        face.flex_col()
+            .child(
+                div()
+                    .flex()
+                    .items_end()
+                    .child(
+                        div()
+                            .flex()
+                            .flex_col()
+                            .flex_1()
+                            .min_w_0()
+                            .gap(px(8.))
+                            .pl(px(12.))
+                            .pt(px(12.))
+                            .child(logo(13.))
+                            .child(
+                                div()
+                                    .text_size(px(15.))
+                                    .line_height(px(19.))
+                                    .font_weight(FontWeight::SEMIBOLD)
+                                    .text_color(rgb(WHITE))
+                                    .child(headline()),
+                            ),
+                    )
+                    .child(
+                        img(ART.clone())
+                            .flex_none()
+                            .w(px(art_w))
+                            .h(px(art_w * ART_HEIGHT / ART_WIDTH)),
+                    ),
+            )
+            .child(
+                div()
+                    .flex()
+                    .px(px(12.))
+                    .pt(px(6.))
+                    .pb(px(12.))
+                    .child(code_chip(11., 26.).flex_1()),
+            )
+    } else {
+        let art_h = width * ART_HEIGHT / ART_WIDTH;
+        let button = div()
+            .flex()
+            .items_center()
+            .justify_center()
+            .h(px(36.))
+            .rounded(px(8.))
+            .bg(rgb(CYAN))
+            .group_hover(id, |s| s.bg(rgb(CYAN_HOVER)))
+            .text_color(rgb(ON_CYAN))
+            .text_size(px(14.))
+            .font_weight(FontWeight::SEMIBOLD)
+            .child(horizon_launcher::i18n::tr("Get my server"));
+        // The art stands out of the card's top; the text starts over its faded foot.
+        face.mt(px(ART_TOP))
+            .flex_col()
+            .child(
+                img(ART.clone())
+                    .absolute()
+                    .top(px(-ART_TOP))
+                    .left_0()
+                    .w(px(width))
+                    .h(px(art_h)),
+            )
+            .child(
+                div()
+                    .flex()
+                    .flex_col()
+                    .pt(px(art_h - ART_TOP - 14.))
+                    .px(px(16.))
+                    .pb(px(16.))
+                    .child(logo(16.))
+                    .child(
+                        div()
+                            .mt(px(12.))
+                            .text_size(px(19.))
+                            .line_height(px(23.))
+                            .font_weight(FontWeight::SEMIBOLD)
+                            .text_color(rgb(WHITE))
+                            .child(headline()),
+                    )
+                    .child(
+                        div()
+                            .mt(px(6.))
+                            .text_size(px(13.))
+                            .line_height(px(18.))
+                            .text_color(rgb(GREY))
+                            .child(horizon_launcher::i18n::tr("Ready in under a minute")),
+                    )
+                    .child(div().mt(px(16.)).child(button))
+                    .child(div().mt(px(8.)).flex().child(code_chip(12., 30.).flex_1())),
+            )
+    };
+    let el = div()
+        .id(id)
+        .group(id)
+        .flex()
+        .flex_col()
+        .gap(px(8.))
+        .w(px(width))
+        .cursor_pointer()
+        .child(label)
+        .child(face)
+        .on_click(|_: &ClickEvent, _, cx| cx.open_url(URL));
+    crate::keyboard(el, &t)
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{HEIGHT, WIDTH};
+    use super::{ART_HEIGHT, ART_WIDTH, HEIGHT, LOGO_HEIGHT, LOGO_WIDTH, WIDTH};
+
+    /// Each bundled picture decodes as a WebP of the size the code lays it out at.
+    #[test]
+    fn the_card_pictures_decode() {
+        for (bytes, size) in [
+            (
+                &include_bytes!("../assets/sculk-card-art.webp")[..],
+                (ART_WIDTH, ART_HEIGHT),
+            ),
+            (
+                &include_bytes!("../assets/sculk-logo.webp")[..],
+                (LOGO_WIDTH, LOGO_HEIGHT),
+            ),
+        ] {
+            let pic = image::load_from_memory_with_format(bytes, image::ImageFormat::WebP)
+                .expect("a WebP");
+            assert_eq!((pic.width(), pic.height()), (size.0 as u32, size.1 as u32));
+        }
+    }
 
     #[test]
     fn the_bundled_banner_decodes() {

From bc0c0fdf4a2911594008f386260177f08138bede Mon Sep 17 00:00:00 2001
From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com>
Date: Tue, 27 Oct 2026 12:13:32 +0100
Subject: [PATCH 475/475] refactor: the MobEffects and Potions tables live in
 horizon-client-core

effects.rs and hud_overlays.rs read the effect and potion tables from
brewing, which made them depend on brewing (and through it on containers
and items), edges that keep the client lib in a single cycle. The tables
have no dependencies, so they move to horizon-client-core; brewing
re-exports them. No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/horizon-client-core/src/lib.rs     |   1 +
 crates/horizon-client-core/src/potions.rs | 249 +++++++++++++++++++++
 crates/horizon-client/src/brewing.rs      | 255 +---------------------
 crates/horizon-client/src/effects.rs      |  10 +-
 crates/horizon-client/src/hud_overlays.rs |   5 +-
 5 files changed, 263 insertions(+), 257 deletions(-)
 create mode 100644 crates/horizon-client-core/src/potions.rs

diff --git a/crates/horizon-client-core/src/lib.rs b/crates/horizon-client-core/src/lib.rs
index 2030165c5..7721668ca 100644
--- a/crates/horizon-client-core/src/lib.rs
+++ b/crates/horizon-client-core/src/lib.rs
@@ -16,6 +16,7 @@ pub mod lang;
 pub mod nbt_path;
 pub mod particle_type;
 pub mod pattern;
+pub mod potions;
 pub mod registries;
 pub mod scoreboard;
 pub mod snbt;
diff --git a/crates/horizon-client-core/src/potions.rs b/crates/horizon-client-core/src/potions.rs
new file mode 100644
index 000000000..044b25e3a
--- /dev/null
+++ b/crates/horizon-client-core/src/potions.rs
@@ -0,0 +1,249 @@
+//! The `MobEffects` and `Potions` registries (code in vanilla, ported as
+//! tables): each effect's colour and category, each potion's effects, and the
+//! potion colour mix. horizon-client re-exports them from `brewing`.
+use std::{collections::HashMap, sync::OnceLock};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Category {
+    Beneficial,
+    Harmful,
+    Neutral,
+}
+/// A `MobEffect`: id (without namespace), colour, category, instantaneous.
+#[derive(Clone, Copy, Debug)]
+pub struct EffectDef {
+    pub id: &'static str,
+    pub color: u32,
+    pub category: Category,
+    pub instant: bool,
+}
+const fn fx(id: &'static str, color: u32, category: Category) -> EffectDef {
+    EffectDef {
+        id,
+        color,
+        category,
+        instant: false,
+    }
+}
+use Category::{Beneficial as B, Harmful as H, Neutral as N};
+/// `MobEffects` in registration order.
+pub const EFFECTS: &[EffectDef] = &[
+    fx("speed", 3402751, B),
+    fx("slowness", 9154528, H),
+    fx("haste", 14270531, B),
+    fx("mining_fatigue", 4866583, H),
+    fx("strength", 16762624, B),
+    EffectDef {
+        id: "instant_health",
+        color: 16262179,
+        category: B,
+        instant: true,
+    },
+    EffectDef {
+        id: "instant_damage",
+        color: 11101546,
+        category: H,
+        instant: true,
+    },
+    fx("jump_boost", 16646020, B),
+    fx("nausea", 5578058, H),
+    fx("regeneration", 13458603, B),
+    fx("resistance", 9520880, B),
+    fx("fire_resistance", 16750848, B),
+    fx("water_breathing", 10017472, B),
+    fx("invisibility", 16185078, B),
+    fx("blindness", 2039587, H),
+    fx("night_vision", 12779366, B),
+    fx("hunger", 5797459, H),
+    fx("weakness", 4738376, H),
+    fx("poison", 8889187, H),
+    fx("wither", 7561558, H),
+    fx("health_boost", 16284963, B),
+    fx("absorption", 2445989, B),
+    EffectDef {
+        id: "saturation",
+        color: 16262179,
+        category: B,
+        instant: true,
+    },
+    fx("glowing", 9740385, N),
+    fx("levitation", 13565951, H),
+    fx("luck", 5882118, B),
+    fx("unluck", 12624973, H),
+    fx("slow_falling", 15978425, B),
+    fx("conduit_power", 1950417, B),
+    fx("dolphins_grace", 8954814, B),
+    fx("bad_omen", 745784, N),
+    fx("hero_of_the_village", 4521796, B),
+    fx("darkness", 2696993, H),
+    fx("trial_omen", 1484454, N),
+    fx("raid_omen", 14565464, N),
+    fx("wind_charged", 12438015, H),
+    fx("weaving", 7891290, H),
+    fx("oozing", 10092451, H),
+    fx("infested", 9214860, H),
+    fx("breath_of_the_nautilus", 65518, B),
+];
+pub fn effect(id: &str) -> Option<&'static EffectDef> {
+    let id = id.trim_start_matches("minecraft:");
+    EFFECTS.iter().find(|e| e.id == id)
+}
+/// Namespaced effect ids for mob effect storage.
+pub fn namespaced(id: &'static str) -> &'static str {
+    static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
+    IDS.get_or_init(|| {
+        EFFECTS
+            .iter()
+            .map(|e| {
+                (
+                    e.id,
+                    &*Box::leak(format!("minecraft:{}", e.id).into_boxed_str()),
+                )
+            })
+            .collect()
+    })
+    .get(id)
+    .copied()
+    .unwrap_or(id)
+}
+/// A `Potion`: id, name suffix (`item.minecraft.potion.effect.<name>`) and
+/// effects as (effect, duration ticks, amplifier).
+#[derive(Clone, Copy, Debug)]
+pub struct PotionDef {
+    pub id: &'static str,
+    pub name: &'static str,
+    pub effects: &'static [(&'static str, i32, i32)],
+}
+const fn p(
+    id: &'static str,
+    name: &'static str,
+    effects: &'static [(&'static str, i32, i32)],
+) -> PotionDef {
+    PotionDef { id, name, effects }
+}
+/// `Potions` in registration order.
+pub const POTIONS: &[PotionDef] = &[
+    p("water", "water", &[]),
+    p("mundane", "mundane", &[]),
+    p("thick", "thick", &[]),
+    p("awkward", "awkward", &[]),
+    p("night_vision", "night_vision", &[("night_vision", 3600, 0)]),
+    p(
+        "long_night_vision",
+        "night_vision",
+        &[("night_vision", 9600, 0)],
+    ),
+    p("invisibility", "invisibility", &[("invisibility", 3600, 0)]),
+    p(
+        "long_invisibility",
+        "invisibility",
+        &[("invisibility", 9600, 0)],
+    ),
+    p("leaping", "leaping", &[("jump_boost", 3600, 0)]),
+    p("long_leaping", "leaping", &[("jump_boost", 9600, 0)]),
+    p("strong_leaping", "leaping", &[("jump_boost", 1800, 1)]),
+    p(
+        "fire_resistance",
+        "fire_resistance",
+        &[("fire_resistance", 3600, 0)],
+    ),
+    p(
+        "long_fire_resistance",
+        "fire_resistance",
+        &[("fire_resistance", 9600, 0)],
+    ),
+    p("swiftness", "swiftness", &[("speed", 3600, 0)]),
+    p("long_swiftness", "swiftness", &[("speed", 9600, 0)]),
+    p("strong_swiftness", "swiftness", &[("speed", 1800, 1)]),
+    p("slowness", "slowness", &[("slowness", 1800, 0)]),
+    p("long_slowness", "slowness", &[("slowness", 4800, 0)]),
+    p("strong_slowness", "slowness", &[("slowness", 400, 3)]),
+    p(
+        "turtle_master",
+        "turtle_master",
+        &[("slowness", 400, 3), ("resistance", 400, 2)],
+    ),
+    p(
+        "long_turtle_master",
+        "turtle_master",
+        &[("slowness", 800, 3), ("resistance", 800, 2)],
+    ),
+    p(
+        "strong_turtle_master",
+        "turtle_master",
+        &[("slowness", 400, 5), ("resistance", 400, 3)],
+    ),
+    p(
+        "water_breathing",
+        "water_breathing",
+        &[("water_breathing", 3600, 0)],
+    ),
+    p(
+        "long_water_breathing",
+        "water_breathing",
+        &[("water_breathing", 9600, 0)],
+    ),
+    p("healing", "healing", &[("instant_health", 1, 0)]),
+    p("strong_healing", "healing", &[("instant_health", 1, 1)]),
+    p("harming", "harming", &[("instant_damage", 1, 0)]),
+    p("strong_harming", "harming", &[("instant_damage", 1, 1)]),
+    p("poison", "poison", &[("poison", 900, 0)]),
+    p("long_poison", "poison", &[("poison", 1800, 0)]),
+    p("strong_poison", "poison", &[("poison", 432, 1)]),
+    p("regeneration", "regeneration", &[("regeneration", 900, 0)]),
+    p(
+        "long_regeneration",
+        "regeneration",
+        &[("regeneration", 1800, 0)],
+    ),
+    p(
+        "strong_regeneration",
+        "regeneration",
+        &[("regeneration", 450, 1)],
+    ),
+    p("strength", "strength", &[("strength", 3600, 0)]),
+    p("long_strength", "strength", &[("strength", 9600, 0)]),
+    p("strong_strength", "strength", &[("strength", 1800, 1)]),
+    p("weakness", "weakness", &[("weakness", 1800, 0)]),
+    p("long_weakness", "weakness", &[("weakness", 4800, 0)]),
+    p("luck", "luck", &[("luck", 6000, 0)]),
+    p("slow_falling", "slow_falling", &[("slow_falling", 1800, 0)]),
+    p(
+        "long_slow_falling",
+        "slow_falling",
+        &[("slow_falling", 4800, 0)],
+    ),
+    p("wind_charged", "wind_charged", &[("wind_charged", 3600, 0)]),
+    p("weaving", "weaving", &[("weaving", 3600, 0)]),
+    p("oozing", "oozing", &[("oozing", 3600, 0)]),
+    p("infested", "infested", &[("infested", 3600, 0)]),
+];
+pub fn potion(id: &str) -> Option<&'static PotionDef> {
+    let id = id.trim_start_matches("minecraft:");
+    POTIONS.iter().find(|p| p.id == id)
+}
+/// `PotionContents.BASE_POTION_COLOR` (ARGB -13083194) as RGB.
+pub const BASE_POTION_COLOR: u32 = 0x385DC6;
+/// `PotionContents.getColor`: amplifier-weighted mix of visible effect colours.
+pub fn potion_color(id: Option<&str>) -> u32 {
+    let Some(def) = id.and_then(potion) else {
+        return BASE_POTION_COLOR;
+    };
+    let (mut r, mut g, mut b, mut total) = (0u32, 0u32, 0u32, 0u32);
+    for (e, _, amp) in def.effects {
+        let Some(e) = effect(e) else { continue };
+        let w = *amp as u32 + 1;
+        r += w * (e.color >> 16 & 255);
+        g += w * (e.color >> 8 & 255);
+        b += w * (e.color & 255);
+        total += w;
+    }
+    match (
+        r.checked_div(total),
+        g.checked_div(total),
+        b.checked_div(total),
+    ) {
+        (Some(r), Some(g), Some(b)) => (r << 16) | (g << 8) | b,
+        _ => BASE_POTION_COLOR,
+    }
+}
diff --git a/crates/horizon-client/src/brewing.rs b/crates/horizon-client/src/brewing.rs
index cdd988a7a..b3cda5f90 100644
--- a/crates/horizon-client/src/brewing.rs
+++ b/crates/horizon-client/src/brewing.rs
@@ -7,257 +7,12 @@ use crate::{
     items::{ItemStack, Items},
 };
 use serde_json::Value;
-use std::{
-    collections::{HashMap, HashSet},
-    fs,
-    path::Path,
-    sync::{Arc, OnceLock},
-};
+use std::{collections::HashSet, fs, path::Path, sync::Arc};
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Category {
-    Beneficial,
-    Harmful,
-    Neutral,
-}
-/// A `MobEffect`: id (without namespace), colour, category, instantaneous.
-#[derive(Clone, Copy, Debug)]
-pub struct EffectDef {
-    pub id: &'static str,
-    pub color: u32,
-    pub category: Category,
-    pub instant: bool,
-}
-const fn fx(id: &'static str, color: u32, category: Category) -> EffectDef {
-    EffectDef {
-        id,
-        color,
-        category,
-        instant: false,
-    }
-}
-use Category::{Beneficial as B, Harmful as H, Neutral as N};
-/// `MobEffects` in registration order.
-pub const EFFECTS: &[EffectDef] = &[
-    fx("speed", 3402751, B),
-    fx("slowness", 9154528, H),
-    fx("haste", 14270531, B),
-    fx("mining_fatigue", 4866583, H),
-    fx("strength", 16762624, B),
-    EffectDef {
-        id: "instant_health",
-        color: 16262179,
-        category: B,
-        instant: true,
-    },
-    EffectDef {
-        id: "instant_damage",
-        color: 11101546,
-        category: H,
-        instant: true,
-    },
-    fx("jump_boost", 16646020, B),
-    fx("nausea", 5578058, H),
-    fx("regeneration", 13458603, B),
-    fx("resistance", 9520880, B),
-    fx("fire_resistance", 16750848, B),
-    fx("water_breathing", 10017472, B),
-    fx("invisibility", 16185078, B),
-    fx("blindness", 2039587, H),
-    fx("night_vision", 12779366, B),
-    fx("hunger", 5797459, H),
-    fx("weakness", 4738376, H),
-    fx("poison", 8889187, H),
-    fx("wither", 7561558, H),
-    fx("health_boost", 16284963, B),
-    fx("absorption", 2445989, B),
-    EffectDef {
-        id: "saturation",
-        color: 16262179,
-        category: B,
-        instant: true,
-    },
-    fx("glowing", 9740385, N),
-    fx("levitation", 13565951, H),
-    fx("luck", 5882118, B),
-    fx("unluck", 12624973, H),
-    fx("slow_falling", 15978425, B),
-    fx("conduit_power", 1950417, B),
-    fx("dolphins_grace", 8954814, B),
-    fx("bad_omen", 745784, N),
-    fx("hero_of_the_village", 4521796, B),
-    fx("darkness", 2696993, H),
-    fx("trial_omen", 1484454, N),
-    fx("raid_omen", 14565464, N),
-    fx("wind_charged", 12438015, H),
-    fx("weaving", 7891290, H),
-    fx("oozing", 10092451, H),
-    fx("infested", 9214860, H),
-    fx("breath_of_the_nautilus", 65518, B),
-];
-pub fn effect(id: &str) -> Option<&'static EffectDef> {
-    let id = id.trim_start_matches("minecraft:");
-    EFFECTS.iter().find(|e| e.id == id)
-}
-/// Namespaced effect ids for mob effect storage.
-pub fn namespaced(id: &'static str) -> &'static str {
-    static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
-    IDS.get_or_init(|| {
-        EFFECTS
-            .iter()
-            .map(|e| {
-                (
-                    e.id,
-                    &*Box::leak(format!("minecraft:{}", e.id).into_boxed_str()),
-                )
-            })
-            .collect()
-    })
-    .get(id)
-    .copied()
-    .unwrap_or(id)
-}
-/// A `Potion`: id, name suffix (`item.minecraft.potion.effect.<name>`) and
-/// effects as (effect, duration ticks, amplifier).
-#[derive(Clone, Copy, Debug)]
-pub struct PotionDef {
-    pub id: &'static str,
-    pub name: &'static str,
-    pub effects: &'static [(&'static str, i32, i32)],
-}
-const fn p(
-    id: &'static str,
-    name: &'static str,
-    effects: &'static [(&'static str, i32, i32)],
-) -> PotionDef {
-    PotionDef { id, name, effects }
-}
-/// `Potions` in registration order.
-pub const POTIONS: &[PotionDef] = &[
-    p("water", "water", &[]),
-    p("mundane", "mundane", &[]),
-    p("thick", "thick", &[]),
-    p("awkward", "awkward", &[]),
-    p("night_vision", "night_vision", &[("night_vision", 3600, 0)]),
-    p(
-        "long_night_vision",
-        "night_vision",
-        &[("night_vision", 9600, 0)],
-    ),
-    p("invisibility", "invisibility", &[("invisibility", 3600, 0)]),
-    p(
-        "long_invisibility",
-        "invisibility",
-        &[("invisibility", 9600, 0)],
-    ),
-    p("leaping", "leaping", &[("jump_boost", 3600, 0)]),
-    p("long_leaping", "leaping", &[("jump_boost", 9600, 0)]),
-    p("strong_leaping", "leaping", &[("jump_boost", 1800, 1)]),
-    p(
-        "fire_resistance",
-        "fire_resistance",
-        &[("fire_resistance", 3600, 0)],
-    ),
-    p(
-        "long_fire_resistance",
-        "fire_resistance",
-        &[("fire_resistance", 9600, 0)],
-    ),
-    p("swiftness", "swiftness", &[("speed", 3600, 0)]),
-    p("long_swiftness", "swiftness", &[("speed", 9600, 0)]),
-    p("strong_swiftness", "swiftness", &[("speed", 1800, 1)]),
-    p("slowness", "slowness", &[("slowness", 1800, 0)]),
-    p("long_slowness", "slowness", &[("slowness", 4800, 0)]),
-    p("strong_slowness", "slowness", &[("slowness", 400, 3)]),
-    p(
-        "turtle_master",
-        "turtle_master",
-        &[("slowness", 400, 3), ("resistance", 400, 2)],
-    ),
-    p(
-        "long_turtle_master",
-        "turtle_master",
-        &[("slowness", 800, 3), ("resistance", 800, 2)],
-    ),
-    p(
-        "strong_turtle_master",
-        "turtle_master",
-        &[("slowness", 400, 5), ("resistance", 400, 3)],
-    ),
-    p(
-        "water_breathing",
-        "water_breathing",
-        &[("water_breathing", 3600, 0)],
-    ),
-    p(
-        "long_water_breathing",
-        "water_breathing",
-        &[("water_breathing", 9600, 0)],
-    ),
-    p("healing", "healing", &[("instant_health", 1, 0)]),
-    p("strong_healing", "healing", &[("instant_health", 1, 1)]),
-    p("harming", "harming", &[("instant_damage", 1, 0)]),
-    p("strong_harming", "harming", &[("instant_damage", 1, 1)]),
-    p("poison", "poison", &[("poison", 900, 0)]),
-    p("long_poison", "poison", &[("poison", 1800, 0)]),
-    p("strong_poison", "poison", &[("poison", 432, 1)]),
-    p("regeneration", "regeneration", &[("regeneration", 900, 0)]),
-    p(
-        "long_regeneration",
-        "regeneration",
-        &[("regeneration", 1800, 0)],
-    ),
-    p(
-        "strong_regeneration",
-        "regeneration",
-        &[("regeneration", 450, 1)],
-    ),
-    p("strength", "strength", &[("strength", 3600, 0)]),
-    p("long_strength", "strength", &[("strength", 9600, 0)]),
-    p("strong_strength", "strength", &[("strength", 1800, 1)]),
-    p("weakness", "weakness", &[("weakness", 1800, 0)]),
-    p("long_weakness", "weakness", &[("weakness", 4800, 0)]),
-    p("luck", "luck", &[("luck", 6000, 0)]),
-    p("slow_falling", "slow_falling", &[("slow_falling", 1800, 0)]),
-    p(
-        "long_slow_falling",
-        "slow_falling",
-        &[("slow_falling", 4800, 0)],
-    ),
-    p("wind_charged", "wind_charged", &[("wind_charged", 3600, 0)]),
-    p("weaving", "weaving", &[("weaving", 3600, 0)]),
-    p("oozing", "oozing", &[("oozing", 3600, 0)]),
-    p("infested", "infested", &[("infested", 3600, 0)]),
-];
-pub fn potion(id: &str) -> Option<&'static PotionDef> {
-    let id = id.trim_start_matches("minecraft:");
-    POTIONS.iter().find(|p| p.id == id)
-}
-/// `PotionContents.BASE_POTION_COLOR` (ARGB -13083194) as RGB.
-pub const BASE_POTION_COLOR: u32 = 0x385DC6;
-/// `PotionContents.getColor`: amplifier-weighted mix of visible effect colours.
-pub fn potion_color(id: Option<&str>) -> u32 {
-    let Some(def) = id.and_then(potion) else {
-        return BASE_POTION_COLOR;
-    };
-    let (mut r, mut g, mut b, mut total) = (0u32, 0u32, 0u32, 0u32);
-    for (e, _, amp) in def.effects {
-        let Some(e) = effect(e) else { continue };
-        let w = *amp as u32 + 1;
-        r += w * (e.color >> 16 & 255);
-        g += w * (e.color >> 8 & 255);
-        b += w * (e.color & 255);
-        total += w;
-    }
-    match (
-        r.checked_div(total),
-        g.checked_div(total),
-        b.checked_div(total),
-    ) {
-        (Some(r), Some(g), Some(b)) => (r << 16) | (g << 8) | b,
-        _ => BASE_POTION_COLOR,
-    }
-}
+pub use horizon_client_core::potions::{
+    BASE_POTION_COLOR, Category, EFFECTS, EffectDef, POTIONS, PotionDef, effect, namespaced,
+    potion, potion_color,
+};
 /// `MobEffectUtil.formatDuration` at 20 TPS: m:ss or h:mm:ss.
 pub fn format_duration(ticks: i32) -> String {
     let secs = ticks / 20;
diff --git a/crates/horizon-client/src/effects.rs b/crates/horizon-client/src/effects.rs
index 387de78b6..9511fd112 100644
--- a/crates/horizon-client/src/effects.rs
+++ b/crates/horizon-client/src/effects.rs
@@ -2,7 +2,7 @@
 //! add/update with hidden effects, per-tick application of the periodic
 //! effects (regeneration, poison, wither, hunger, saturation, instant
 //! effects), and the derived flags the movement and damage code read.
-use crate::brewing;
+use horizon_client_core::potions;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct EffectInstance {
@@ -183,7 +183,7 @@ impl PlayerEffects {
     pub fn from_saved(saved: &[(String, i32, i32, bool, bool)]) -> Self {
         let mut effects = Self::default();
         for (id, duration, amplifier, ambient, particles) in saved {
-            if let Some(def) = brewing::effect(id) {
+            if let Some(def) = potions::effect(id) {
                 let mut e = EffectInstance::new(def.id, *duration, *amplifier);
                 e.ambient = *ambient;
                 e.visible = *particles;
@@ -306,10 +306,10 @@ impl PlayerEffects {
     ) -> (Vec<EffectInstance>, Vec<EffectAction>) {
         let mut lasting = Vec::new();
         let mut now = Vec::new();
-        if let Some(def) = potion.and_then(brewing::potion) {
+        if let Some(def) = potion.and_then(potions::potion) {
             for (id, duration, amp) in def.effects {
-                let id = brewing::effect(id).map_or("speed", |e| e.id);
-                if brewing::effect(id).is_some_and(|e| e.instant) {
+                let id = potions::effect(id).map_or("speed", |e| e.id);
+                if potions::effect(id).is_some_and(|e| e.instant) {
                     now.extend(instant(id, *amp, 1.0));
                 } else {
                     // withScaledDuration: max(floor(d * scale), 1).
diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs
index c6b098f75..8af2c2a0d 100644
--- a/crates/horizon-client/src/hud_overlays.rs
+++ b/crates/horizon-client/src/hud_overlays.rs
@@ -107,10 +107,11 @@ pub struct EffectIcon {
 
 impl From<&crate::effects::EffectInstance> for EffectIcon {
     fn from(effect: &crate::effects::EffectInstance) -> Self {
-        let def = crate::brewing::effect(effect.id);
+        let def = horizon_client_core::potions::effect(effect.id);
         Self {
             id: effect.id.to_owned(),
-            beneficial: def.is_some_and(|d| d.category == crate::brewing::Category::Beneficial),
+            beneficial: def
+                .is_some_and(|d| d.category == horizon_client_core::potions::Category::Beneficial),
             color: def.map_or(0, |d| d.color as i32),
             ambient: effect.ambient,
             duration: effect.duration,