Merge branch 'heads/pt3/3113' into union/pt3-1

Main's c5fe5d4bc added EndState::eye_positions (id and position, for
status); the hitbox view needs the previous and current positions.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

.claude/skills/vanilla-parity/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: vanilla-parity
+description: Fix a Horizon bug or gap so it behaves 1:1 like vanilla 26.3, starting from the port ledger (tools/port_ledger.py) instead of grepping. Use for any issue, Discord report or PR that makes Horizon match vanilla: "X doesn't work like in Java", a missing sound, particle, animation, mob behaviour, block rule, screen or packet.
+---
+
+# Vanilla parity with the port ledger
+
+The port ledger pairs every vanilla method with the Rust fn that ports it (or says it is missing, or needs
+no port) and lists where a port isn't wired like vanilla. Ask it first; grep only for what it can't answer.
+Full reference: `docs/port-ledger.md`.
+
+## 0. Have a fresh ledger
+
+```sh
+python3 tools/port_ledger.py build          # ~20 s; again after pulling main
+```
+
+It needs the vanilla jar (the launcher's `versions/26.3/26.3.jar`, or `--jar`) and/or the lab's decompiled
+sources (`python3 tools/lab.py decompile`, or `--sources DIR`). If `build` says it has no vanilla code, run
+the lab first; don't guess vanilla from memory.
+
+## 1. From the report to the code
+
+```sh
+python3 tools/port_ledger.py issue 3236                      # a GitHub issue number
+python3 tools/port_ledger.py issue "mooshroom stays red after lightning"   # or the report's text
+```
+
+It ranks the vanilla classes the report names and lists, per class, its Rust home files, where each method is
+ported, and the known gaps (`missing` rows from the verdict map, seam/client/drift gaps). Often the cause is
+already written there ("Type is not saved"). Then drill in:
+
+```sh
+python3 tools/port_ledger.py where MushroomCow.readAdditionalSaveData   # ports, callers, callees, gaps
+python3 tools/port_ledger.py class MushroomCow                          # every method: where, or missing
+python3 tools/port_ledger.py what crates/horizon-client/src/mobs/farm.rs:120   # which vanilla method a fn ports
+```
+
+A ledger answer is a lead, not a verdict: about 1 in 12 map rows is wrong. Read the vanilla method (path and
+line are in the output) and the Rust fn before changing anything.
+
+## 2. Port it the vanilla way
+
+- Translate the vanilla method, don't reinvent it: same order of operations, same constants, the same random
+  draws in the same order (`horizon_core::random`), Java `Math` through `horizon_core::jmath`.
+- Open the fn's doc with the vanilla method it ports: `` /// `MushroomCow.readAdditionalSaveData`: ... ``.
+  That one line is what makes the next agent find it.
+- Fix the path players run: single player is a client of the integrated server, so server logic lives in
+  `game/lan*.rs` and `src/lan/`, and what only the client's copy shows (particles, local sounds, hand
+  animation) must be reached from `game/remote*.rs`. A fix on the old in-frame path alone fixes nothing.
+- Look at the neighbours the ledger lists for the same class: a `client` or `seam` gap next to your fix is
+  usually the same bug on the other path.
+
+## 3. Before the PR
+
+```sh
+python3 tools/port_ledger.py check --base origin/main
+```
+
+It lists the ports your branch touches with their open gaps, citations to add, stale citations, and (against
+the base) the gaps the branch closes and opens. Close what belongs to your fix, cite what you ported, leave
+no new stale citation. If you ported a method the verdict map called `missing`, change its row in
+`tools/port_map/*.tsv` to `port` with the fn (`file.rs::Owner::fn`) and run
+`python3 tools/port_ledger.py map-check tools/port_map/<file>.tsv`.
+
+Then the usual: the harness for the area (`docs/architecture.md`), `cargo check`/tests per `AGENTS.md`, and
+a small PR that says which vanilla method it now matches.
+
+## Finding work
+
+```sh
+python3 tools/port_ledger.py gaps --kind seam      # ported on two paths, wired on one: the best leads
+python3 tools/port_ledger.py gaps --kind client    # client-only effects the server path never reaches
+python3 tools/port_ledger.py gaps --kind drift     # a port missing a sound, particle, item or constant
+rg -n "player:" tools/port_map/*.tsv               # missing behaviour a player would see
+```

AGENTS.md

@@ -35,11 +35,12 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 
 | Crate | Owns |
 |---|---|
-| `horizon-client` | The game: a lib (`src/lib.rs`, ~170 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`, ~100 flat modules: gameplay, networking, title screens) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) |
 | `horizon-items` | Blocks and items below gameplay: `blocks.rs` (block facts), `items.rs`, `item_data.rs` (components), `enchant.rs`, `cooldowns.rs`, `bundle.rs`, `item_nbt.rs`. Re-exported as `horizon_client::items`... |
 | `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-client-input` | Key bindings and key names, toggle keys, mouse options, controller settings and glyphs, the clipboard, window options (`keybinds.rs`, `gamepad.rs`, `mouse.rs`, `window.rs`...). Re-exported under the old paths |
+| `horizon-client-render` | The client's world data, rendering and screens (chunks, meshing, light, streaming, `gfx`, HUD, menus, settings): ~80 modules that horizon-client re-exports under the same paths. Nothing in it reaches gameplay |
 | `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` |
@@ -99,6 +100,9 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 
 ## Vanilla reference
 
+- Start parity work from the port ledger, not grep: `python3 tools/port_ledger.py issue N` (or `where
+  Class.method`, `what file:line`), and `check --base origin/main` before the PR. How:
+  [.claude/skills/vanilla-parity/SKILL.md](.claude/skills/vanilla-parity/SKILL.md), [docs/port-ledger.md](docs/port-ledger.md).
 - Decompiled sources: `.local/minecraft/26.3/sources/{client,server}/` (`python3 tools/lab.py decompile`).
 - Bytecode queries (callers through lambdas, every overload):
   `python3 tools/rea_vanilla.py method net.minecraft.world.level.block.DispenserBlock dispenseFrom`
@@ -110,7 +114,8 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 
 ## horizon-client: where things live
 
-`L:` = lib (`crates/horizon-client/src/`), `G:` = bin (`crates/horizon-client/src/game/`). The lib can't see
+`L:` = lib (`crates/horizon-client/src/`, or `crates/horizon-client-render/src/` for the modules that crate holds, under
+the same `horizon_client::<module>` paths), `G:` = bin (`crates/horizon-client/src/game/`). The lib can't see
 `Game`; bin code reaches the lib as `horizon_client::<module>`.
 
 | Subsystem | Files |

Cargo.lock

@@ -1378,7 +1378,6 @@ dependencies = [
  "ab_glyph",
  "bytemuck",
  "chrono",
- "cpal",
  "flate2",
  "gilrs",
  "glam",
@@ -1386,6 +1385,7 @@ dependencies = [
  "horizon-bench",
  "horizon-client-core",
  "horizon-client-input",
+ "horizon-client-render",
  "horizon-command",
  "horizon-core",
  "horizon-dualsense",
@@ -1412,7 +1412,6 @@ dependencies = [
  "serde_json",
  "sha1",
  "sha2",
- "symphonia",
  "unicode-bidi",
  "ureq",
  "wgpu",
@@ -1441,6 +1440,48 @@ dependencies = [
  "winit",
 ]
 
+[[package]]
+name = "horizon-client-render"
+version = "0.1.0"
+dependencies = [
+ "ab_glyph",
+ "bytemuck",
+ "chrono",
+ "cpal",
+ "flate2",
+ "glam",
+ "horizon-assets",
+ "horizon-bench",
+ "horizon-client-core",
+ "horizon-client-input",
+ "horizon-command",
+ "horizon-core",
+ "horizon-hdr",
+ "horizon-items",
+ "horizon-protocol",
+ "horizon-shader-api",
+ "horizon-shaders",
+ "horizon-telemetry",
+ "horizon-theme",
+ "horizon-threads",
+ "horizon-world",
+ "log",
+ "miniz_oxide 0.8.9",
+ "naga",
+ "png",
+ "pollster",
+ "rustix 1.1.5",
+ "serde",
+ "serde_json",
+ "sha2",
+ "symphonia",
+ "unicode-bidi",
+ "ureq",
+ "wgpu",
+ "winit",
+ "zip",
+]
+
 [[package]]
 name = "horizon-command"
 version = "0.1.0"

Cargo.toml

@@ -9,6 +9,7 @@ members = [
     "crates/horizon-client",
     "crates/horizon-client-core",
     "crates/horizon-client-input",
+    "crates/horizon-client-render",
     "crates/horizon-command",
     "crates/horizon-items",
     "crates/horizon-server-files",

crates/horizon-client-core/src/component.rs

@@ -1,6 +1,6 @@
 //! Text components from commands: `ComponentArgument` reads an SNBT (or JSON)
 //! value, `ComponentSerialization` turns it into styled text.
-use crate::text::{Style, Text, named_color};
+use crate::text::{InlineObject, Style, Text, named_color};
 use horizon_world::nbt::Tag;
 use serde_json::{Map, Value};
 
@@ -263,6 +263,10 @@ pub fn to_text_with(
             let style = object_style(o);
             let content = if let Some(t) = contents(o) {
                 t
+            } else if let Some(object) = inline_object(o, resolve, contents) {
+                let mut text = Text::literal("\u{fffc}");
+                text.spans[0].style.inline_object = Some(object);
+                text
             } else if let Some(t) = o.get("text") {
                 match t {
                     Value::String(s) => Text::literal(s.clone()),
@@ -299,12 +303,45 @@ pub fn to_text_with(
             {
                 out.push(to_text_with(extra, resolve, contents).with_style(&style));
             }
-            out
+            if o.contains_key("object") || o.contains_key("player") || o.contains_key("sprite") {
+                out.with_component(Value::Object(o.clone()))
+            } else {
+                out
+            }
         }
         Value::Null => Text::empty(),
     }
 }
 
+fn inline_object(
+    object: &serde_json::Map<String, Value>,
+    resolve: &mut dyn FnMut(&str) -> Text,
+    contents: &mut dyn FnMut(&serde_json::Map<String, Value>) -> Option<Text>,
+) -> Option<InlineObject> {
+    let kind = object.get("object").and_then(Value::as_str);
+    let fallback = object
+        .get("fallback")
+        .map(|value| to_text_with(value, resolve, contents).plain())
+        .unwrap_or_default();
+    match kind {
+        Some("player") | None if object.contains_key("player") => Some(InlineObject::Player {
+            profile: object.get("player")?.clone(),
+            hat: object.get("hat").and_then(Value::as_bool).unwrap_or(true),
+            fallback,
+        }),
+        Some("atlas") | None if object.contains_key("sprite") => Some(InlineObject::Atlas {
+            atlas: object
+                .get("atlas")
+                .and_then(Value::as_str)
+                .unwrap_or("minecraft:blocks")
+                .to_owned(),
+            sprite: object.get("sprite")?.as_str()?.to_owned(),
+            fallback,
+        }),
+        _ => None,
+    }
+}
+
 /// `CustomName` as text: a string keeps its legacy formatting codes, anything
 /// else is a component (`ComponentSerialization`).
 pub fn name_text(tag: &Tag) -> Text {
@@ -318,6 +355,32 @@ pub fn name_text(tag: &Tag) -> Text {
 mod tests {
     use super::*;
 
+    #[test]
+    fn player_object_survives_text_parsing_and_keeps_its_siblings() {
+        let component = serde_json::json!({
+            "text": "<",
+            "extra": [
+                {"object": "player", "player": {"name": "elyapluggin"}, "hat": false,
+                 "fallback": "[head]"},
+                {"text": " >", "color": "gold"}
+            ]
+        });
+        let text = to_text(&component, &mut |_| Text::empty());
+        assert_eq!(text.plain(), "<[head] >");
+        assert!(matches!(
+            &text.spans[1].style.inline_object,
+            Some(InlineObject::Player { hat: false, .. })
+        ));
+        assert!(text.spans[2].style.inline_object.is_none());
+        assert_eq!(text.component(), component);
+        let sprite = serde_json::json!({"object": "atlas", "sprite": "minecraft:item/porkchop"});
+        let text = to_text(&sprite, &mut |_| Text::empty());
+        assert!(matches!(
+            &text.spans[0].style.inline_object,
+            Some(InlineObject::Atlas { sprite, .. }) if sprite == "minecraft:item/porkchop"
+        ));
+    }
+
     #[test]
     fn snbt_and_json_components() {
         let input = "{text:'Hi ',color:red,extra:[{text:\"there\",bold:1b}]} rest";

crates/horizon-client-core/src/lang.rs

@@ -40,6 +40,10 @@ static BIDIRECTIONAL: AtomicBool = AtomicBool::new(false);
 /// A source of resource files: the prepared root plus packs, highest priority last.
 pub trait ResourceSource {
     fn read(&self, path: &str) -> Option<Vec<u8>>;
+    /// Whether `path` is there, without reading it where the source can tell.
+    fn exists(&self, path: &str) -> bool {
+        self.read(path).is_some()
+    }
     /// The namespaces under `assets/` (resource packs may add their own).
     fn namespaces(&self) -> Vec<String> {
         vec!["minecraft".into()]
@@ -68,6 +72,9 @@ impl ResourceSource for std::path::PathBuf {
     fn read(&self, path: &str) -> Option<Vec<u8>> {
         std::fs::read(self.join(path)).ok()
     }
+    fn exists(&self, path: &str) -> bool {
+        self.join(path).is_file()
+    }
     fn namespaces(&self) -> Vec<String> {
         std::fs::read_dir(self.join("assets"))
             .into_iter()
@@ -190,7 +197,7 @@ pub fn available(sources: &[&dyn ResourceSource]) -> Vec<LanguageInfo> {
             for (code, info) in value["language"].as_object().into_iter().flatten() {
                 // Only languages whose file exists somewhere are selectable.
                 let file = format!("assets/minecraft/lang/{code}.json");
-                if code != DEFAULT && !sources.iter().any(|s| s.read(&file).is_some()) {
+                if code != DEFAULT && !sources.iter().any(|s| s.exists(&file)) {
                     continue;
                 }
                 found.insert(
@@ -284,4 +291,26 @@ mod tests {
         );
         assert_eq!(langs[1].label(), "Français (France)");
     }
+
+    #[test]
+    fn languages_are_listed_without_reading_their_files() {
+        struct NoLangReads;
+        impl ResourceSource for NoLangReads {
+            fn read(&self, path: &str) -> Option<Vec<u8>> {
+                assert!(!path.contains("/lang/"), "read {path}");
+                (path == "assets/pack.mcmeta").then(|| {
+                    br#"{"language":{"fr_fr":{"name":"French"},"de_de":{"name":"German"}}}"#
+                        .to_vec()
+                })
+            }
+            fn exists(&self, path: &str) -> bool {
+                path == "assets/minecraft/lang/fr_fr.json"
+            }
+        }
+        let langs = available(&[&NoLangReads]);
+        assert_eq!(
+            langs.iter().map(|l| l.code.as_str()).collect::<Vec<_>>(),
+            ["en_us", "fr_fr"]
+        );
+    }
 }

crates/horizon-client-core/src/text.rs

@@ -58,6 +58,28 @@ pub enum ClickEvent {
     OpenFile(String),
 }
 
+/// A non-character `minecraft:object` embedded in a text component.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum InlineObject {
+    Player {
+        profile: Value,
+        hat: bool,
+        fallback: String,
+    },
+    Atlas {
+        atlas: String,
+        sprite: String,
+        fallback: String,
+    },
+}
+impl InlineObject {
+    pub fn fallback(&self) -> &str {
+        match self {
+            Self::Player { fallback, .. } | Self::Atlas { fallback, .. } => fallback,
+        }
+    }
+}
+
 /// Text style; `None` fields inherit from the enclosing style.
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct Style {
@@ -77,6 +99,8 @@ pub struct Style {
     /// The font (`FontDescription.Resource`), a full id like
     /// `minecraft:alt`; the default font when unset.
     pub font: Option<String>,
+    /// Content metadata for a single U+FFFC object span; never inherited.
+    pub inline_object: Option<InlineObject>,
 }
 /// A style's `font` field: an identifier (`alt` is `minecraft:alt`).
 pub fn font_id(v: &Value) -> Option<String> {
@@ -337,7 +361,13 @@ impl Text {
     }
     /// Component.getString: the plain characters.
     pub fn plain(&self) -> String {
-        self.spans.iter().map(|s| s.text.as_str()).collect()
+        self.spans
+            .iter()
+            .map(|s| match &s.style.inline_object {
+                Some(object) if s.text == "\u{fffc}" => object.fallback(),
+                _ => s.text.as_str(),
+            })
+            .collect()
     }
     pub fn is_empty(&self) -> bool {
         self.spans.iter().all(|s| s.text.is_empty())

crates/horizon-client-render/Cargo.toml

@@ -0,0 +1,67 @@
+[package]
+name = "horizon-client-render"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+rust-version = "1.90"
+description = "The client's world data, rendering and screens: chunks, meshing, light, streaming, the renderer, the HUD, menus and settings; no gameplay"
+
+[dependencies]
+horizon-assets = { path = "../horizon-assets" }
+horizon-bench = { path = "../horizon-bench" }
+horizon-client-core = { path = "../horizon-client-core" }
+horizon-client-input = { path = "../horizon-client-input" }
+horizon-command = { path = "../horizon-command" }
+horizon-core = { path = "../horizon-core" }
+horizon-hdr = { path = "../horizon-hdr" }
+horizon-items = { path = "../horizon-items" }
+horizon-protocol = { path = "../horizon-protocol" }
+horizon-shader-api = { path = "../horizon-shader-api" }
+horizon-shaders = { path = "../horizon-shaders" }
+horizon-telemetry = { path = "../horizon-telemetry", default-features = false, features = ["live"] }
+horizon-theme = { path = "../horizon-theme" }
+horizon-threads = { path = "../horizon-threads" }
+horizon-world = { path = "../horizon-world" }
+ab_glyph = "0.2.32"
+bytemuck = { version = "1.24", features = ["derive"] }
+# Sound (ALSA on Linux); the `audio` feature.
+cpal = { version = "0.16", optional = true }
+chrono = { version = "0.4.42", default-features = false, features = ["clock", "std"] }
+flate2 = { version = "1.1.10", default-features = false, features = ["zlib-rs", "runtime_detection"] }
+glam = "0.30"
+log = "0.4"
+miniz_oxide = "0.8"
+naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out"] }
+png = "0.18"
+pollster = "0.4"
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1.0.151", features = ["raw_value"] }
+sha2 = "0.10.9"
+symphonia = { version = "0.5", default-features = false, features = ["ogg", "vorbis"] }
+unicode-bidi = "0.3.18"
+ureq = { version = "2", default-features = false, features = ["tls"] }
+wgpu = { version = "30.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "metal", "wgsl", "naga-ir"] }
+winit = "0.30.13"
+zip = { version = "2", default-features = false, features = ["deflate"] }
+
+[target.'cfg(unix)'.dependencies]
+rustix = { version = "1", default-features = false, features = ["std", "time"] }
+
+[target.'cfg(windows)'.dependencies]
+wgpu = { version = "30.0.1", default-features = false, features = ["dx12"] }
+
+[target.'cfg(not(target_os = "macos"))'.dependencies]
+wgpu = { version = "30.0.1", default-features = false, features = ["gles"] }
+
+[features]
+# Sound output: horizon-client's `audio` feature.
+audio = ["dep:cpal"]
+# Helpers horizon-client's tests build their fixtures with.
+test-support = []
+
+[lints]
+workspace = true
+
+[dev-dependencies]
+horizon-items = { path = "../horizon-items", features = ["test-support"] }
+naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out", "msl-out", "spv-out"] }

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

@@ -42,11 +42,11 @@ impl HeightmapState for StateFacts {
 }
 #[derive(Clone)]
 pub struct Properties(Arc<Vec<StateFacts>>);
-#[cfg(test)]
+#[cfg(any(test, feature = "test-support"))]
 impl Properties {
     /// Heightmap facts for tests, per state: (air, has a fluid, blocks
     /// motion, blocks motion but is not leaves). State 0 is minecraft:air.
-    pub(crate) fn for_tests(states: &[(bool, bool, bool, bool)]) -> Self {
+    pub fn for_tests(states: &[(bool, bool, bool, bool)]) -> Self {
         Self(Arc::new(
             states
                 .iter()
@@ -196,7 +196,7 @@ impl Assets {
 impl RenderAssets {
     pub fn load(root: &Path, assets: &Assets) -> Result<Self> {
         let registry = assets.registry;
-        let mut sprites = crate::sprites::Sprites::default();
+        let mut sprites = crate::sprites::Sprites::with_disk_cache(root);
         for name in MATERIALS {
             sprites.insert(root, &format!("minecraft:block/{name}"))?;
         }
@@ -217,6 +217,7 @@ impl RenderAssets {
         for stage in 0..10 {
             sprites.insert(root, &format!("minecraft:block/destroy_stage_{stage}"))?;
         }
+        sprites.save_disk_cache();
         sprites.finish();
         // `finish` grows the buffer by doubling: keep only the bytes in use.
         sprites.pixels.shrink_to_fit();

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

@@ -187,7 +187,14 @@ pub fn list_textures(root: &Path) -> Vec<String> {
             };
             for e in entries.flatten() {
                 let p = e.path();
-                if p.is_dir() {
+                // `file_type` comes with the listing; `Path::is_dir` is a stat per
+                // entry, kept for links (which it follows).
+                let dir = match e.file_type() {
+                    Ok(t) if t.is_symlink() => p.is_dir(),
+                    Ok(t) => t.is_dir(),
+                    Err(_) => p.is_dir(),
+                };
+                if dir {
                     stack.push(p);
                 } else if p.extension().is_some_and(|x| x == "png")
                     && let Ok(rel) = p.strip_prefix(&base)

crates/horizon-client-render/src/chunk/block_entity.rs

@@ -230,7 +230,7 @@ pub struct Info {
 /// `VibrationSelector`: the closest, then highest-frequency candidate of a tick.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct Selector {
-    pub(crate) current: Option<(Info, i64)>,
+    pub current: Option<(Info, i64)>,
 }
 /// `VibrationSystem.Data`.
 #[derive(Clone, Debug, Default, PartialEq)]
@@ -278,7 +278,7 @@ pub struct SpawnData {
 /// Which `SpawnData` is next: one of the potentials (the same object in
 /// vanilla, so changing it changes the potential) or its own.
 #[derive(Clone, Debug, PartialEq)]
-pub(crate) enum Next {
+pub enum Next {
     Potential(usize),
     Own(SpawnData),
 }
@@ -288,7 +288,7 @@ pub struct Spawner {
     pub spawn_delay: i32,
     /// `SpawnPotentials`: data and weight.
     pub potentials: Vec<(SpawnData, i32)>,
-    pub(crate) next: Option<Next>,
+    pub next: Option<Next>,
     pub min_spawn_delay: i32,
     pub max_spawn_delay: i32,
     pub spawn_count: i32,
@@ -301,6 +301,24 @@ pub struct Spawner {
     pub spin: f64,
     pub o_spin: f64,
 }
+impl Default for Spawner {
+    fn default() -> Self {
+        Self {
+            spawn_delay: 20,
+            potentials: Vec::new(),
+            next: None,
+            min_spawn_delay: 200,
+            max_spawn_delay: 800,
+            spawn_count: 4,
+            max_nearby_entities: 6,
+            required_player_range: 16,
+            spawn_range: 4,
+            client_delay: 20,
+            spin: 0.0,
+            o_spin: 0.0,
+        }
+    }
+}
 /// `TrialSpawnerConfig`.
 #[derive(Clone, Debug, PartialEq)]
 pub struct TrialConfig {
@@ -314,6 +332,26 @@ pub struct TrialConfig {
     pub loot_tables_to_eject: Vec<(String, i32)>,
     pub items_to_drop_when_ominous: String,
 }
+impl Default for TrialConfig {
+    /// `TrialSpawnerConfig.Builder`'s defaults.
+    fn default() -> Self {
+        Self {
+            spawn_range: 4,
+            total_mobs: 6.0,
+            simultaneous_mobs: 2.0,
+            total_mobs_added_per_player: 2.0,
+            simultaneous_mobs_added_per_player: 1.0,
+            ticks_between_spawn: 40,
+            spawn_potentials: Vec::new(),
+            loot_tables_to_eject: vec![
+                ("minecraft:spawners/trial_chamber/consumables".into(), 1),
+                ("minecraft:spawners/trial_chamber/key".into(), 1),
+            ],
+            items_to_drop_when_ominous:
+                "minecraft:spawners/trial_chamber/items_to_drop_when_ominous".into(),
+        }
+    }
+}
 /// A `Holder<TrialSpawnerConfig>` as saved: a registry id
 /// (`minecraft:trial_chamber/breeze/normal`) or an inline config.
 #[derive(Clone, Debug, Default, PartialEq)]
@@ -347,6 +385,28 @@ pub struct TrialSpawner {
     /// and their weights (the rolled counts).
     pub dispensing: Option<Vec<ItemStack>>,
 }
+impl Default for TrialSpawner {
+    fn default() -> Self {
+        Self {
+            normal: ConfigSlot::default(),
+            ominous: ConfigSlot::default(),
+            target_cooldown_length: 36000,
+            required_player_range: 14,
+            detected_players: Vec::new(),
+            current_mobs: Vec::new(),
+            cooldown_ends_at: 0,
+            next_mob_spawns_at: 0,
+            total_mobs_spawned: 0,
+            next_spawn_data: None,
+            ejecting_loot_table: None,
+            is_ominous: false,
+            has_display: false,
+            spin: 0.0,
+            o_spin: 0.0,
+            dispensing: None,
+        }
+    }
+}
 /// `VaultConfig`.
 #[derive(Clone, Debug, PartialEq)]
 pub struct VaultConfig {

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

@@ -330,7 +330,7 @@ pub fn stack_lines(backtrace: &str, from_panic: bool) -> String {
     // separator the build machine used.
     let manifest = env!("CARGO_MANIFEST_DIR").replace('\\', "/");
     let root = manifest
-        .strip_suffix("crates/horizon-client")
+        .strip_suffix("crates/horizon-client-render")
         .unwrap_or(&manifest);
     let mut frames: Vec<(String, Option<String>)> = Vec::new();
     for line in backtrace.lines() {
@@ -605,7 +605,7 @@ mod tests {
         );
         assert_eq!(
             stack_lines(&bt, true),
-            "horizon_client::crash::debug_crash_tick (crates/horizon-client/src/crash.rs:359:9)\nwinit::dispatch (winit-0.30.13/src/event_loop.rs:642:56)\nmain\n"
+            "horizon_client::crash::debug_crash_tick (crates/horizon-client-render/src/crash.rs:359:9)\nwinit::dispatch (winit-0.30.13/src/event_loop.rs:642:56)\nmain\n"
         );
     }
 

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

@@ -203,6 +203,13 @@ pub struct FogInputs<'a> {
     /// `BossHealthOverlay.shouldCreateWorldFog`: a boss bar with
     /// `createWorldFog` is shown (the Ender Dragon's).
     pub boss_world_fog: bool,
+    /// The camera entity is a spectator (`LavaFogEnvironment`).
+    pub spectator: bool,
+    /// The camera entity has Fire Resistance (`LavaFogEnvironment`).
+    pub fire_resistance: bool,
+    /// `GameRenderer.nightVisionScale` while Night Vision is on without
+    /// Darkness, else 0 (`FogRenderer.computeFogColor`'s brightenFactor).
+    pub night_vision: f32,
 }
 
 /// `FogRenderer.setupFog` + `computeFogColor`.
@@ -272,7 +279,11 @@ pub fn setup_fog(tables: &FogTables, state: &FogState, input: &FogInputs) -> Fog
         color[1] += (color[1] * 0.6 - color[1]) * t;
         color[2] += (color[2] * 0.6 - color[2]) * t;
     }
-    let brighten = if eye_in_water { water_vision } else { 0.0 };
+    let brighten = if eye_in_water {
+        water_vision
+    } else {
+        input.night_vision
+    };
     if color.iter().all(|&c| c != 0.0) {
         let scale = 1.0 / color[0].max(color[1]).max(color[2]);
         color = color.map(|c| c + (c * scale - c) * brighten);
@@ -288,10 +299,16 @@ pub fn setup_fog(tables: &FogTables, state: &FogState, input: &FogInputs) -> Fog
     };
     match input.fog_type {
         FogType::Lava => {
-            fog.environmental_start = 0.25;
-            fog.environmental_end = 1.0;
-            fog.sky_end = 1.0;
-            fog.cloud_end = 1.0;
+            // LavaFogEnvironment.setupFog.
+            (fog.environmental_start, fog.environmental_end) = if input.spectator {
+                (-8.0, rd * 0.5)
+            } else if input.fire_resistance {
+                (0.0, 5.0)
+            } else {
+                (0.25, 1.0)
+            };
+            fog.sky_end = fog.environmental_end;
+            fog.cloud_end = fog.environmental_end;
         }
         FogType::PowderSnow => {
             fog.environmental_start = 0.0;
@@ -405,6 +422,9 @@ mod tests {
             darkness: None,
             darken_world: 0.0,
             boss_world_fog: false,
+            spectator: false,
+            fire_resistance: false,
+            night_vision: 0.0,
         }
     }
     #[test]

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

@@ -896,6 +896,9 @@ impl Font {
         std::mem::take(&mut self.cache.borrow_mut().region.pending)
     }
     pub fn advance(&self, c: char, style: &Style) -> f32 {
+        if c == '\u{fffc}' && style.inline_object.is_some() {
+            return 8.0;
+        }
         let g = self.glyph_styled(c, style);
         g.advance + if style.is_bold() { g.offset } else { 0.0 }
     }

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

@@ -570,6 +570,7 @@ impl Item {
 pub enum Action {
     ButtonClick,
     Changed,
+    SliderDrag,
     OpenAdvanced,
     OpenSimple,
     Done,
@@ -800,7 +801,7 @@ impl GraphicsUi {
                     .find(|wd| matches!(wd.target, Target::Item(i) if i == item))
             {
                 item.set_slider(s, ui::slider_value(wd.x, wd.w, x));
-                return vec![Action::Changed];
+                return vec![Action::SliderDrag];
             }
             return Vec::new();
         }
@@ -822,11 +823,11 @@ impl GraphicsUi {
                     if item.slider(s).is_some() {
                         self.dragging = Some(item);
                         item.set_slider(s, ui::slider_value(wd.x, wd.w, x));
+                        vec![Action::SliderDrag]
                     } else {
                         item.cycle(s, right, framebuffer);
-                        return vec![Action::ButtonClick, Action::Changed];
+                        vec![Action::ButtonClick, Action::Changed]
                     }
-                    vec![Action::Changed]
                 }
             };
         }
@@ -897,7 +898,7 @@ mod tests {
                 false,
                 false
             ),
-            vec![Action::Changed]
+            vec![Action::SliderDrag]
         );
         assert_eq!(
             ui.click(
@@ -909,7 +910,7 @@ mod tests {
                 true,
                 false
             ),
-            vec![Action::Changed]
+            vec![Action::SliderDrag]
         );
         assert!(ui.release());
         assert!(!ui.release());

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

@@ -59,6 +59,8 @@ pub struct HudAtlas {
     pub width: u32,
     pub height: u32,
     pub sprites: HashMap<String, Rect>,
+    /// Resolved player-profile names and UUIDs for inline head components.
+    pub object_skins: HashMap<String, String>,
     /// Sprites with a 0 < alpha < 255 texel (`SpriteContents.transparency().hasTranslucent`),
     /// which puts their particles on vanilla's translucent layer.
     pub translucent: HashSet<String>,
@@ -252,6 +254,24 @@ fn atlas_sprites(root: &Path, packed: &[PackedImage]) -> Vec<PackedImage> {
     out.into_iter().map(|(_, image)| image).collect()
 }
 impl HudAtlas {
+    /// Keep a ready profile skin when another source only has its default.
+    pub fn set_object_skin(&mut self, key: String, skin: String) {
+        use std::collections::hash_map::Entry;
+        if self.object_skins.len() >= 1024 && !self.object_skins.contains_key(&key) {
+            self.object_skins.clear();
+        }
+        match self.object_skins.entry(key) {
+            Entry::Occupied(entry)
+                if skin.starts_with("entity/player/") && self.sprites.contains_key(entry.get()) => {
+            }
+            Entry::Occupied(mut entry) => {
+                entry.insert(skin);
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(skin);
+            }
+        }
+    }
     /// A font glyph's atlas cell (8x8 GUI pixels) and advance.
     pub fn glyph(&self, ch: char) -> Option<(Rect, f32)> {
         let g = self.font.glyph(ch);
@@ -592,6 +612,7 @@ impl HudAtlas {
             width,
             height,
             sprites,
+            object_skins: HashMap::new(),
             translucent,
             flags,
             sprite_animations,
@@ -641,6 +662,8 @@ pub struct HudBatch {
     pub glint_alpha: f32,
     /// Screen's first vertex: the preceding HUD is part of its blurred background.
     pub blur_at: u32,
+    /// Player object profiles encountered while painting text this frame.
+    pub inline_profiles: Vec<serde_json::Value>,
 }
 /// How a run of HUD vertices blends and tests depth.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -692,6 +715,7 @@ impl HudBatch {
             end_portal: EndPortalFill::default(),
             glint_alpha: 0.75,
             blur_at: 0,
+            inline_profiles: Vec::new(),
         }
     }
     /// Draw the vertices added since `start` with the inverting blend.
@@ -1012,17 +1036,38 @@ impl HudBatch {
         let mut glyphs = Vec::new();
         let mut cursor = x;
         for (i, (ch, style)) in text.chars().enumerate() {
+            let object = (ch == '\u{fffc}')
+                .then_some(style.inline_object.as_ref())
+                .flatten();
+            if let Some(crate::text::InlineObject::Player { profile, .. }) = object
+                && self.inline_profiles.len() < 256
+                && !self.inline_profiles.contains(profile)
+            {
+                self.inline_profiles.push(profile.clone());
+            }
             // The style's font (`Style.getFont`), the default one unless set.
-            let mut g = font.glyph_styled(ch, style);
+            let mut g = if object.is_some() {
+                crate::font::Glyph {
+                    rect: None,
+                    left: 0.0,
+                    top: 0.0,
+                    right: 0.0,
+                    bottom: 8.0,
+                    advance: 8.0,
+                    offset: 0.0,
+                }
+            } else {
+                font.glyph_styled(ch, style)
+            };
             // Font.StringRenderOutput.accept: obfuscated characters draw a
             // random glyph of the same width each frame.
-            if style.obfuscated == Some(true) && ch != ' ' {
+            if object.is_none() && style.obfuscated == Some(true) && ch != ' ' {
                 g = font.random_glyph(style, g.advance);
             }
             let c = style.color.map_or(color, |rgb| {
                 rgba((rgb >> 16) as u8, (rgb >> 8) as u8, rgb as u8, alpha)
             });
-            let bold = style.is_bold();
+            let bold = object.is_none() && style.is_bold();
             let advance = g.advance + if bold { g.offset } else { 0.0 };
             glyphs.push((
                 cursor,
@@ -1034,6 +1079,7 @@ impl HudBatch {
                 style.strikethrough == Some(true),
                 i == 0,
                 advance,
+                object.cloned(),
             ));
             cursor += advance;
         }
@@ -1041,7 +1087,13 @@ impl HudBatch {
         let white = font.white();
         let passes: &[bool] = if shadow { &[true, false] } else { &[false] };
         for &is_shadow in passes {
-            for &(gx, g, c, bold, italic, underline, strike, first, advance) in &glyphs {
+            for (gx, g, c, bold, italic, underline, strike, first, advance, object) in &glyphs {
+                if let Some(object) = object {
+                    if !is_shadow {
+                        self.draw_inline_object(atlas, object, *gx, y, alpha);
+                    }
+                    continue;
+                }
                 let (dx, col) = if is_shadow {
                     let b = c.to_le_bytes();
                     (
@@ -1054,11 +1106,11 @@ impl HudBatch {
                         ),
                     )
                 } else {
-                    (0.0, c)
+                    (0.0, *c)
                 };
-                let (px, py) = (gx + dx, y + dx);
-                let shear = |v: f32| if italic { 1.0 - 0.25 * v } else { 0.0 };
-                let thick = if bold { 0.1 } else { 0.0 };
+                let (px, py) = (*gx + dx, y + dx);
+                let shear = |v: f32| if *italic { 1.0 - 0.25 * v } else { 0.0 };
+                let thick = if *bold { 0.1 } else { 0.0 };
                 let draw = |batch: &mut Self, ox: f32| match g.rect {
                     Some(r) => {
                         let (x0, x1, y0, y1) = (
@@ -1093,21 +1145,89 @@ impl HudBatch {
                     None => {}
                 };
                 draw(self, 0.0);
-                if bold {
+                if *bold {
                     draw(self, g.offset);
                 }
-                let x0 = if first { px - 1.0 } else { px };
-                if strike {
-                    self.rect_uv(x0, py + 3.5, px + advance - x0, 1.0, white, col);
+                let x0 = if *first { px - 1.0 } else { px };
+                if *strike {
+                    self.rect_uv(x0, py + 3.5, px + *advance - x0, 1.0, white, col);
                 }
-                if underline {
-                    self.rect_uv(x0, py + 8.0, px + advance - x0, 1.0, white, col);
+                if *underline {
+                    self.rect_uv(x0, py + 8.0, px + *advance - x0, 1.0, white, col);
                 }
             }
         }
         cursor - x
     }
+
+    fn draw_inline_object(
+        &mut self,
+        atlas: &HudAtlas,
+        object: &crate::text::InlineObject,
+        x: f32,
+        y: f32,
+        alpha: u8,
+    ) {
+        use crate::text::InlineObject;
+        let tint = rgba(255, 255, 255, alpha);
+        match object {
+            InlineObject::Player { profile, hat, .. } => {
+                let id = crate::skins::parse_profile(profile).id;
+                let name = inline_profile_name(profile);
+                let by_id = atlas.object_skins.get(&format!("id:{id:032x}"));
+                let by_name = name.and_then(|name| {
+                    atlas
+                        .object_skins
+                        .get(&format!("name:{}", name.to_ascii_lowercase()))
+                });
+                let resolved = if profile.get("id").is_some() {
+                    by_id.or(by_name)
+                } else {
+                    by_name.or(by_id)
+                };
+                let default = crate::tab_list::default_skin(id);
+                let skin = resolved
+                    .filter(|path| atlas.sprites.contains_key(*path))
+                    .map_or(default, String::as_str);
+                let Some(rect) = atlas.sprites.get(skin).copied() else {
+                    return;
+                };
+                for u in [8.0, 40.0].into_iter().take(if *hat { 2 } else { 1 }) {
+                    let du = (rect.u1 - rect.u0) / 64.0;
+                    let dv = (rect.v1 - rect.v0) / 64.0;
+                    self.rect_uv(
+                        x,
+                        y,
+                        8.0,
+                        8.0,
+                        Rect {
+                            u0: rect.u0 + du * u,
+                            v0: rect.v0 + dv * 8.0,
+                            u1: rect.u0 + du * (u + 8.0),
+                            v1: rect.v0 + dv * 16.0,
+                            w: 8,
+                            h: 8,
+                        },
+                        tint,
+                    );
+                }
+            }
+            InlineObject::Atlas { sprite, .. } => {
+                let key = sprite.strip_prefix("minecraft:").unwrap_or(sprite);
+                if let Some(rect) = atlas.sprites.get(key).copied() {
+                    self.rect_uv(x, y, 8.0, 8.0, rect, tint);
+                }
+            }
+        }
+    }
 }
+
+fn inline_profile_name(profile: &serde_json::Value) -> Option<&str> {
+    profile
+        .as_str()
+        .or_else(|| profile.get("name").and_then(serde_json::Value::as_str))
+}
+
 #[repr(C)]
 #[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
 struct HudUniform {
@@ -1822,6 +1942,56 @@ mod tests {
         assert!(missing.rect.is_none() && missing.right == 5.0);
     }
 
+    #[test]
+    fn player_object_draws_an_inline_head() {
+        let root = two_glyph_font("inline-head");
+        write_png(&root, "entity/player/slim/alex", 64, 64);
+        write_png(&root, "entity/player/wide/steve", 64, 64);
+        let mut atlas = HudAtlas::build(&root).unwrap();
+        let text = crate::component::to_text(
+            &serde_json::json!({"object":"player","player":{"id":"00000000-0000-0000-0000-000000000000"}}),
+            &mut |_| crate::text::Text::empty(),
+        );
+        let mut batch = HudBatch::new([320, 240]);
+        assert_eq!(
+            batch.text_styled(&atlas, &text, 10.0, 10.0, u32::MAX, false),
+            8.0
+        );
+        assert_eq!(batch.vertices.len(), 12); // face and hat, six vertices each
+        assert_eq!(batch.inline_profiles.len(), 1);
+        atlas.set_object_skin("name:elyapluggin".into(), "entity/player/wide/steve".into());
+        let named = crate::component::to_text(
+            &serde_json::json!({"object":"player","player":{"name":"elyapluggin"}}),
+            &mut |_| crate::text::Text::empty(),
+        );
+        batch.vertices.clear();
+        batch.text_styled(&atlas, &named, 10.0, 10.0, u32::MAX, false);
+        let skin = atlas.sprites["entity/player/wide/steve"];
+        assert_eq!(batch.vertices[0].uv[0], skin.u0 + (skin.u1 - skin.u0) / 8.0);
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn atlas_object_draws_an_item_sprite_inline() {
+        let root = two_glyph_font("inline-item");
+        write_png(&root, "item/porkchop", 16, 16);
+        let atlas = HudAtlas::build(&root).unwrap();
+        let text = crate::component::to_text(
+            &serde_json::json!({
+                "text": "a",
+                "extra": [{"object": "atlas", "sprite": "minecraft:item/porkchop"}]
+            }),
+            &mut |_| crate::text::Text::empty(),
+        );
+        let mut batch = HudBatch::new([320, 240]);
+        let width = batch.text_styled(&atlas, &text, 10.0, 10.0, u32::MAX, false);
+        assert_eq!(width, atlas.font.glyph('a').advance + 8.0);
+        assert_eq!(batch.vertices.len(), 12); // glyph and one sprite
+        let sprite = atlas.sprites["item/porkchop"];
+        assert_eq!(batch.vertices[6].uv, [sprite.u0, sprite.v0]);
+        fs::remove_dir_all(root).unwrap();
+    }
+
     #[test]
     fn effect_icons_are_painted_from_the_mob_effect_directory() {
         use crate::{effects::EffectInstance, hud_layout, hud_overlays, inventory_effects};
@@ -2008,6 +2178,7 @@ mod tests {
                 end_portal: EndPortalFill::default(),
                 glint_alpha: 0.75,
                 blur_at: 0,
+                inline_profiles: Vec::new(),
             };
             for (image_width, image_height) in [(195, 136), (176, 166), (176, 222)] {
                 assert_eq!(

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

@@ -0,0 +1,115 @@
+//! The client's world data, rendering and screens: chunks, meshing, light, streaming, the renderer,
+//! the HUD, menus and settings. Gameplay (horizon-client) builds on it; nothing here reaches gameplay.
+#![forbid(unsafe_code)]
+pub mod assets;
+pub mod atlas_sources;
+pub mod audio;
+pub mod auth;
+pub mod bidi;
+pub mod biome;
+pub mod block_entities;
+pub mod block_entity_anim;
+pub mod block_entity_render;
+pub mod border_render;
+pub mod breaking;
+pub mod brewing;
+pub mod camera;
+pub mod chat;
+pub mod chunk;
+pub mod chunk_map;
+pub mod clouds;
+pub mod collisions;
+pub mod command_block;
+pub mod containers;
+pub mod crash;
+pub mod datapack;
+pub mod dynamic_light;
+pub mod effects;
+pub mod environment;
+pub mod extras;
+pub mod fast_hash;
+pub mod fog;
+pub mod font;
+pub mod gfx;
+pub mod graphics;
+pub mod graphics_style;
+pub mod graphics_ui;
+pub mod hud;
+pub mod hud_layout;
+pub mod hud_overlays;
+pub mod inventory_effects;
+pub mod java_text;
+pub mod level_loading;
+pub mod light;
+pub mod lod;
+pub mod logging;
+pub mod menu_blur;
+pub mod mesher;
+pub mod minimap;
+pub mod mipmap;
+pub mod mod_list;
+pub mod model_library;
+pub mod models;
+pub mod options_file;
+pub mod options_fixes;
+pub mod options_ui;
+pub mod overlay;
+pub mod pack_screen;
+pub mod packs;
+pub mod par;
+pub mod particles;
+pub mod poi_sections;
+pub mod providers;
+pub mod screen_draw;
+pub mod screen_effects;
+pub mod sculk;
+pub mod settings;
+pub mod shader_pack_list;
+pub mod signs;
+pub mod skins;
+pub mod sound_engine;
+pub mod sound_events;
+pub mod spans;
+mod sprite_cache;
+pub mod sprites;
+pub mod streaming;
+pub mod tab_list;
+pub mod telemetry;
+pub mod testgen;
+pub mod title_edition;
+pub mod trims;
+pub mod ui;
+pub mod vault;
+pub mod weather;
+pub mod widgets;
+pub mod world;
+pub mod worldborder;
+pub mod zip;
+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_client_input::clipboard;
+pub use horizon_client_input::gamepad;
+pub use horizon_client_input::input;
+pub use horizon_client_input::interaction_input;
+pub use horizon_client_input::key_names;
+pub use horizon_client_input::keybinds;
+pub use horizon_client_input::keymapping;
+pub use horizon_client_input::mouse;
+pub use horizon_client_input::window;
+pub use horizon_command as command;
+pub use horizon_items::blocks;
+pub use horizon_items::bundle;
+pub use horizon_items::cooldowns;
+pub use horizon_items::enchant;
+pub use horizon_items::item_data;
+pub use horizon_items::items;
+pub use horizon_items::random_sequences;