Merge pull request #12227 from horizon-rust/fix/keyring-timeout-12179

🤖 Agent: keyring calls now give up after 20 s on a thread of their own; a call still stuck makes later ones fail at once, so the account lock is never held forever (tested with a keyring that never answers).
launcher: give up on a keyring that never answers (#12179 )
2026-11-07 17:21:49 -10:00 · 2026-11-08 04:05:55 +01:00 · 2026-11-08 04:04:29 +01:00 · 2026-11-08 04:02:16 +01:00 · 2026-11-08 03:58:06 +01:00 · 2026-11-08 03:58:03 +01:00
862 changed files with 83025 additions and 15541 deletions
@@ -152,23 +152,23 @@ state stays separate from the library tests. This compiles gameplay twice for ex

 | Subsystem | Files |
 |---|---|
-| Game loop, tick, frame | `game.rs`: `fn run`, `impl ApplicationHandler for Game` (`window_event`, `about_to_wait`), `fn tick`, `fn tick_world`, `fn render`; L: `clock.rs`, `spans.rs`; `horizon-client-input/src/window.rs` |
-| Rendering | L: `gfx.rs` (`Renderer::new`, `Renderer::render`), `gfx/` (cull, occlusion, translucency, upload, timing, lod, weather, stars, end_sky), `*.wgsl`, `particles.rs`, `block_entity_render.rs`, `item_render.rs`, `fog.rs`, `clouds.rs`, `camera.rs`, `first_person.rs`; G: `render_tick.rs`, `item_draw.rs` |
-| Chunks, streaming, light | L: `streaming.rs` (worker pool: generate, light, mesh), `world.rs`, `chunk.rs`, `chunk_map.rs`, `light.rs`, `mesher.rs` + `mesher/`, `vanillagen.rs` (binds horizon-world's generator), `lod.rs` + `lod/`, `server_terrain.rs` (a server's kept chunks), `bluemap.rs` + `bluemap_detect.rs` (far terrain from its web map), `ticket_levels.rs`; G: `world_loading.rs`, `postprocess.rs`; game.rs `fn update_world` |
+| Game loop, tick, frame | `game.rs`: `fn run`, `fn tick`, `fn tick_world`, `fn render`; G: `window_handler.rs` (`impl ApplicationHandler for Game`: `window_event`, `about_to_wait`); L: `clock.rs`, `spans.rs`; `horizon-client-input/src/window.rs` |
+| Rendering | L: `gfx.rs` (`Renderer::new`, `Renderer::render`), `gfx/` (cull, occlusion, translucency, upload, timing, lod, weather, stars, end_sky), `*.wgsl`, `particles.rs`, `block_entity_render.rs`, `item_render.rs`, `fog.rs`, `clouds.rs`, `camera.rs`, `first_person.rs`; G: `render_tick.rs`, `item_draw.rs`, `screen_backgrounds.rs` (panorama, menu blur, border wall) |
+| Chunks, streaming, light | L: `streaming.rs` (worker pool: generate, light, mesh), `world.rs`, `chunk.rs`, `chunk_map.rs`, `light.rs`, `mesher.rs` + `mesher/`, `vanillagen.rs` (binds horizon-world's generator), `lod.rs` + `lod/`, `server_terrain.rs` (a server's kept chunks), `bluemap.rs` + `bluemap_detect.rs` (far terrain from its web map), `ticket_levels.rs`; G: `world_loading.rs`, `world_entry.rs`, `postprocess.rs`; game.rs `fn update_world` |
 | World generation | `crates/horizon-world/src/worldgen/` (`generator*.rs`, `feature_graph.rs`, `structure/`, `carver/`) |
 | Block behaviour | `crates/horizon-world/src/level/` (`mod.rs`, `tick.rs`, `hooks.rs`, `redstone.rs`, `place.rs`, `interact.rs`); game.rs `fn tick_blocks`, `fn process_level_events` |
 | Mobs | L: `mobs.rs` (types), `mobs/` (`ai.rs`, `goals.rs`, `brain.rs`, `*_brain.rs`, `nav.rs`, `path.rs`, `species.rs`, `spawning.rs`, `render.rs`, `anim.rs`); G: `creatures.rs` (ticking, spawning, mob events), one file per mob family (`dragon.rs`, `wither.rs`, `villagers.rs`, `piglins.rs`, `golems.rs`...), `natural_spawning.rs` |
 | 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`; crate `horizon-items`: `items.rs`, `item_data.rs`, `enchant.rs`, `blocks.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` |
+| Player actions | game.rs (`fn use_hand`, `fn tick_mining`, `fn break_block`); G: `item_actions.rs` (`fn use_item`), `melee.rs` (`fn attack`), `hand.rs`, `combat.rs`, `consume.rs`, `using_item.rs` (an item in use, tick by tick), `potions.rs`, `shield.rs`, `crossbow.rs`, `trident.rs`, `fishing.rs`; L: `motion.rs` + `motion/` (movement), `collisions.rs`; crate `horizon-items`: `items.rs`, `item_data.rs`, `enchant.rs`, `blocks.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`, `inventory_input.rs` (keys and clicks over a container), `inventory_slots.rs` (slot layout and drawing) |
 | 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` |
+| 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`, `loading_screen.rs` (the loading screen, the pre-game `App`), `screens.rs` (pause, death), `options.rs`, `lan_screen.rs`, `chat.rs`, `sign_edit.rs`, `books.rs`, `creative_screen.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`, `horizon-anticheat` (L: `lan/anticheat.rs`) |
-| 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`; crate `horizon-client-input` (`keybinds.rs`, `keymapping.rs`, `key_names.rs`, `mouse.rs`, `input.rs`, `interaction_input.rs`, `gamepad.rs`, `clipboard.rs`); L: `osk.rs`; G: `pad.rs`, `pad_menu.rs` |
+| 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), `world_session.rs` (opening and closing a world); `crates/horizon-world/src/{region.rs,nbt.rs,datafix/}` |
+| Input | game.rs `fn window_event`; G: `play_keys.rs` (`fn key_pressed`), `play_input.rs` (`fn play_mouse`, toggled keys, the hotbar wheel); crate `horizon-client-input` (`keybinds.rs`, `keymapping.rs`, `key_names.rs`, `mouse.rs`, `input.rs`, `interaction_input.rs`, `gamepad.rs`, `clipboard.rs`); L: `osk.rs`; G: `pad.rs`, `pad_menu.rs`, `pad_craft.rs`, `pointer_capture.rs` (mouse look, pointer grab) |
 | 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`, `mobs/cem.rs` + `mobs/cem_anim.rs` (OptiFine/EMF entity models and their animations); `horizon-client-core/src/lang.rs`; crates `horizon-assets`, `horizon-optifine`; G: `packs.rs` |
 | Agent control | L: `control.rs` (socket), `bin/horizon-ctl/`; G: `control.rs`, `agent.rs`, `events.rs`, `ui_control.rs` ([docs/agent-control.md](docs/agent-control.md)) |
@@ -191,7 +191,7 @@ state stays separate from the library tests. This compiles gameplay twice for ex
  `levels.rs` swaps whole dimensions in the same way. Changes reach clients through the block log, level
  events and the entity tracker (`lan/tracking.rs`, `game/lan_entities.rs`).
 - Shared read-only data: `Resources` (`res`: blocks, items, recipes, mob types, biomes) and `PackResources`
-  (`pack`), both in game.rs.
+  (`pack`), both in game.rs, their methods in `game/resource_tables.rs`.

 ## Single player runs on a server thread

@@ -61,6 +61,10 @@ another project's source may also be read and used, **only when that project's l
  "source available" licenses, all rights reserved (OptiFine), and any project with no license or an unclear one.
  Don't read, copy, translate or paraphrase their source, and don't send code an AI tool wrote from it. Being able
  to download a mod or a pack does not give you the right to read its files.
+- **Java's own library is GPL too.** OpenJDK's source (`java.lang.Math`, `StrictMath`, `FdLibm`, `HashMap`, the
+  sorts, `Double.toString`, HotSpot's intrinsics...) is GPL-2.0, so it is off limits like the rest. Reproduce Java's
+  behaviour from its API documentation (the Javadoc) and from what a JVM returns, or from a permissive original such
+  as Sun's fdlibm C sources (see [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md)); see #6741.
 - **Check the license yourself.** Read the LICENSE file at the commit you use and the header of each file you take:
  some repositories mix licenses, and a file under another license is off limits. A license that changed: the one at
  your commit counts. In doubt, don't: ask in #contributors first.
@@ -1,5 +1,36 @@
 # Third-party notices

+## Code removed for its license
+
+Horizon once shipped three pieces of code under MIT that came from projects whose licenses don't allow that. All
+three are gone from main. They are listed here for anyone who holds an older commit, tag or release: in those
+versions, that code is not covered by Horizon's MIT license. It stays under its authors' copyright and its original
+license.
+
+- **Shader packs written from Iris's source.** `crates/horizon-shaderpack` and the render stages that used it were
+  written from the source of [Iris](https://github.com/IrisShaders/Iris) (LGPL-3.0, copyright the Iris contributors).
+  They were added from 15 October 2026 (`b22583d057`), shipped in the game releases `v2026.10.16.02` to `v0.2.46`,
+  and were removed on 24 October 2026 ([#1561](https://github.com/horizon-rust/horizon/pull/1561)) after a developer
+  of Iris showed us. Shader packs came back in `crates/horizon-shaders`, first written from a description of the
+  pack format.
+- **Math functions translated from OpenJDK.** In `crates/horizon-core/src/jmath.rs`, `fdlibm::{log, log10, cbrt,
+  hypot}` were translated from OpenJDK's `java/lang/FdLibm.java` and `round_f32` from its `java/lang/Math.java`
+  (GPL-2.0 with the Classpath Exception), and `aarch64::{sin, cos}` from HotSpot's `macroAssembler_aarch64_trig.cpp`
+  (GPL-2.0); copyright Oracle and/or its affiliates, and Cavium for that file. The `fdlibm` and `aarch64` functions
+  were added on 13 October 2026 (`558d140fca`, first released in `v2026.10.13`). `round_f32` was added on 14 October
+  2026 as `java_round` in `crates/horizon-client/src/mipmap.rs` (`95db0fce9d`) and moved into `jmath.rs` on 3
+  November ([#7770](https://github.com/horizon-rust/horizon/pull/7770)). All of them were replaced in
+  [#11944](https://github.com/horizon-rust/horizon/pull/11944) by code written without OpenJDK's sources, from Sun's
+  fdlibm C sources, the Java SE API documentation and a description of the behaviour, and checked against a JVM
+  ([#6741](https://github.com/horizon-rust/horizon/issues/6741)).
+- **Java's `HashMap` translated from OpenJDK.** `crates/horizon-world/src/java_hash_map.rs`, which reproduces the
+  iteration order of `java.util.HashMap`, was translated from OpenJDK's `java/util/HashMap.java` (GPL-2.0 with the
+  Classpath Exception; copyright Oracle and/or its affiliates). It was added on 7 October 2026 (`118e93ea51` and
+  `194db0dbb4`, first released in `v2026.10.12`). It was replaced in
+  [#12043](https://github.com/horizon-rust/horizon/pull/12043) by code written without OpenJDK's sources, from a
+  description of the behaviour, the Java SE API documentation and the textbook red-black tree, and checked against a
+  JVM ([#6741](https://github.com/horizon-rust/horizon/issues/6741)).
+
 ## Catnip / Ponder

 `crates/horizon-client-render/src/fluid_render.rs` translates the still-fluid face tiling and
@@ -15,8 +46,11 @@ original classes, game shaders, textures or prepared resources are distributed h
 `third_party/wgpu-hal` is [wgpu-hal](https://github.com/gfx-rs/wgpu) 30.0.1 by the gfx-rs
 developers, with upstream fixes applied
 ([gfx-rs/wgpu#10124](https://github.com/gfx-rs/wgpu/pull/10124),
-[gfx-rs/wgpu#10714](https://github.com/gfx-rs/wgpu/pull/10714)). It is licensed under MIT or
-Apache-2.0; both licenses are in that folder (`LICENSE.MIT`, `LICENSE.APACHE`).
+[gfx-rs/wgpu#10714](https://github.com/gfx-rs/wgpu/pull/10714)). Its GL backend also reports
+the context's sampled textures and samplers per shader stage (usually 32 on desktop GL,
+where WebGL2's minimum 16 was reported before), so a pipeline layout the driver accepts is
+not refused. It is licensed under MIT or Apache-2.0; both licenses are in that folder
+(`LICENSE.MIT`, `LICENSE.APACHE`).

 ## naga

@@ -256,3 +290,22 @@ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+## fdlibm
+
+`crates/horizon-core/src/jmath/fdlibm.rs` and the `fdlibm_asin`, `fdlibm_atan` and
+`fdlibm_atan2` functions in `crates/horizon-core/src/geometry/trig.rs` are Rust ports of
+[fdlibm](https://www.netlib.org/fdlibm/) 5.3, Sun's freely distributable math library, whose
+results the Java SE API specifies for `StrictMath`. `fdlibm.rs` ports `e_log.c`, `e_log10.c`,
+`s_cbrt.c` and `e_hypot.c`, and, with fused multiply-adds, `s_sin.c`, `s_cos.c`, `k_sin.c`,
+`k_cos.c` and `e_rem_pio2.c`; `trig.rs` ports `e_asin.c`, `s_atan.c` and `e_atan2.c`. This
+notice also heads both files:
+
+```
+Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+
+Developed at SunSoft, a Sun Microsystems, Inc. business.
+Permission to use, copy, modify, and distribute this
+software is freely granted, provided that this notice
+is preserved.
+```
@@ -917,6 +917,46 @@ impl NumericProperty {
 /// (`None` removes a prototype component).
 pub type Components = BTreeMap<String, Value>;

+/// A stack's components read in place: its patch first, then its item's defaults. Reading one copies
+/// nothing, where [`ItemModels::components`] clones the defaults for a stack with a patch (an enchanted
+/// sword's are a few dozen JSON values, on every draw of it).
+#[derive(Clone, Copy)]
+pub struct ComponentsView<'a> {
+    prototype: &'a Components,
+    patch: &'a BTreeMap<String, Option<Value>>,
+}
+
+impl<'a> ComponentsView<'a> {
+    pub fn get(&self, key: &str) -> Option<&'a Value> {
+        match self.patch.get(key) {
+            Some(patched) => patched.as_ref(),
+            None => self.prototype.get(key),
+        }
+    }
+    pub fn contains_key(&self, key: &str) -> bool {
+        self.get(key).is_some()
+    }
+    /// Components with no patch: `components` as they are.
+    pub fn of(components: &'a Components) -> Self {
+        static NO_PATCH: BTreeMap<String, Option<Value>> = BTreeMap::new();
+        Self {
+            prototype: components,
+            patch: &NO_PATCH,
+        }
+    }
+    /// The merged map, for what needs one whole.
+    pub fn to_map(&self) -> Components {
+        let mut out = self.prototype.clone();
+        for (key, value) in self.patch {
+            match value {
+                Some(v) => out.insert(key.clone(), v.clone()),
+                None => out.remove(key),
+            };
+        }
+        out
+    }
+}
+
 /// An item stack as the resolver reads it.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct StackView {
@@ -1087,14 +1127,15 @@ impl ItemModels {
        if stack.patch.is_empty() {
            return std::borrow::Cow::Borrowed(prototype);
        }
-        let mut out = prototype.clone();
-        for (key, value) in &stack.patch {
-            match value {
-                Some(v) => out.insert(key.clone(), v.clone()),
-                None => out.remove(key),
-            };
+        std::borrow::Cow::Owned(self.components_view(stack).to_map())
+    }
+    /// The stack's components, read in place (see [`ComponentsView`]).
+    pub fn components_view<'a>(&'a self, stack: &'a StackView) -> ComponentsView<'a> {
+        static NONE: Components = BTreeMap::new();
+        ComponentsView {
+            prototype: self.prototypes.get(&stack.item).unwrap_or(&NONE),
+            patch: &stack.patch,
        }
-        std::borrow::Cow::Owned(out)
    }
    /// `ItemModelResolver.updateForTopItem`.
    pub fn resolve(&self, stack: &StackView, ctx: &Context, env: &dyn ItemEnv) -> ResolvedItem {
@@ -1112,7 +1153,7 @@ impl ItemModels {
        ctx: &Context,
        env: &dyn ItemEnv,
    ) {
-        let components = self.components(stack);
+        let components = self.components_view(stack);
        let Some(Value::String(model_id)) = components.get("minecraft:item_model") else {
            return;
        };
@@ -1122,7 +1163,7 @@ impl ItemModels {
        let mut state = Resolve {
            models: self,
            stack,
-            components: &components,
+            components,
            ctx,
            env,
        };
@@ -1140,7 +1181,7 @@ impl ItemModels {
        self.properties(stack).2
    }
    fn properties(&self, stack: &StackView) -> (bool, bool, f32) {
-        match self.components(stack).get("minecraft:item_model") {
+        match self.components_view(stack).get("minecraft:item_model") {
            Some(Value::String(id)) => identifier(id)
                .ok()
                .and_then(|id| self.definitions.get(&id))
@@ -1159,7 +1200,7 @@ impl ItemModels {
 struct Resolve<'a> {
    models: &'a ItemModels,
    stack: &'a StackView,
-    components: &'a Components,
+    components: ComponentsView<'a>,
    ctx: &'a Context<'a>,
    env: &'a dyn ItemEnv,
 }
@@ -1455,9 +1496,9 @@ impl Resolve<'_> {
    fn numeric(&self, property: &NumericProperty) -> f32 {
        let owner = self.ctx.owner;
        match property {
-            NumericProperty::BundleFullness => {
-                self.env.bundle_fullness(self.stack, self.components)
-            }
+            NumericProperty::BundleFullness => self
+                .env
+                .bundle_fullness(self.stack, &self.components.to_map()),
            NumericProperty::Compass {
                wobble,
                target,
@@ -63,7 +63,7 @@ pub(super) fn decode(m: &Map<String, Value>) -> Result<Value> {
 /// with a matching level. An empty predicate list still needs the component.
 pub(super) fn matches(
    predicate: &Value,
-    components: &Components,
+    components: ComponentsView<'_>,
    env: &dyn ItemEnv,
 ) -> Option<bool> {
    let (id, expected) = predicate.as_object()?.iter().next()?;
@@ -143,13 +143,17 @@ mod tests {
            json!({"minecraft:density":0}),
        )]);
        assert_eq!(
-            matches(&json!({"minecraft:enchantments":[{}]}), &components, &NoEnv),
+            matches(
+                &json!({"minecraft:enchantments":[{}]}),
+                ComponentsView::of(&components),
+                &NoEnv
+            ),
            Some(true)
        );
        assert_eq!(
            matches(
                &json!({"minecraft:enchantments":[{"enchantments":"minecraft:density"}]}),
-                &components,
+                ComponentsView::of(&components),
                &NoEnv
            ),
            Some(false)
@@ -166,12 +170,21 @@ mod tests {
            "minecraft:enchantments".into(),
            json!({"minecraft:density":3}),
        )]);
-        assert_eq!(matches(&predicate, &components, &Tags), Some(true));
-        assert_eq!(matches(&predicate, &components, &NoEnv), Some(false));
+        assert_eq!(
+            matches(&predicate, ComponentsView::of(&components), &Tags),
+            Some(true)
+        );
+        assert_eq!(
+            matches(&predicate, ComponentsView::of(&components), &NoEnv),
+            Some(false)
+        );
        components.insert(
            "minecraft:enchantments".into(),
            json!({"minecraft:density":2}),
        );
-        assert_eq!(matches(&predicate, &components, &Tags), Some(false));
+        assert_eq!(
+            matches(&predicate, ComponentsView::of(&components), &Tags),
+            Some(false)
+        );
    }
 }
@@ -1,4 +1,5 @@
 use super::*;
+use serde_json::json;

 #[test]
 fn identifier_adds_default_namespace() {
@@ -111,3 +112,49 @@ fn custom_condition_validates_its_name_and_both_branches() {
    assert!(matches!(node("example:charged", empty).unwrap(),
        ItemModelNode::Condition { property: ConditionProperty::Custom(name), .. } if name == "example:charged"));
 }
+
+#[test]
+fn a_patched_stack_reads_its_patch_over_its_items_defaults() {
+    let mut models = ItemModels::default();
+    models.prototypes.insert(
+        "minecraft:diamond_sword".into(),
+        Components::from_iter([
+            (
+                "minecraft:item_model".into(),
+                json!("minecraft:diamond_sword"),
+            ),
+            ("minecraft:max_damage".into(), json!(1561)),
+            ("minecraft:rarity".into(), json!("common")),
+        ]),
+    );
+    let mut stack = StackView::new("minecraft:diamond_sword", 1);
+    stack.patch.insert(
+        "minecraft:enchantments".into(),
+        Some(json!({"minecraft:sharpness": 5})),
+    );
+    stack
+        .patch
+        .insert("minecraft:rarity".into(), Some(json!("rare")));
+    stack.patch.insert("minecraft:max_damage".into(), None);
+    let view = models.components_view(&stack);
+    assert_eq!(view.get("minecraft:rarity"), Some(&json!("rare")));
+    assert_eq!(view.get("minecraft:max_damage"), None, "a removed default");
+    assert_eq!(
+        view.get("minecraft:item_model"),
+        Some(&json!("minecraft:diamond_sword"))
+    );
+    assert!(view.contains_key("minecraft:enchantments"));
+    assert!(!view.contains_key("minecraft:custom_name"));
+    // Every key reads as the merged map has it.
+    let merged = models.components(&stack);
+    for key in [
+        "minecraft:rarity",
+        "minecraft:max_damage",
+        "minecraft:item_model",
+        "minecraft:enchantments",
+        "minecraft:custom_name",
+    ] {
+        assert_eq!(view.get(key), merged.get(key), "{key}");
+    }
+    assert_eq!(view.to_map(), *merged);
+}
@@ -290,12 +290,12 @@ pub fn normalize_quaternion(q: [f32; 4]) -> [f32; 4] {
    [x * inv, y * inv, z * inv, w * inv]
 }
 /// JOML `Math.sin(float)` without fast math.
-fn joml_sin(rad: f32) -> f32 {
+pub fn joml_sin(rad: f32) -> f32 {
    f64::from(rad).sin() as f32
 }
 /// JOML `Math.cosFromSin(float, float)` without fast math: the magnitude from
 /// the sine, the sign from the angle's quadrant (exact zeros at right angles).
-fn cos_from_sin(sin: f32, angle: f32) -> f32 {
+pub fn cos_from_sin(sin: f32, angle: f32) -> f32 {
    let cos = (1.0 - sin * sin).sqrt();
    let tau = (std::f64::consts::PI * 2.0) as f32;
    let a = angle + std::f32::consts::FRAC_PI_2;
@@ -217,9 +217,10 @@ pub fn stack(tag: &Tag) -> Option<Tag> {
    Some(Tag::compound(out))
 }
 /// `ItemStackTemplate.CODEC`: an item id or `{id, count?, components?}`.
+/// Encoding uses the primary record form, including for a bare item id.
 fn template(tag: &Tag) -> Option<Tag> {
    match tag {
-        Tag::String(_) => Some(tag.clone()),
+        Tag::String(_) => Some(Tag::compound([("id", tag.clone())])),
        Tag::Compound(_) => {
            let mut out = vec![("id", string(&text(tag.get("id"))?))];
            if let Some(count) = int(tag.get("count")).filter(|c| *c != 1) {
@@ -1011,3 +1012,69 @@ mod tests {
        assert_eq!(items[1].get("count"), Some(&Tag::Int(5)));
    }
 }
+
+#[cfg(test)]
+mod pot_template_tests {
+    use super::*;
+    use horizon_world::nbt::parse_snbt;
+
+    #[test]
+    fn decorated_pot_string_template_load_save_uses_item_compound() {
+        let parse = |s: &str| parse_snbt(s).expect("valid input NBT").0;
+        let input = |front: &str| {
+            let mut tag = parse(
+                r#"{id:"minecraft:decorated_pot",x:4,y:200,z:4,sherds:{back:{id:"minecraft:brick"},right:{id:"minecraft:archer_pottery_sherd"}},item:{id:"minecraft:wheat",count:3,components:{"minecraft:custom_name":"H290 item"}}}"#,
+            );
+            let Tag::Compound(root) = &mut tag else {
+                unreachable!()
+            };
+            let Some(Tag::Compound(sides)) = root.get_mut(&"sherds".into()) else {
+                unreachable!()
+            };
+            sides.insert("front".into(), parse(front));
+            tag
+        };
+        let other_fields = |loaded: &Tag, saved: &Tag| {
+            assert_eq!(saved.get("id"), loaded.get("id"));
+            for key in ["x", "y", "z", "item"] {
+                assert_eq!(saved.get(key), loaded.get(key), "{key}");
+            }
+            let loaded_sides = loaded.get("sherds").unwrap();
+            let saved_sides = saved.get("sherds").unwrap();
+            for side in ["back", "right"] {
+                assert_eq!(saved_sides.get(side), loaded_sides.get(side), "{side}");
+            }
+            assert_eq!(saved_sides.get("left"), None);
+        };
+        let plain = r#"{id:"minecraft:angler_pottery_sherd"}"#;
+        let defaults = r#"{id:"minecraft:angler_pottery_sherd",count:1,components:{}}"#;
+        let rich = r#"{id:"minecraft:angler_pottery_sherd",count:3,components:{"minecraft:custom_data":{h290:1},"minecraft:custom_name":"H290 sherd"}}"#;
+        // Actual canonical load/save entry, not the private template helper.
+        for (front, expected) in [(plain, plain), (defaults, plain), (rich, rich)] {
+            let loaded = input(front);
+            let original = loaded.clone();
+            let saved = canonical(&loaded).expect("actual decorated-pot codec");
+            other_fields(&loaded, &saved);
+            assert_eq!(
+                saved.get("sherds").unwrap().get("front"),
+                Some(&parse(expected))
+            );
+            assert_eq!(canonical(&saved).as_ref(), Some(&saved));
+            assert_eq!(loaded, original, "read-only canonicalization");
+        }
+        println!(
+            "H290 actual canonical compound/default/count/components, other sides/item/name and idempotency controls admitted"
+        );
+        let loaded = input(r#""minecraft:angler_pottery_sherd""#);
+        let original = loaded.clone();
+        let saved = canonical(&loaded).expect("actual decorated-pot codec");
+        other_fields(&loaded, &saved);
+        assert_eq!(loaded, original, "read-only canonicalization");
+        assert_eq!(
+            saved.get("sherds").unwrap().get("front"),
+            Some(&parse(plain)),
+            "string template must save the primary item compound",
+        );
+        assert_eq!(canonical(&saved).as_ref(), Some(&saved));
+    }
+}
@@ -412,10 +412,11 @@ pub fn to_text_with(
                            .collect()
                    })
                    .unwrap_or_default();
-                let translated = Text::translate(key, &args);
+                // TranslatableContents.decompose: Language.getOrDefault(key, fallback), so the
+                // fallback is the template itself, never looked up as another key.
                match o.get("fallback").and_then(Value::as_str) {
-                    Some(fallback) if translated.plain() == key => Text::translate(fallback, &args),
-                    _ => translated,
+                    Some(fallback) => Text::translate_with_fallback(key, fallback, &args),
+                    None => Text::translate(key, &args),
                }
            } else if let Some(sel) = o.get("selector").and_then(Value::as_str) {
                resolve(sel)
@@ -513,6 +514,43 @@ pub fn name_text(tag: &Tag) -> Text {
 #[cfg(test)]
 mod tests {
    use super::*;
+    use crate::lang::{self, Language, ResourceSource};
+
+    struct Mem(std::collections::HashMap<String, Vec<u8>>);
+    impl ResourceSource for Mem {
+        fn read(&self, path: &str) -> Option<Vec<u8>> {
+            self.0.get(path).cloned()
+        }
+    }
+
+    /// TranslatableContents.decompose: Language.getOrDefault(key, fallback). A missing key
+    /// shows the fallback as written, even when the fallback is another key the language has.
+    #[test]
+    fn a_translatable_fallback_stays_literal() {
+        let pack = Mem([(
+            "assets/minecraft/lang/en_us.json".to_owned(),
+            br#"{"real.key": "Translated", "greet": "Hello %s"}"#.to_vec(),
+        )]
+        .into());
+        let ((), _) = lang::scoped(Language::load(&[&pack], "en_us"), || {
+            let parse = |v: Value| to_text(&v, &mut |_| Text::empty()).plain();
+            let missing = serde_json::json!({"translate": "missing.key", "fallback": "real.key"});
+            assert_eq!(parse(missing), "real.key");
+            // The fallback is a template: its arguments are filled in.
+            let args = serde_json::json!({"translate": "missing.key", "fallback": "Hi %s", "with": ["Steve"]});
+            assert_eq!(parse(args), "Hi Steve");
+            // A key the language has wins over its fallback.
+            let found =
+                serde_json::json!({"translate": "greet", "fallback": "real.key", "with": ["Alex"]});
+            assert_eq!(parse(found), "Hello Alex");
+            // A component built with the constructor keeps its meaning through its JSON.
+            let built = Text::translate_with_fallback("missing.key", "real.key", &[]);
+            let again = to_text(&built.component(), &mut |_| Text::empty());
+            assert_eq!(again.plain(), built.plain());
+            assert_eq!(again.component(), built.component());
+        });
+    }
+
    /// SnbtGrammar: a compound or list may end with one comma; two in a row
    /// stay an error.
    #[test]
@@ -46,6 +46,21 @@ thread_local! {
 }
 /// The current language's `bidirectional`, read for every drawn string.
 static BIDIRECTIONAL: AtomicBool = AtomicBool::new(false);
+/// Counts the languages set (`set`): another count is another language, so text looked up
+/// before it may read otherwise.
+static GENERATION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+thread_local! {
+    /// Counts the scopes this thread entered and left (`scoped`), which no other thread sees.
+    static SCOPE_GENERATION: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
+}
+/// Which language text looks up in now, on this thread, as a count that changes whenever that
+/// can: both counts only grow, so their sum changes when either does.
+pub fn generation() -> u64 {
+    GENERATION.load(Ordering::Relaxed) + SCOPE_GENERATION.get()
+}
+fn scope_changed() {
+    SCOPE_GENERATION.set(SCOPE_GENERATION.get() + 1);
+}

 /// A source of resource files: the prepared root plus packs, highest priority last.
 pub trait ResourceSource {
@@ -524,6 +539,7 @@ 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));
+    GENERATION.fetch_add(1, Ordering::Relaxed);
 }
 pub fn current() -> Option<Arc<Language>> {
    if let Some(language) = SCOPE.with(|s| s.borrow().as_ref().map(|s| s.language.clone())) {
@@ -543,6 +559,7 @@ pub fn scoped<R>(language: Language, f: impl FnOnce() -> R) -> (R, Vec<String>)
    impl Drop for Restore {
        fn drop(&mut self) {
            SCOPE.with(|s| *s.borrow_mut() = self.0.take());
+            scope_changed();
        }
    }
    let outer = SCOPE.with(|s| {
@@ -552,6 +569,7 @@ pub fn scoped<R>(language: Language, f: impl FnOnce() -> R) -> (R, Vec<String>)
        })
    });
    let _restore = Restore(outer);
+    scope_changed();
    let result = f();
    let missed = SCOPE.with(|s| {
        s.borrow_mut()
@@ -583,6 +583,10 @@ pub struct PadSettings {
    /// The sneak button flips sneaking (Bedrock's default) instead of
    /// holding it, unless vanilla's toggle crouch is on already.
    pub toggle_sneak: bool,
+    /// LT + A on a recipe crafts on every server, not only in single player and on LAN worlds
+    /// found in the server list. Off by default: a server's rules may count a repeated craft as a
+    /// macro.
+    pub craft_on_servers: bool,
    pub glyphs: GlyphStyle,
    /// A Nintendo pad's face buttons go by their letters (A confirms and jumps, as on the
    /// Switch's own menus and keyboard) instead of their places (B, at the bottom, does): on
@@ -614,6 +618,7 @@ impl Default for PadSettings {
            look_deadzone: 0.12,
            trigger_threshold: 0.4,
            toggle_sneak: true,
+            craft_on_servers: false,
            glyphs: GlyphStyle::Auto,
            nintendo_letters: cfg!(target_os = "horizon"),
            keyboard: TextKeyboard::Auto,
@@ -684,6 +689,7 @@ impl PadSettings {
                    s.trigger_threshold = unit(s.trigger_threshold).clamp(0.1, 0.9)
                }
                "toggleSneak" => s.toggle_sneak = flag(s.toggle_sneak),
+                "craftOnServers" => s.craft_on_servers = flag(s.craft_on_servers),
                "glyphs" => s.glyphs = GlyphStyle::parse(value),
                "nintendoLetters" => s.nintendo_letters = flag(s.nintendo_letters),
                "keyboard" => s.keyboard = TextKeyboard::parse(value),
@@ -745,7 +751,8 @@ impl PadSettings {
            self.keyboard.name(),
        );
        text.push_str(&format!(
-            "gameplayGuide:{}\npointerSpeed:{}\nscrollSpeed:{}\nrepeatDelay:{}\nrepeatInterval:{}\n",
+            "craftOnServers:{}\ngameplayGuide:{}\npointerSpeed:{}\nscrollSpeed:{}\nrepeatDelay:{}\nrepeatInterval:{}\n",
+            bool_text(self.craft_on_servers),
            self.guide_detail.name(),
            self.pointer_speed, self.scroll_speed, self.repeat_delay, self.repeat_interval,
        ));
@@ -245,6 +245,7 @@ fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
        settings.fxaa,
        settings.taa,
        settings.upscale,
+        0.85,
    );
    let mut notes = Vec::new();
    let mut note = |what: &str, result: horizon_client_render::Result<()>| {
@@ -47,6 +47,53 @@ struct Channel {
    world: u32,
    /// The sound file it started and when, to tell another player's copy of it.
    started: Option<(String, std::time::Instant)>,
+    /// Its sound event plays clearly through a mod's muffle (`Audio::muffle`).
+    unmuffled: bool,
+}
+/// The cutoff of the muffle's low-pass at full strength: the world heard through ringing ears.
+const MUFFLED_CUTOFF: f32 = 300.0;
+/// The cutoff it sweeps down from as its strength rises.
+const OPEN_CUTOFF: f32 = 20_000.0;
+/// How long the muffle takes to glide to a new level: a game tick's step (50 ms) would click.
+const MUFFLE_GLIDE: f32 = 0.02;
+/// A mod's muffle (`Audio::muffle`) in the mixer: the other sounds are mixed apart, low-passed by
+/// two one-pole stages and turned down, then added to the sounds it leaves clear. While it is off
+/// (never set, or faded out) the sounds mix straight into the output, as without it.
+#[derive(Default)]
+struct Muffle {
+    /// `[amount, lowpass]`, each 0 to 1, as the game's tick last set them.
+    target: [f32; 2],
+    /// Where the output is now, gliding to `target`.
+    current: [f32; 2],
+    /// The low-pass stages' state for the left and right output channels.
+    stages: [[f32; 2]; 2],
+    /// The muffled sounds of one buffer, reused.
+    bus: Vec<f32>,
+}
+impl Muffle {
+    fn active(&self) -> bool {
+        self.target != [0.0; 2] || self.current.iter().any(|v| *v > 1e-4)
+    }
+    /// Adds `bus` (the muffled sounds) to `data`, low-passed and turned down.
+    fn apply(&mut self, bus: &[f32], data: &mut [f32], channels: usize, rate: u32) {
+        let rate = rate as f32;
+        let glide = 1.0 - (-1.0 / (MUFFLE_GLIDE * rate)).exp();
+        for (frame, muffled) in data.chunks_mut(channels).zip(bus.chunks(channels)) {
+            for (current, target) in self.current.iter_mut().zip(self.target) {
+                *current += (target - *current) * glide;
+            }
+            let [amount, lowpass] = self.current;
+            let gain = 1.0 - amount;
+            let cutoff = OPEN_CUTOFF * (MUFFLED_CUTOFF / OPEN_CUTOFF).powf(lowpass);
+            let a = 1.0 - (-std::f32::consts::TAU * cutoff / rate).exp();
+            for ((out, s), stage) in frame.iter_mut().zip(muffled).zip(&mut self.stages) {
+                stage[0] += (s - stage[0]) * a;
+                stage[1] += (stage[0] - stage[1]) * a;
+                // Dry at no strength, so a muffle that only turns sounds down leaves them as they were.
+                *out += (s + (stage[1] - s) * lowpass) * gain;
+            }
+        }
+    }
 }
 #[derive(Default)]
 struct Mixer {
@@ -65,6 +112,8 @@ struct Mixer {
    cameras: Vec<([f64; 3], Basis, u32)>,
    /// Per-source gain/pan/step cache for one buffer, reused across callbacks.
    voices: Vec<(ChannelId, [f32; 3], f64)>,
+    /// A mod's muffle of the sounds it does not exempt.
+    muffle: Muffle,
    limiter_peak: f32,
    /// The output device the stream was opened on (`Library.currentDeviceName`).
    #[cfg(feature = "audio")]
@@ -100,6 +149,21 @@ pub struct Heard {
    pub range: f32,
    pub looping: bool,
 }
+/// A mod's muffle (`Audio::muffle`): its full strength, and the ticks it fades over and has left.
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct MuffleFade {
+    amount: f32,
+    lowpass: f32,
+    ticks: u32,
+    left: u32,
+}
+impl MuffleFade {
+    /// `[amount, lowpass]` now: full when set, falling in a straight line to none.
+    fn level(&self) -> [f32; 2] {
+        let left = self.left as f32 / self.ticks as f32;
+        [self.amount * left, self.lowpass * left]
+    }
+}
 /// The mixer side of the engine (`Backend`).
 pub struct MixerBackend {
    mixer: Arc<Mutex<Mixer>>,
@@ -247,6 +311,8 @@ pub struct Audio {
    pub stopped: std::collections::BTreeMap<String, u32>,
    /// The volume sliders' `SoundPreviewHandler`.
    preview: crate::sound_preview::SoundPreview,
+    /// A mod's muffle fading out (`muffle`), advanced by `tick`.
+    muffle: Option<MuffleFade>,
    /// `SoundEngine.lastSeenDevices`: the system default output last seen.
    #[cfg(feature = "audio")]
    default_seen: Option<String>,
@@ -439,6 +505,7 @@ impl Backend for MixerBackend {
                owner: self.owner,
                world: self.world,
                started: None,
+                unmuffled: false,
            },
        );
        Some(id)
@@ -466,6 +533,9 @@ impl Backend for MixerBackend {
    fn set_relative(&mut self, channel: ChannelId, relative: bool) {
        self.with(channel, |c| c.relative = relative);
    }
+    fn set_unmuffled(&mut self, channel: ChannelId, unmuffled: bool) {
+        self.with(channel, |c| c.unmuffled = unmuffled);
+    }
    /// `getCompleteBuffer` (cached, else decoded on the decoder thread) or
    /// `getStream` (decoded on a thread of its own), then attach and
    /// `alSourcePlay`. A sound that cannot load leaves its source initial,
@@ -702,6 +772,13 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
        let step = f64::from(*source_rate) / f64::from(rate) * f64::from(c.pitch.max(0.0));
        voices.push((*id, [left, right, gain], step));
    }
+    // A mod's muffle: the sounds it doesn't exempt mix into a bus of their own first.
+    let muffling = mixer.muffle.active();
+    let mut bus = std::mem::take(&mut mixer.muffle.bus);
+    if muffling {
+        bus.clear();
+        bus.resize(data.len(), 0.0);
+    }
    for (id, [left, right, gain], step) in voices.iter().copied() {
        let Some(c) = mixer.channels.get_mut(&id) else {
            continue;
@@ -711,7 +788,12 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
        };
        let source_channels = source_channels as usize;
        let frames = samples.len() / source_channels;
-        for frame in data.chunks_mut(channels) {
+        let out: &mut [f32] = if muffling && !c.unmuffled {
+            &mut bus
+        } else {
+            &mut *data
+        };
+        for frame in out.chunks_mut(channels) {
            let mut i = c.position as usize;
            if i + 1 >= frames {
                if c.looping && frames > 1 {
@@ -746,6 +828,14 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
        }
    }
    mixer.voices = voices;
+    if muffling {
+        mixer.muffle.apply(&bus, data, channels, rate);
+    } else {
+        // Off: the next muffle starts from silence, not from the last one's filter.
+        mixer.muffle.current = [0.0; 2];
+        mixer.muffle.stages = [[0.0; 2]; 2];
+    }
+    mixer.muffle.bus = bus;
    // Limit the whole buffer together, preserving waveform and stereo balance
    // instead of flattening each overloaded sample; release over 200 ms
    // (OpenAL Soft's output limiter, `ALC_OUTPUT_LIMITER_SOFT`, releases
@@ -1071,12 +1161,13 @@ impl Audio {
            listener: [0.0; 3],
            listener_yaw: 0.0,
            master: 1.0,
-            random: LegacyRandom::new(crate::sound_engine::unique_seed()),
+            random: crate::random_source::create(),
            source_override: None,
            capture: None,
            heard: Default::default(),
            stopped: Default::default(),
            preview: Default::default(),
+            muffle: None,
            #[cfg(feature = "audio")]
            default_seen: if live { default_output_name() } else { None },
            #[cfg(feature = "audio")]
@@ -1232,12 +1323,13 @@ impl Audio {
            listener: [0.0; 3],
            listener_yaw: 0.0,
            master: self.master,
-            random: LegacyRandom::new(crate::sound_engine::unique_seed()),
+            random: crate::random_source::create(),
            source_override: None,
            capture: None,
            heard: Default::default(),
            stopped: Default::default(),
            preview: Default::default(),
+            muffle: None,
            // The device belongs to the first player's output, which looks after it.
            #[cfg(feature = "audio")]
            default_seen: self.default_seen.clone(),
@@ -1370,6 +1462,50 @@ impl Audio {
        }
        self.sync_volumes();
        self.engine.tick(paused, ctx, &mut self.backend);
+        // A paused game holds a mod's muffle where it is, as it holds the sounds.
+        if !paused && let Some(fade) = &mut self.muffle {
+            fade.left = fade.left.saturating_sub(1);
+            let level = fade.level();
+            if fade.left == 0 {
+                self.muffle = None;
+                self.engine.set_unmuffled(Vec::new(), &mut self.backend);
+            }
+            self.set_muffle_level(level);
+        }
+    }
+    /// A mod's muffle (`native_muffle_sounds`): `amount` (0 to 1) of every sound's volume taken
+    /// away and `lowpass` (0 to 1) dulling it, from untouched to a 300 Hz low-pass, fading in a
+    /// straight line to none over `ticks` client ticks; the sound events in `exempt` (namespaced,
+    /// `mymod:ear.ringing`) play clearly through it, those already playing too. It replaces any
+    /// muffle in place; `ticks` 0 or no strength ends it. The output's, so in splitscreen every
+    /// player hears it. False for an amount or strength outside 0 to 1.
+    pub fn muffle(&mut self, amount: f32, lowpass: f32, ticks: u32, exempt: &[&str]) -> bool {
+        if !(0.0..=1.0).contains(&amount) || !(0.0..=1.0).contains(&lowpass) {
+            return false;
+        }
+        let on = ticks > 0 && (amount > 0.0 || lowpass > 0.0);
+        let exempt = if on {
+            exempt
+                .iter()
+                .map(|e| crate::sound_events::normalize(e))
+                .collect()
+        } else {
+            Vec::new()
+        };
+        self.engine.set_unmuffled(exempt, &mut self.backend);
+        self.muffle = on.then_some(MuffleFade {
+            amount,
+            lowpass,
+            ticks,
+            left: ticks,
+        });
+        self.set_muffle_level(self.muffle.map_or([0.0; 2], |fade| fade.level()));
+        true
+    }
+    fn set_muffle_level(&mut self, level: [f32; 2]) {
+        if let Ok(mut m) = self.backend.mixer.lock() {
+            m.muffle.target = level;
+        }
    }
    /// The `uiSoundReserve` extra: positional sounds leave
    /// `sound_engine::HEARD_RESERVE` static channels free (off: vanilla's pool).
@@ -1482,7 +1618,7 @@ impl Audio {
                "minecraft:ui.button.click",
                1.0,
                0.25,
-                SoundEngine::unseeded(),
+                crate::random_source::create(),
            ),
            false,
        );
@@ -1624,7 +1760,7 @@ impl Audio {
            f64::from(pos[2]) + 0.5,
        ];
        let event = crate::sound_events::normalize(event);
-        let instance = SoundInstance::for_jukebox_song(&event, at, SoundEngine::unseeded());
+        let instance = SoundInstance::for_jukebox_song(&event, at, crate::random_source::create());
        self.play_instance(instance, true).0
    }
    /// Stop and drop a held instance.
@@ -1835,6 +1971,7 @@ mod tests {
            owner: 0,
            world: 0,
            started: None,
+            unmuffled: false,
        }
    }

@@ -2255,6 +2392,123 @@ mod tests {
        assert_eq!(data, [0.5; 2]);
    }

+    /// One second of a `hz` sine at 48 kHz, amplitude 0.3 (looped, it repeats seamlessly).
+    fn sine(hz: f32) -> Vec<f32> {
+        (0..48_000)
+            .map(|i| 0.3 * (std::f32::consts::TAU * hz * i as f32 / 48_000.0).sin())
+            .collect()
+    }
+
+    fn rms(data: &[f32]) -> f32 {
+        (data.iter().map(|s| s * s).sum::<f32>() / data.len() as f32).sqrt()
+    }
+
+    /// `seconds` of the mixer's stereo output, in the 10 ms buffers an output stream asks for.
+    fn listen(m: &mut Mixer, seconds: f32) -> Vec<f32> {
+        let mut out = Vec::new();
+        let mut buffer = [0.0; 960];
+        for _ in 0..(seconds * 100.0).round() as usize {
+            mix(m, &mut buffer, 2, 48_000);
+            out.extend_from_slice(&buffer);
+        }
+        out
+    }
+
+    #[test]
+    fn a_muffle_dulls_and_quietens_every_sound_but_the_exempt_ones() {
+        // A looping tone heard through a muffle of `[amount, lowpass]`, once it has settled.
+        let heard = |hz: f32, muffle: [f32; 2], unmuffled: bool| {
+            let mut m = Mixer::default();
+            let mut c = channel(sine(hz), None, [0.0, 0.0, 2.0], true);
+            c.unmuffled = unmuffled;
+            m.channels.insert(1, c);
+            m.muffle.target = muffle;
+            listen(&mut m, 0.2);
+            listen(&mut m, 0.2)
+        };
+        let plain = |hz: f32| rms(&heard(hz, [0.0; 2], false));
+        // Fully low-passed, a 6 kHz whine all but goes and a 100 Hz hum keeps most of its level.
+        assert!(rms(&heard(6000.0, [0.0, 1.0], false)) < plain(6000.0) * 0.05);
+        assert!(rms(&heard(100.0, [0.0, 1.0], false)) > plain(100.0) * 0.8);
+        // Half the volume taken and no low-pass: half the level, the tone itself untouched.
+        let ducked = rms(&heard(6000.0, [0.5, 0.0], false)) / plain(6000.0);
+        assert!((ducked - 0.5).abs() < 1e-3, "{ducked}");
+        // An exempt sound plays through as if there were no muffle, sample for sample.
+        assert_eq!(
+            heard(6000.0, [0.5, 1.0], true),
+            heard(6000.0, [0.0; 2], false)
+        );
+    }
+
+    #[test]
+    fn a_faded_muffle_leaves_the_sound_as_it_was() {
+        let mixer = || {
+            let mut m = Mixer::default();
+            m.channels
+                .insert(1, channel(sine(3000.0), None, [2.0, 0.0, 1.0], true));
+            m
+        };
+        let (mut muffled, mut plain) = (mixer(), mixer());
+        muffled.muffle.target = [0.7, 1.0];
+        assert_ne!(listen(&mut muffled, 0.1), listen(&mut plain, 0.1));
+        muffled.muffle.target = [0.0; 2];
+        listen(&mut muffled, 0.5);
+        listen(&mut plain, 0.5);
+        assert_eq!(listen(&mut muffled, 0.1), listen(&mut plain, 0.1));
+    }
+
+    #[test]
+    fn a_mods_muffle_fades_with_the_game_ticks_and_spares_its_exempt_sounds() {
+        let mut audio = Audio::silent(Path::new("/nonexistent/horizon-test-assets"));
+        audio.engine.registry.add_file(
+            "minecraft",
+            br#"{"ambient.cave":{"sounds":["ambient/cave/cave1"]}}"#,
+            &|_, _| true,
+        );
+        audio.engine.registry.add_file(
+            "hztest",
+            br#"{"ear.ringing":{"sounds":["ear/ringing"]}}"#,
+            &|_, _| true,
+        );
+        // The engine makes its channels; with no output, none loads a file.
+        audio.engine.loaded = true;
+        let marks = |audio: &Audio| {
+            let m = audio.backend.mixer.lock().unwrap();
+            let mut marks: Vec<_> = m
+                .channels
+                .iter()
+                .map(|(&id, c)| (id, c.unmuffled))
+                .collect();
+            marks.sort();
+            marks
+        };
+        let level = |audio: &Audio| audio.backend.mixer.lock().unwrap().muffle.target;
+        let close =
+            |a: [f32; 2], b: [f32; 2]| (a[0] - b[0]).abs() < 1e-6 && (a[1] - b[1]).abs() < 1e-6;
+        // Two sounds already playing, and one exempt sound started under the muffle.
+        audio.play("ambient.cave", None, 1.0, 1.0);
+        audio.play("hztest:ear.ringing", None, 1.0, 1.0);
+        assert!(audio.muffle(0.8, 1.0, 4, &["hztest:ear.ringing"]));
+        audio.play("hztest:ear.ringing", None, 1.0, 1.0);
+        assert_eq!(marks(&audio), [(1, false), (2, true), (3, true)]);
+        assert!(close(level(&audio), [0.8, 1.0]));
+        let ticks = TickContext::default();
+        audio.tick(false, &ticks);
+        assert!(close(level(&audio), [0.6, 0.75]), "{:?}", level(&audio));
+        // A paused game holds it.
+        audio.tick(true, &ticks);
+        assert!(close(level(&audio), [0.6, 0.75]), "{:?}", level(&audio));
+        for _ in 0..3 {
+            audio.tick(false, &ticks);
+        }
+        assert_eq!(level(&audio), [0.0; 2]);
+        // Over: its exemptions go with it.
+        assert_eq!(marks(&audio), [(1, false), (2, false), (3, false)]);
+        // Out of range changes nothing.
+        assert!(!audio.muffle(1.5, 0.0, 10, &[]));
+        assert_eq!(level(&audio), [0.0; 2]);
+    }
+
    #[test]
    fn output_devices_are_looked_at_again_only_when_the_cards_change() {
        // No fingerprint (not Linux, or the cards could not be read): the list
@@ -77,6 +77,9 @@ pub struct BlockEntities {
    /// The fluid tanks of mod blocks' block entities, by block state id;
    /// built with `states`, like the containers.
    mod_fluids: FxHashMap<u32, Arc<ModFluidTanks>>,
+    /// State-aware native factory ownership. Shared across level snapshots;
+    /// an empty slice means the declarations have not yet been compiled.
+    stateful_entities: Arc<[bool]>,
    /// The energy buffers of mod blocks' block entities, by block state id;
    /// built with `states`, like the containers.
    mod_energy: FxHashMap<u32, Arc<ModEnergyBuffer>>,
@@ -209,6 +212,21 @@ impl BlockEntities {
    pub fn mod_fluids(&self, state: u32) -> Option<&Arc<ModFluidTanks>> {
        self.mod_fluids.get(&state)
    }
+    pub fn set_stateful_entities(&mut self, states: Vec<bool>) {
+        self.stateful_entities = states.into();
+    }
+    pub fn has_stateful_entity_table(&self) -> bool {
+        !self.stateful_entities.is_empty()
+    }
+    pub fn stateful_entities(&self) -> Arc<[bool]> {
+        self.stateful_entities.clone()
+    }
+    pub fn stateful_entity(&self, state: u32) -> bool {
+        self.stateful_entities
+            .get(state as usize)
+            .copied()
+            .unwrap_or(false)
+    }
    pub fn set_mod_energy(&mut self, energy: FxHashMap<u32, Arc<ModEnergyBuffer>>) {
        self.mod_energy = energy;
    }
@@ -3,20 +3,22 @@
 //! decorated pots, conduits, enchanting-table and lectern books and copper
 //! golem statues, End portals and End gateways. Models are vanilla's baked `LayerDefinitions` layers
 //! (`entity-models.json`); transforms, animation and textures follow each
-//! vanilla renderer. Faces are lit like the `entity` shader: the lightmap at
-//! the block plus `minecraft_mix_light` with the level's two diffuse lights.
+//! vanilla renderer. Faces carry their tint and world normal: the entity
+//! shader (and a shader pack) applies `minecraft_mix_light` from the normal, as
+//! vanilla's does.
 use crate::{
    Result,
    bidi::visual,
    block_entity_anim::{self, EnchantingBook},
    breaking::entity_geometry,
    fast_hash::FxHashMap,
-    font::Glyph,
+    font::{Font, Glyph},
    gfx::mark_oit,
    hud::Rect,
    mesher::{CULL_BACK, Vertex},
    models::load_visibility,
    signs::{self, SignData, SignText},
+    text::{Style, Text},
    world::World,
 };
 use glam::{DVec3, Mat4, Quat, Vec3};
@@ -128,6 +130,14 @@ fn pack_color(rgb: u32, alpha: u32, brightness: f32) -> u32 {
    let c = |shift: u32| (((rgb >> shift) & 255) as f32 * brightness) as u32;
    alpha << 24 | c(0) << 16 | c(8) << 8 | c(16)
 }
+/// A world normal as `Vertex::normal` holds it: RGBA8_SNORM, `w` positive so
+/// the entity shader and a shader pack both shade by it. Block-entity models
+/// carry no normals of their own (vanilla computes each face's from its
+/// polygon, then `minecraft_mix_light` uses it in the shader).
+fn pack_normal(normal: Vec3) -> [i8; 4] {
+    let c = |v: f32| (v.clamp(-1.0, 1.0) * 127.0).round() as i8;
+    [c(normal.x), c(normal.y), c(normal.z), 127]
+}

 /// Everything a draw call needs besides the geometry.
 #[derive(Clone, Copy)]
@@ -165,6 +175,7 @@ pub fn draw_part(
        light,
        lights,
        glow,
+        ..
    } = paint;
    for poly in &part.polygons {
        let pos = poly.map(|v| m.transform_point3(Vec3::new(v[0], v[1], v[2]) / 16.0));
@@ -177,11 +188,21 @@ pub fn draw_part(
        } else {
            normal
        };
-        let color = pack_color(tint, 255, diffuse(normal, lights));
+        // The colour is the tint alone when the caller shades by the level's
+        // lights: the entity shader applies `minecraft_mix_light` from the
+        // normal, as vanilla does, so a shader pack receives the unshaded
+        // colour Iris gives it (a baked shade would be applied a second time
+        // by the pack's lighting). Other lights (an item preview's
+        // `Lighting.Entry`) are not the shader's to know, so those stay baked
+        // into the colour, as before.
+        let baked = !(lights == diffuse_lights(false) || lights == diffuse_lights(true));
+        let brightness = if baked { diffuse(normal, lights) } else { 1.0 };
+        let color = pack_color(tint, 255, brightness);
+        let normal = if baked { [0; 4] } else { pack_normal(normal) };
        for (r, light) in std::iter::once((r, light)).chain(glow.map(|g| (g, FULL_BRIGHT))) {
            for (v, position) in poly.iter().zip(pos) {
                out.push(Vertex {
-                    normal: [0; 4],
+                    normal,
                    pos: position.to_array(),
                    uv: [r.u0 + (r.u1 - r.u0) * v[3], r.v0 + (r.v1 - r.v0) * v[4]],
                    layer: 0,
@@ -600,30 +621,26 @@ fn frac(x: f32) -> f32 {
    x - x.floor()
 }

-/// `StringSplitter.splitLines(...).get(0)` for plain text: the first line,
-/// wrapped at the last space that fits or mid-word when none does.
-fn first_line(line: &str, max_width: f32, advance: &dyn Fn(char) -> f32) -> String {
+/// `StringSplitter.findLineBreak`: first line, with styled advances.
+fn first_line(line: &Text, max_width: f32, advance: &dyn Fn(char, &Style) -> f32) -> Text {
    let mut width = 0.0;
+    let mut visible = false;
    let mut last_space = None;
-    for (i, c) in line.char_indices() {
+    for (i, (c, style)) in line.chars().enumerate() {
        if c == '\n' {
-            return line[..i].to_owned();
+            return line.slice(0, i);
        }
        if c == ' ' {
            last_space = Some(i);
        }
-        width += advance(c);
-        if width > max_width {
-            let end = match last_space {
-                Some(s) if s > 0 => s,
-                _ if i > 0 => i,
-                // The first char alone is too wide: take that one char.
-                _ => c.len_utf8(),
-            };
-            return line[..end].to_owned();
+        let step = advance(c, style);
+        width += step;
+        if visible && width > max_width.max(1.0) {
+            return line.slice(0, last_space.unwrap_or(i));
        }
+        visible |= step != 0.0;
    }
-    line.to_owned()
+    line.clone()
 }

 /// `AbstractSignRenderer.isOutlineVisible`: the camera within 16 blocks of
@@ -641,7 +658,7 @@ fn sign_text_near(pos: [i32; 3], camera: DVec3) -> bool {
 /// `AbstractSignRenderer.submitSignText`: four centred lines, glowing text
 /// full-bright with an 8x outline in the dark colour. The font colours each
 /// glyph by its style (`Font.StringRenderOutput`): a line's own colour wins,
-/// else the sign's. A line is one call per run of one colour.
+/// else the sign's. Keep style boundaries for glyphs and decoration effects.
 fn sign_text_calls(
    scene: &Scene,
    data: &SignData,
@@ -653,27 +670,43 @@ fn sign_text_calls(
    let line_height = data.line_height();
    let midpoint = (4.0 * line_height / 2.0).floor();
    let dark = 0xFF00_0000 | text.dark_color();
-    let (color, outline, light) = if text.glowing {
+    let (color, outline, light, tier) = if text.glowing {
        let c = text.text_color();
        (
            0xFF00_0000 | c,
            if c == 0 || near { dark } else { 0 },
            240 | 240 << 8,
+            crate::mesher::LOW,
        )
    } else {
-        (dark, 0, vertex_light(packed))
+        (dark, 0, vertex_light(packed), 0)
+    };
+    let advance = |c: char, style: &Style| {
+        let g = scene
+            .font
+            .map_or_else(|| (scene.glyph)(c), |f| f.glyph_styled(c, style));
+        g.advance + if style.is_bold() { g.offset } else { 0.0 }
    };
-    let advance = |c: char| (scene.glyph)(c).advance;
    let mut calls: Vec<TextCall> = Vec::with_capacity(text.lines.len());
    for i in 0..text.lines.len() {
        // The line that fits, in the order it is drawn (getVisualOrder).
        let line = text.line_text(i);
-        let line = line.resolved();
-        let flat: String = line.chars().map(|(c, _)| c).collect();
-        let fits = first_line(&flat, data.max_line_width(), &advance);
-        let shown = line.slice(0, fits.chars().count());
+        let shown = if let Some(font) = scene.font {
+            font.split_formatted(&line, data.max_line_width())
+                .into_iter()
+                .next()
+                .unwrap_or_default()
+                .resolved()
+                .into_owned()
+        } else {
+            first_line(&line.resolved(), data.max_line_width(), &advance)
+        };
        let shown = visual(&shown);
-        let width = shown.chars().map(|(c, _)| advance(c)).sum::<f32>().ceil();
+        let width = shown
+            .chars()
+            .map(|(c, s)| advance(c, s))
+            .sum::<f32>()
+            .ceil();
        let x = -((width as i32) / 2) as f32;
        let y = i as f32 * line_height - midpoint;
        let first = calls.len();
@@ -683,19 +716,22 @@ fn sign_text_calls(
                .style
                .color
                .map_or(color, |rgb| 0xFF00_0000 | (rgb & 0xFF_FFFF));
-            match calls[first..].last_mut() {
-                Some(last) if last.color == run => last.text.push_str(&span.text),
-                _ => calls.push(TextCall {
-                    matrix: m,
-                    x: x + pen,
-                    y,
-                    text: span.text.clone(),
-                    color: run,
-                    outline,
-                    light,
-                }),
-            }
-            pen += span.text.chars().map(advance).sum::<f32>();
+            calls.push(TextCall {
+                matrix: m,
+                x: x + pen,
+                y,
+                text: span.text.clone(),
+                style: span.style.clone(),
+                color: run,
+                outline,
+                light,
+                tier,
+            });
+            pen += span
+                .text
+                .chars()
+                .map(|c| advance(c, &span.style))
+                .sum::<f32>();
        }
        if calls.len() == first {
            // A line with no text is still a call, of no glyphs.
@@ -704,15 +740,28 @@ fn sign_text_calls(
                x,
                y,
                text: String::new(),
+                style: Style::default(),
                color,
                outline,
                light,
+                tier,
            });
        }
    }
    calls
 }

+fn sign_text_animated(data: &SignData) -> bool {
+    [&data.front, &data.back].into_iter().any(|side| {
+        (0..side.lines.len()).any(|i| {
+            side.line_text(i)
+                .resolved()
+                .chars()
+                .any(|(c, s)| c != ' ' && s.obfuscated == Some(true))
+        })
+    })
+}
+
 /// How far the text of an outlined call sits in front of its outline, in
 /// text units (`Font.DisplayMode.POLYGON_OFFSET`, see `draw_text`).
 const TEXT_OVER_OUTLINE: f32 = 0.05;
@@ -726,72 +775,131 @@ const TEXT_OVER_OUTLINE: f32 = 0.05;
 /// reader instead (a twentieth of a font pixel, invisible) rather than
 /// z-fighting with the outline under it.
 fn draw_text(scene: &Scene, call: &TextCall, out: &mut Vec<Vertex>) {
-    text_vertices(scene.glyph, call, out);
+    let glyph = |c| {
+        let Some(font) = scene.font else {
+            return (scene.glyph)(c);
+        };
+        let g = font.glyph_styled(c, &call.style);
+        if call.style.obfuscated == Some(true) && c != ' ' {
+            font.random_glyph(&call.style, g.advance)
+        } else {
+            g
+        }
+    };
+    text_vertices(&glyph, scene.font.map(Font::white), call, out);
 }

-/// `draw_text` with the font's glyph cells and advances from `glyph`: the
+/// `BakedSheetGlyph.renderChar` / `Font.PreparedTextBuilder.accept`: the
 /// text of `call` as glyph quads in its matrix's plane, 1 unit a font pixel,
 /// y down as the font's, with its outline when it has one. A native mod's
 /// block entity draws its text this way (`native_draw_text`).
-pub fn text_vertices(glyph: &dyn Fn(char) -> Glyph, call: &TextCall, out: &mut Vec<Vertex>) {
-    let mut emit = |dx: f32, dy: f32, z: f32, argb: u32| {
-        let mut x = call.x + dx;
-        let y0 = call.y + dy;
-        for ch in call.text.chars() {
+pub fn text_vertices(
+    glyph: &dyn Fn(char) -> Glyph,
+    white: Option<Rect>,
+    call: &TextCall,
+    out: &mut Vec<Vertex>,
+) {
+    let bold = call.style.is_bold();
+    let mut quad = |corners: [(f32, f32); 4], cell: Rect, z: f32, argb: u32| {
+        let uvs = [
+            [cell.u0, cell.v1],
+            [cell.u1, cell.v1],
+            [cell.u1, cell.v0],
+            [cell.u0, cell.v0],
+        ];
+        let color = 0xFF00_0000 | (argb & 255) << 16 | (argb >> 8 & 255) << 8 | (argb >> 16 & 255);
+        for ((x, y), uv) in corners.into_iter().zip(uvs) {
+            out.push(Vertex {
+                normal: [0; 4],
+                pos: call.matrix.transform_point3(Vec3::new(x, y, z)).to_array(),
+                uv,
+                layer: u32::from(call.tier) << 16,
+                color,
+                light: call.light,
+                glint_uv: [0.0; 2],
+            });
+        }
+    };
+    let mut emit = |dx: f32, dy: f32, z: f32, argb: u32, outline: bool| {
+        let mut pen = call.x;
+        for (i, ch) in call.text.chars().enumerate() {
            let g = glyph(ch);
+            let x = pen + dx * g.offset;
+            let y = call.y + dy * g.offset;
+            let advance = g.advance + if bold { g.offset } else { 0.0 };
            if let Some(cell) = g.rect {
-                // BakedSheetGlyph: the glyph's own box from the pen, not a
-                // fixed 8x8 cell (a Unifont glyph is 0.5 units per texel).
-                let (x0, x1) = (x + g.left, x + g.right);
-                let (top, bottom) = (y0 + g.top, y0 + g.bottom);
-                let corners = [(x0, bottom), (x1, bottom), (x1, top), (x0, top)];
-                let uvs = [
-                    [cell.u0, cell.v1],
-                    [cell.u1, cell.v1],
-                    [cell.u1, cell.v0],
-                    [cell.u0, cell.v0],
-                ];
-                let c =
-                    0xFF00_0000 | (argb & 255) << 16 | (argb >> 8 & 255) << 8 | (argb >> 16 & 255);
-                for ((cx, cy), uv) in corners.into_iter().zip(uvs) {
-                    out.push(Vertex {
-                        normal: [0; 4],
-                        pos: call
-                            .matrix
-                            .transform_point3(Vec3::new(cx, cy, z))
-                            .to_array(),
-                        uv,
-                        layer: 0,
-                        color: c,
-                        light: call.light,
-
-                        glint_uv: [0.0, 0.0],
-                    });
+                let thick = if bold { 0.1 } else { 0.0 };
+                let shear = |v| {
+                    if call.style.is_italic() {
+                        1.0 - 0.25 * v
+                    } else {
+                        0.0
+                    }
+                };
+                for copy in 0..=usize::from(bold) {
+                    let x0 = x + copy as f32 * g.offset + g.left - thick;
+                    let x1 = x + copy as f32 * g.offset + g.right + thick;
+                    let top = y + g.top - thick;
+                    let bottom = y + g.bottom + thick;
+                    quad(
+                        [
+                            (x0 + shear(g.bottom), bottom),
+                            (x1 + shear(g.bottom), bottom),
+                            (x1 + shear(g.top), top),
+                            (x0 + shear(g.top), top),
+                        ],
+                        cell,
+                        z + copy as f32 * 0.001,
+                        argb,
+                    );
                }
            }
-            x += g.advance;
+            // `Font.prepare8xTextOutline` discards effects: only the front
+            // text gets underline/strikethrough, including over spaces.
+            if !outline && let Some(white) = white {
+                let x0 = if i == 0 { x - 1.0 } else { x };
+                for (enabled, top) in [
+                    (call.style.strikethrough, 3.5),
+                    (call.style.underlined, 8.0),
+                ] {
+                    if enabled == Some(true) {
+                        quad(
+                            [
+                                (x0, y + top + 1.0),
+                                (x + advance, y + top + 1.0),
+                                (x + advance, y + top),
+                                (x0, y + top),
+                            ],
+                            white,
+                            z + 0.01,
+                            argb,
+                        );
+                    }
+                }
+            }
+            pen += advance;
        }
    };
    if call.outline != 0 {
-        for (dx, dy) in [
-            (-1.0, -1.0),
-            (0.0, -1.0),
-            (1.0, -1.0),
-            (-1.0, 0.0),
-            (1.0, 0.0),
-            (-1.0, 1.0),
-            (0.0, 1.0),
-            (1.0, 1.0),
-        ] {
-            emit(dx, dy, 0.0, call.outline);
+        for dx in -1..=1 {
+            for dy in -1..=1 {
+                if dx != 0 || dy != 0 {
+                    emit(dx as f32, dy as f32, 0.0, call.outline, true);
+                }
+            }
        }
    }
-    let z = if call.outline != 0 {
-        TEXT_OVER_OUTLINE
-    } else {
-        0.0
-    };
-    emit(0.0, 0.0, z, call.color);
+    emit(
+        0.0,
+        0.0,
+        if call.outline != 0 {
+            TEXT_OVER_OUTLINE
+        } else {
+            0.0
+        },
+        call.color,
+        false,
+    );
 }

 /// Block-entity fields the level ticks, at one position (vanilla's own field
@@ -824,12 +932,16 @@ pub struct TextCall {
    pub x: f32,
    pub y: f32,
    pub text: String,
+    pub style: Style,
    /// ARGB.
    pub color: u32,
    /// ARGB outline colour, 0 for none.
    pub outline: u32,
    /// Horizon packed light (sky*16 | block*16 << 8).
    pub light: u32,
+    /// HDR emission tier of its glyphs (`mesher::hdr_tier`), 0 for none: glowing sign text
+    /// shines in HDR output and in shader packs (`horizonTier`), as full-bright text does in SDR.
+    pub tier: u8,
 }

 /// Inputs from the game for one frame of block-entity rendering.
@@ -868,6 +980,8 @@ pub struct Scene<'a> {
    pub skull: &'a dyn Fn([i32; 3]) -> Option<String>,
    /// Font glyph: atlas cell (none for blank glyphs such as the space), box and advance.
    pub glyph: &'a dyn Fn(char) -> Glyph,
+    /// Font providers, effects and random glyphs for styled sign text.
+    pub font: Option<&'a Font>,
    /// Changes whenever `glyph` may answer differently (`Font::epoch`): sign
    /// text laid out under another value is laid out again.
    pub glyphs: u64,
@@ -1029,6 +1143,7 @@ struct SignTextEntry {
    /// Game time it was last drawn.
    used: i64,
    vertices: Vec<Vertex>,
+    animated: bool,
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 struct StaticKey {
@@ -2335,9 +2450,11 @@ impl BlockEntityRenderer {
        let entry = match signs.entry(pos) {
            std::collections::hash_map::Entry::Occupied(mut occupied) => {
                let entry = occupied.get_mut();
+                let changed = entry.data != *data;
                if (entry.state, entry.packed, entry.near, entry.glyphs)
                    != (state, packed, near, glyphs)
-                    || entry.data != *data
+                    || changed
+                    || entry.animated
                {
                    entry.vertices.clear();
                    self.render_one(
@@ -2352,7 +2469,10 @@ impl BlockEntityRenderer {
                        &mut entry.vertices,
                    );
                    entry.state = state;
-                    entry.data.clone_from(data);
+                    if changed {
+                        entry.animated = sign_text_animated(data);
+                        entry.data.clone_from(data);
+                    }
                    entry.packed = packed;
                    entry.near = near;
                    entry.glyphs = glyphs;
@@ -2373,6 +2493,7 @@ impl BlockEntityRenderer {
                    &mut vertices,
                );
                vacant.insert(SignTextEntry {
+                    animated: sign_text_animated(data),
                    state,
                    data: data.clone(),
                    packed,
@@ -3612,6 +3733,7 @@ mod tests {
            skull: &|_| None,
            glyph: &|_| Glyph::default(),
            glyphs: 0,
+            font: None,
            dynamic_visible: None,
        };
        // Compare the cached world path with the original model renderer,
@@ -3774,6 +3896,105 @@ mod tests {
        // Straight down: ambient only.
        assert!((diffuse(-Vec3::Y, lights) - 0.4).abs() < 1e-6);
    }
+    /// A face's colour carries its tint alone and its normal carries the
+    /// shading: the entity shader applies `minecraft_mix_light` from it, as a
+    /// shader pack's lighting does, so a baked shade would be applied twice.
+    #[test]
+    fn a_face_keeps_its_tint_and_normal_for_the_shader_to_shade() {
+        let quad = |y: f32, z0: f32, z1: f32| {
+            [
+                [0.0, y, z0, 0.0, 0.0],
+                [0.0, y, z1, 0.0, 1.0],
+                [16.0, y, z1, 1.0, 1.0],
+                [16.0, y, z0, 1.0, 0.0],
+            ]
+        };
+        // Opposite windings: the first faces up, the second down.
+        let part = ModelPart {
+            pose: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0],
+            polygons: vec![quad(0.0, 0.0, 16.0), quad(16.0, 16.0, 0.0)],
+            children: vec![],
+        };
+        let mut out = Vec::new();
+        draw_part(
+            &part,
+            "root",
+            Mat4::IDENTITY,
+            &|_, _| {},
+            Paint {
+                sprite: Rect {
+                    u0: 0.0,
+                    v0: 0.0,
+                    u1: 1.0,
+                    v1: 1.0,
+                    w: 16,
+                    h: 16,
+                },
+                tint: 0x123456,
+                light: 0,
+                lights: diffuse_lights(false),
+                glow: None,
+            },
+            &mut out,
+        );
+        assert_eq!(out.len(), 8);
+        // The same tint on both faces: no directional shade baked in (`pack_color`
+        // stores the tint in the vertex colour's BGR byte order).
+        let tint = pack_color(0x12_3456, 255, 1.0);
+        assert!(out.iter().all(|v| v.color == tint));
+        let (up, down) = (&out[0], &out[4]);
+        assert_eq!(up.normal, [0, 127, 0, 127]);
+        assert_eq!(down.normal, [0, -127, 0, 127]);
+        // The shader still gets the difference the old baked colours held.
+        let lights = diffuse_lights(false);
+        let up_normal = Vec3::new(0.0, f32::from(up.normal[1]) / 127.0, 0.0);
+        let down_normal = Vec3::new(0.0, f32::from(down.normal[1]) / 127.0, 0.0);
+        assert!(diffuse(up_normal, lights) > diffuse(down_normal, lights));
+    }
+    /// Lights the entity shader does not know (an item preview's
+    /// `Lighting.Entry`) stay baked into the colour, and `normal.w` 0 tells
+    /// the shader to keep it: `game/item_draw` passes those for block-entity
+    /// items in inventories and hands.
+    #[test]
+    fn lights_other_than_the_levels_stay_baked() {
+        let part = ModelPart {
+            pose: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0],
+            polygons: vec![[
+                [0.0, 0.0, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 16.0, 0.0, 1.0],
+                [16.0, 0.0, 16.0, 1.0, 1.0],
+                [16.0, 0.0, 0.0, 1.0, 0.0],
+            ]],
+            children: vec![],
+        };
+        let lights = (Vec3::X, Vec3::Z);
+        let mut out = Vec::new();
+        draw_part(
+            &part,
+            "root",
+            Mat4::IDENTITY,
+            &|_, _| {},
+            Paint {
+                sprite: Rect {
+                    u0: 0.0,
+                    v0: 0.0,
+                    u1: 1.0,
+                    v1: 1.0,
+                    w: 16,
+                    h: 16,
+                },
+                tint: 0x12_3456,
+                light: 0,
+                lights,
+                glow: None,
+            },
+            &mut out,
+        );
+        let baked = pack_color(0x12_3456, 255, diffuse(Vec3::Y, lights));
+        assert!(out.iter().all(|v| v.color == baked));
+        assert!(out.iter().all(|v| v.normal == [0; 4]));
+        assert_ne!(baked, pack_color(0x12_3456, 255, 1.0));
+    }
    #[test]
    fn part_poses_compose_like_model_part() {
        let part = ModelPart {
@@ -3907,6 +4128,7 @@ mod tests {
            skull: &|_| None,
            glyph: &glyph,
            glyphs: 0,
+            font: None,
            dynamic_visible: None,
        };
        let mut call = TextCall {
@@ -3914,9 +4136,11 @@ mod tests {
            x: 0.0,
            y: 0.0,
            text: "Hi".into(),
+            style: Style::default(),
            color: 0xFFFF_FF00,
            outline: 0xFF33_3300,
            light: 240 | 240 << 8,
+            tier: 0,
        };
        let mut out = Vec::new();
        draw_text(&scene, &call, &mut out);
@@ -3980,6 +4204,7 @@ mod tests {
            skull: &|_| None,
            glyph: &glyph,
            glyphs: 0,
+            font: None,
            dynamic_visible: None,
        };
        let call = TextCall {
@@ -3987,9 +4212,11 @@ mod tests {
            x: 10.0,
            y: 2.0,
            text: "ab".into(),
+            style: Style::default(),
            color: 0xFF00_0000,
            outline: 0,
            light: 240 | 240 << 8,
+            tier: 0,
        };
        let mut out = Vec::new();
        draw_text(&scene, &call, &mut out);
@@ -4009,6 +4236,83 @@ mod tests {
        assert_eq!(boxes, [[10.0, 14.0, 2.0, 10.0], [15.0, 19.0, 2.0, 10.0]]);
    }

+    #[test]
+    fn styled_sign_quads_follow_vanilla_glyph_and_effect_bounds() {
+        let white = Rect {
+            u0: 0.0,
+            v0: 0.0,
+            u1: 0.1,
+            v1: 0.1,
+            w: 1,
+            h: 1,
+        };
+        let glyph = |c| Glyph {
+            rect: (c != ' ').then_some(white),
+            left: 0.0,
+            right: 4.0,
+            top: 0.0,
+            bottom: 8.0,
+            advance: 5.0,
+            offset: 0.5,
+        };
+        let mut call = TextCall {
+            matrix: Mat4::IDENTITY,
+            x: 0.0,
+            y: 0.0,
+            text: "A ".into(),
+            color: 0xff123456,
+            outline: 0,
+            light: 240,
+            tier: crate::mesher::LOW,
+            style: Style {
+                bold: Some(true),
+                italic: Some(true),
+                underlined: Some(true),
+                strikethrough: Some(true),
+                ..Default::default()
+            },
+        };
+        let mut out = Vec::new();
+        text_vertices(&glyph, Some(white), &call, &mut out);
+        // BakedSheetGlyph: bold expands by 0.1, italic shears by 1 - y/4,
+        // the second bold glyph is 0.5 along and 0.001 in front (Unihex).
+        assert_eq!(out.len(), 24);
+        for (got, expected) in out[0].pos.iter().zip([-1.1, 8.1, 0.0]) {
+            assert!((got - expected).abs() < 1e-6);
+        }
+        assert!((out[4].pos[0] - out[0].pos[0] - 0.5).abs() < 1e-6);
+        assert_eq!(out[4].pos[2], 0.001);
+        assert_eq!(out[8].pos, [-1.0, 4.5, 0.01]);
+        assert_eq!(out[12].pos, [-1.0, 9.0, 0.01]);
+        assert_eq!(out[21].pos, [11.0, 9.0, 0.01]); // underline crosses the space
+        assert!(out.iter().all(|v| v.color == 0xff563412 && v.light == 240));
+        call.outline = 0xff010203;
+        out.clear();
+        text_vertices(&glyph, Some(white), &call, &mut out);
+        // Eight outlines contain glyphs only; effects appear once, in front.
+        assert_eq!(out.len(), 8 * 8 + 24);
+        assert!((out[0].pos[0] - -1.6).abs() < 1e-6);
+        assert!(out[64..].iter().all(|v| v.pos[2] >= TEXT_OVER_OUTLINE));
+        // The glow tier reaches bold copies, outlines and decoration quads.
+        assert!(out.iter().all(|v| v.layer >> 16 == 1));
+        call.tier = 0;
+        out.clear();
+        text_vertices(&glyph, Some(white), &call, &mut out);
+        assert!(out.iter().all(|v| v.layer >> 16 == 0));
+    }
+
+    #[test]
+    fn styled_sign_clipping_counts_bold_width_and_preserves_resets() {
+        let line = Text::legacy("§lAB§r東Z");
+        let advance = |_: char, s: &Style| 5.0 + if s.is_bold() { 0.5 } else { 0.0 };
+        let shown = first_line(&line, 16.0, &advance);
+        assert_eq!(shown.plain(), "AB東");
+        assert_eq!(
+            shown.chars().map(|(_, s)| s.is_bold()).collect::<Vec<_>>(),
+            [true, true, false]
+        );
+    }
+
    /// The front text calls of a sign whose every glyph advances 6.
    fn front_calls(data: &SignData, near: bool) -> Vec<(String, f32, f32, u32, u32)> {
        let world = World::new(BlockStateId(0), 1);
@@ -4037,6 +4341,7 @@ mod tests {
            skull: &|_| None,
            glyph: &glyph,
            glyphs: 0,
+            font: None,
            dynamic_visible: None,
        };
        sign_text_calls(&scene, data, &data.front, Mat4::IDENTITY, 0, near)
@@ -4176,7 +4481,9 @@ mod tests {
            ..changed.clone()
        };
        let wide = std::cell::Cell::new(6.0);
+        let glyph_reads = std::cell::Cell::new(0);
        let glyph = |c: char| {
+            glyph_reads.set(glyph_reads.get() + 1);
            let u = f32::from(c as u8 % 16) / 16.0;
            let rect = Rect {
                u0: u,
@@ -4219,6 +4526,7 @@ mod tests {
            skull: &|_| None,
            glyph: &glyph,
            glyphs: 0,
+            font: None,
            dynamic_visible: None,
        };
        let check = |scene: &Scene, pos: [i32; 3], state: u32| {
@@ -4262,6 +4570,23 @@ mod tests {
        wide.set(5.0);
        scene.glyphs = 1;
        check(&scene, pos, 1);
+        // With the same game time and data, plain text reuses its vertices,
+        // but obfuscated text must ask the font for fresh glyphs each frame.
+        let mut vertices = Vec::new();
+        let reads = glyph_reads.get();
+        renderer.render(&scene, [(pos, 1)].iter(), &mut vertices);
+        assert_eq!(glyph_reads.get(), reads);
+        let animated = SignData {
+            front: text("§kSecret", false),
+            ..Default::default()
+        };
+        let animated_sign = |_| Some(&animated);
+        scene.sign = &animated_sign;
+        renderer.render(&scene, [(pos, 0)].iter(), &mut vertices);
+        let reads = glyph_reads.get();
+        renderer.render(&scene, [(pos, 0)].iter(), &mut vertices);
+        assert!(glyph_reads.get() > reads);
+        scene.sign = &first_sign;
        // Signs out of view for a while are dropped.
        scene.game_time = 2 * SIGN_TEXT_KEEP;
        check(&scene, pos, 0);
@@ -4269,11 +4594,23 @@ mod tests {
    }
    #[test]
    fn first_line_wraps_on_bytes_without_splitting_a_char() {
-        let advance = |c: char| if c == ' ' { 4.0 } else { 6.0 };
-        assert_eq!(first_line("ab cd ef", 13.0, &advance), "ab");
-        assert_eq!(first_line("abcdef", 13.0, &advance), "ab");
-        assert_eq!(first_line("\u{6771}", 3.0, &advance), "\u{6771}");
-        assert_eq!(first_line("ab\ncd", 100.0, &advance), "ab");
+        let advance = |c: char, _: &Style| if c == ' ' { 4.0 } else { 6.0 };
+        assert_eq!(
+            first_line(&Text::literal("ab cd ef"), 13.0, &advance).plain(),
+            "ab"
+        );
+        assert_eq!(
+            first_line(&Text::literal("abcdef"), 13.0, &advance).plain(),
+            "ab"
+        );
+        assert_eq!(
+            first_line(&Text::literal("\u{6771}"), 3.0, &advance).plain(),
+            "\u{6771}"
+        );
+        assert_eq!(
+            first_line(&Text::literal("ab\ncd"), 100.0, &advance).plain(),
+            "ab"
+        );
    }
    /// `rendertype_end_portal` culls back faces, and `AbstractEndPortalRenderer`
    /// submits the unit cube's two Y faces. Both are wound outward, so of each
@@ -4377,6 +4714,7 @@ mod tests {
            skull: &|_| None,
            glyph: &|_| Glyph::default(),
            glyphs: 0,
+            font: None,
            dynamic_visible: None,
        };
        let mut verts = Vec::new();
@@ -4463,6 +4801,7 @@ mod tests {
            skull: &|_| None,
            glyph: &|_| Glyph::default(),
            glyphs: 0,
+            font: None,
            dynamic_visible: None,
        };
        // A closed single chest of `block` drawn by `renderer`: positions and UVs.
@@ -358,6 +358,7 @@ fn batched_callbacks_preserve_entity_ranges_and_allow_immediate_culling() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    // Reverse local-position order to check that cache indexing does not
@@ -447,6 +448,7 @@ fn static_cache_qualifies_local_positions_by_section_and_drops_old_entries() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let options = CacheOptions {
@@ -502,6 +504,7 @@ fn gpu_static_cache_uses_section_local_chests_and_keeps_visibility_separate() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let blocks = [([100, 70, -32], 0)];
@@ -689,6 +692,7 @@ fn sign_text_cache_can_be_disabled_and_reenabled_without_changing_output() {
        skull: &|_| None,
        glyph: &glyph,
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
@@ -743,6 +747,7 @@ fn shulker_cache_tracks_settled_poses_and_does_not_freeze_opening_animation() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
@@ -845,6 +850,7 @@ fn shulker_cache_covers_all_colors_and_facing_directions() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let options = CacheOptions {
@@ -900,6 +906,7 @@ fn cached_bells_keep_shaking_until_the_animation_ends() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
@@ -962,6 +969,7 @@ fn cached_closed_chests_match_the_direct_model_and_rebuild_when_opening() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
@@ -993,7 +1001,9 @@ fn cached_closed_chests_match_the_direct_model_and_rebuild_when_opening() {
    scene.nether = true;
    let nether_closed = render_cached(&scene);
    assert_same_vertices(&nether_closed, &render_direct(&renderer, &scene, &blocks));
-    assert_vertices_differ(&closed_again, &nether_closed);
+    // The nether is the entity shader's flag now (`entity_light`'s `l1` and
+    // `globals.time.y`), not a baked colour, so the cached geometry serves both.
+    assert_same_vertices(&closed_again, &nether_closed);
 }

 #[test]
@@ -1058,6 +1068,7 @@ fn closed_chest_cache_covers_all_materials_and_atlas_reloads() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let pos = [0, 64, 0];
@@ -1147,6 +1158,7 @@ fn double_chest_cache_bypasses_both_halves_while_either_lid_is_open() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let pair = [([0, 64, 0], 0), ([1, 64, 0], 1)];
@@ -1223,6 +1235,7 @@ fn decorated_pot_cache_tracks_sherds_and_bypasses_wobble_animation() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
@@ -1302,6 +1315,7 @@ fn banner_cache_keeps_the_pole_static_while_the_flag_and_patterns_update() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
@@ -1369,6 +1383,7 @@ fn cached_wall_banner_poles_use_the_wall_model() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let pos = [0, 64, 0];
@@ -1417,6 +1432,7 @@ fn copper_statue_cache_rebuilds_when_its_pose_state_changes() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let options = CacheOptions {
@@ -1523,6 +1539,7 @@ fn copper_statue_cache_covers_weathering_waxing_and_all_poses() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        font: None,
        dynamic_visible: None,
    };
    let options = CacheOptions {
@@ -620,6 +620,14 @@ impl Chunk {
            entities: Vec::new(),
        }
    }
+    /// The original `structures.starts`, including starts with unknown pieces.
+    pub fn saved_structure_starts(&self) -> Option<&horizon_world::nbt::Compound> {
+        let structures = self.saved.as_ref()?.root.get(&"structures".into())?;
+        match structures.get("starts")? {
+            horizon_world::nbt::Tag::Compound(starts) => Some(starts),
+            _ => None,
+        }
+    }
    /// The minimum block Y of the column.
    #[inline]
    pub fn min_y(&self) -> i32 {
@@ -59,6 +59,9 @@ pub enum BlockEntity {
    CreakingHeart(Box<CreakingHeart>),
    /// `BannerBlockEntity`: the pattern layers.
    Banner(Banner),
+    /// `CopperGolemStatueBlockEntity`: its own components, which hold the
+    /// custom name of the golem it was (`createStatue`).
+    CopperGolemStatue(Compound),
    /// `CrafterBlockEntity`.
    Crafter(Crafter),
    /// `SpawnerBlockEntity` (`crate::mobs::spawner`).
@@ -80,6 +83,8 @@ pub enum BlockEntity {
    /// `DaylightDetectorBlockEntity`: no data, only the ticker
    /// (`DaylightDetectorBlock.tickEntity`).
    DaylightDetector,
+    /// `BellBlockEntity`: saved identity only; ringing state is kept separately.
+    Bell,
    /// Suspicious sand and gravel: saved loot and the transient brushed face.
    Brushable(Box<Brushable>),
    /// A shelf holds three displayed item stacks.
@@ -449,6 +454,9 @@ pub struct Jukebox {
    pub items: [Option<ItemStack>; 1],
    /// `ticks_since_song_started`, while a song plays.
    pub ticks: i64,
+    /// `JukeboxBlockEntity.saveAdditional` writes the clock only when its song
+    /// reference exists. Keep this separate from legacy playback adoption.
+    pub song_clock_present: bool,
    pub playing: bool,
 }
 impl Jukebox {
@@ -208,7 +208,7 @@ where
        Ok(resolve_world_movement(
            self,
            MovementRequest {
-                entity: EntityIdentity(0),
+                entity: context.entity().unwrap_or(EntityIdentity(0)),
                context,
                bounds,
                movement,
@@ -279,7 +279,7 @@ impl SceneCollisions<'_, '_> {
        Ok(resolve_world_movement(
            self,
            MovementRequest {
-                entity: EntityIdentity(0),
+                entity: context.entity().unwrap_or(EntityIdentity(0)),
                context,
                bounds,
                movement,
@@ -300,6 +300,7 @@ impl SceneCollisions<'_, '_> {
        CollisionContext::for_entity(
            CollisionEntity {
                identity: EntityIdentity(0),
+                kind: horizon_world::collision_context::EntityContextKind::Living,
                y,
                descending: false,
                main_hand: Some(CollisionItem::EMPTY),
@@ -335,6 +336,26 @@ where
 {
    no_collision_in(world, bounds, true)
 }
+/// `CollisionGetter.noCollision(entity, bounds)`: retain the real entity snapshot.
+pub fn no_collision_with_context<W, E>(
+    world: &mut W,
+    bounds: Aabb,
+    context: CollisionContext<'_>,
+) -> bool
+where
+    W: BlockCollisionWorld<Error = E> + EntityMovementWorld<Error = E>,
+{
+    no_world_collision(
+        world,
+        CollisionCheckRequest {
+            entity: context.entity().unwrap_or(EntityIdentity(0)),
+            context,
+            bounds,
+            candidate_budget: 1_000_000,
+        },
+    )
+    .unwrap_or(false)
+}
 fn no_collision_in<W, E>(world: &mut W, bounds: Aabb, fluids: bool) -> bool
 where
    W: BlockCollisionWorld<Error = E> + EntityMovementWorld<Error = E>,
@@ -392,9 +392,15 @@ impl BlockEntity {
        if name == "minecraft:end_gateway" {
            return Some(Self::EndGateway(EndGateway::default()));
        }
+        if name == "minecraft:bell" {
+            return Some(Self::Bell);
+        }
        if name == "minecraft:daylight_detector" {
            return Some(Self::DaylightDetector);
        }
+        if name.ends_with("copper_golem_statue") {
+            return Some(Self::CopperGolemStatue(Default::default()));
+        }
        if name == "minecraft:beacon" {
            return Some(Self::Beacon(Box::new(Beacon {
                last_check_y: i32::MIN / 2,
@@ -460,6 +466,7 @@ impl BlockEntity {
            Self::CommandBlock(_) => crate::command_block::Mode::of_block(name).is_some(),
            Self::Skull(_) => is_skull(name),
            Self::Banner(_) => name.ends_with("_banner"),
+            Self::CopperGolemStatue(_) => name.ends_with("copper_golem_statue"),
            Self::Shelf(_) => name == "minecraft:shelf" || name.ends_with("_shelf"),
            Self::Mod(_) => !name.starts_with("minecraft:"),
            Self::Beehive(_) => matches!(name, "minecraft:beehive" | "minecraft:bee_nest"),
@@ -483,6 +490,7 @@ impl BlockEntity {
            Self::Crafter(_) => name == "minecraft:crafter",
            Self::EndGateway(_) => name == "minecraft:end_gateway",
            Self::DaylightDetector => name == "minecraft:daylight_detector",
+            Self::Bell => name == "minecraft:bell",
            Self::StructureBlock(_) => name == "minecraft:structure_block",
            Self::TestBlock(_) => name == "minecraft:test_block",
            Self::TestInstanceBlock(_) => name == "minecraft:test_instance_block",
@@ -510,6 +518,7 @@ impl BlockEntity {
            Self::Lectern(_) => "minecraft:lectern",
            Self::Sculk(s) => s.id(),
            Self::Banner(_) => "minecraft:banner",
+            Self::CopperGolemStatue(_) => "minecraft:copper_golem_statue",
            Self::Crafter(_) => "minecraft:crafter",
            Self::CreakingHeart(_) => "minecraft:creaking_heart",
            Self::Spawner(_) => "minecraft:mob_spawner",
@@ -520,6 +529,7 @@ impl BlockEntity {
            Self::Skull(_) => "minecraft:skull",
            Self::EndGateway(_) => "minecraft:end_gateway",
            Self::DaylightDetector => "minecraft:daylight_detector",
+            Self::Bell => "minecraft:bell",
            Self::Brushable(_) => "minecraft:brushable_block",
            Self::Campfire(_) => "minecraft:campfire",
            Self::ChiseledBookshelf(_) => "minecraft:chiseled_bookshelf",
@@ -554,11 +564,12 @@ impl BlockEntity {
            | Self::TestBlock(_)
            | Self::TestInstanceBlock(_)
            | Self::DaylightDetector
+            | Self::Bell
            | Self::Brushable(_) => Vec::new(),
            Self::Mod(m) => m.items.iter().flatten().cloned().collect(),
            Self::Lectern(l) => l.book.iter().cloned().collect(),
            Self::Sculk(_) => Vec::new(),
-            Self::Banner(_) => Vec::new(),
+            Self::Banner(_) | Self::CopperGolemStatue(_) => Vec::new(),
            Self::Crafter(c) => c.items.iter().flatten().cloned().collect(),
            Self::Campfire(c) => c.items.iter().flatten().cloned().collect(),
            Self::ChiseledBookshelf(b) => b.items.iter().flatten().cloned().collect(),
@@ -575,6 +586,7 @@ impl BlockEntity {
            | Self::Lectern(_)
            | Self::Sculk(_)
            | Self::Banner(_)
+            | Self::CopperGolemStatue(_)
            | Self::EndGateway(_)
            | Self::Skull(_)
            | Self::PotentSulfur(_)
@@ -583,6 +595,7 @@ impl BlockEntity {
            | Self::TestBlock(_)
            | Self::TestInstanceBlock(_)
            | Self::DaylightDetector
+            | Self::Bell
            | Self::Brushable(_) => &[],
            Self::Jukebox(j) => &j.items,
            Self::Crafter(c) => &c.items,
@@ -609,6 +622,7 @@ impl BlockEntity {
            | Self::Lectern(_)
            | Self::Sculk(_)
            | Self::Banner(_)
+            | Self::CopperGolemStatue(_)
            | Self::EndGateway(_)
            | Self::Skull(_)
            | Self::PotentSulfur(_)
@@ -617,6 +631,7 @@ impl BlockEntity {
            | Self::TestBlock(_)
            | Self::TestInstanceBlock(_)
            | Self::DaylightDetector
+            | Self::Bell
            | Self::Brushable(_) => &mut [],
            Self::Jukebox(j) => &mut j.items,
            Self::Crafter(c) => &mut c.items,
@@ -83,6 +83,13 @@ fn choice_description(opt: Opt, pad: &PadSettings) -> Option<&'static str> {
            GlyphStyle::PlayStation => "Always shows PlayStation buttons.",
            GlyphStyle::Nintendo => "Always shows Nintendo buttons.",
        },
+        Opt::PadNintendoButtons => {
+            if pad.nintendo_letters {
+                "A, on the right, confirms and jumps and B goes back, as on a Switch."
+            } else {
+                "B, at the bottom, confirms and jumps and A goes back, as on other controllers."
+            }
+        }
        Opt::PadKeyboard => match pad.keyboard {
            gamepad::TextKeyboard::Auto => {
                "Opens Steam's keyboard on a Steam Deck under Steam, and Horizon's otherwise."
@@ -184,6 +191,10 @@ pub fn rows() -> Vec<(Page, Vec<(&'static str, Vec<Setting>)>)> {
                            Opt::PadGameplayGuide,
                            "Show the buttons for what you can do, while you play with a controller.",
                        ),
+                        option(
+                            Opt::PadCraftOnServers,
+                            "Lets LT + A craft on servers other than your own worlds. Some servers count it as a macro.",
+                        ),
                        option(
                            Opt::PadTriggerThreshold,
                            "How far a trigger is pulled before it counts as pressed.",
@@ -261,6 +272,10 @@ pub fn rows() -> Vec<(Page, Vec<(&'static str, Vec<Setting>)>)> {
                            Opt::PadGlyphs,
                            "Follow the controller, or always show one family's buttons.",
                        ),
+                        option(
+                            Opt::PadNintendoButtons,
+                            "Whether a Nintendo controller's A and B work by where they sit or by their letters.",
+                        ),
                        info(Info::Using, "The buttons menus show right now."),
                    ],
                ),
@@ -333,6 +348,7 @@ impl Item {
            Item::Option(Opt::PadAdaptiveTriggers) => Some(c.adaptive_triggers),
            Item::Option(Opt::PadInvertX) => Some(c.invert_x),
            Item::Option(Opt::PadInvertY) => Some(c.invert_y),
+            Item::Option(Opt::PadCraftOnServers) => Some(c.craft_on_servers),
            _ => None,
        }
    }
@@ -1332,6 +1348,7 @@ mod tests {
            Opt::PadLookDeadzone,
            Opt::PadTriggerThreshold,
            Opt::PadGlyphs,
+            Opt::PadNintendoButtons,
            Opt::PadKeyboard,
            Opt::PadPointerSpeed,
            Opt::PadScrollSpeed,
@@ -1429,6 +1446,53 @@ mod tests {
        assert!((s.controller.move_deadzone - before - 0.01).abs() < 0.001);
    }

+    /// The Device page's Nintendo Buttons row sits with the glyphs, steps between its two
+    /// values rather than ticking a box, and what it sets is what the controller file keeps.
+    #[test]
+    fn the_nintendo_buttons_row_flips_letters_and_the_file_keeps_it() {
+        let (page, group) = rows()
+            .into_iter()
+            .flat_map(|(page, groups)| groups.into_iter().map(move |g| (page, g)))
+            .find(|(_, (_, rows))| {
+                rows.iter()
+                    .any(|r| r.item == Item::Option(Opt::PadNintendoButtons))
+            })
+            .unwrap();
+        assert_eq!((page, group.0), (Page::Device, "Glyphs"));
+        let mut s = Settings::default();
+        let item = Item::Option(Opt::PadNintendoButtons);
+        assert!(item.steps(&s));
+        s.controller.nintendo_letters = false;
+        let mut ui = ControllerUi {
+            focus: Some(Target::Item(item)),
+            ..ControllerUi::default()
+        };
+        // Vanilla's caption and value template; Horizon's own words come bundled.
+        struct Vanilla;
+        impl lang::ResourceSource for Vanilla {
+            fn read(&self, path: &str) -> Option<Vec<u8>> {
+                (path == "assets/minecraft/lang/en_us.json")
+                    .then(|| br#"{"options.generic_value": "%s: %s"}"#.to_vec())
+            }
+        }
+        let value = |ui: &ControllerUi, s: &Settings| {
+            lang::scoped(lang::Language::load(&[&Vanilla], "en_us"), || {
+                ui.parts(item, s)
+            })
+            .0
+        };
+        assert_eq!(value(&ui, &s).0, "Nintendo Buttons");
+        assert_eq!(value(&ui, &s).1.as_deref(), Some("By Position"));
+        let actions = key(&mut ui, &mut s, K::Enter);
+        assert!(actions.contains(&Action::Changed), "{actions:?}");
+        assert!(s.controller.nintendo_letters);
+        assert_eq!(value(&ui, &s).1.as_deref(), Some("By Letter"));
+        assert!(PadSettings::parse(&s.controller.serialize()).nintendo_letters);
+        key(&mut ui, &mut s, K::Enter);
+        assert!(!s.controller.nintendo_letters);
+        assert!(!PadSettings::parse(&s.controller.serialize()).nintendo_letters);
+    }
+
    /// What the screen draws at the bottom of the page changes with the choice, in every one of
    /// these settings.
    #[test]
@@ -1438,6 +1502,7 @@ mod tests {
        for (opt, choices) in [
            (Opt::PadGameplayGuide, 3),
            (Opt::PadGlyphs, 4),
+            (Opt::PadNintendoButtons, 2),
            (Opt::PadKeyboard, 3),
            (Opt::PadLightbar, 3),
        ] {
@@ -1470,6 +1535,7 @@ mod tests {
            for opt in [
                Opt::PadGameplayGuide,
                Opt::PadGlyphs,
+                Opt::PadNintendoButtons,
                Opt::PadKeyboard,
                Opt::PadLightbar,
            ] {
@@ -141,7 +141,8 @@ impl DataPack {
 pub fn discover(world: &Path) -> Vec<DataPack> {
    discover_folder(&world.join("datapacks"))
 }
-/// Packs in Create World's temporary pack folder, before a world exists.
+/// `FolderRepositorySource.loadPacks`: packs in Create World's temporary
+/// folder or a world's data-pack directory, with required folder metadata.
 pub fn discover_folder(dir: &Path) -> Vec<DataPack> {
    let Ok(entries) = std::fs::read_dir(dir) else {
        return Vec::new();
@@ -150,7 +151,7 @@ pub fn discover_folder(dir: &Path) -> Vec<DataPack> {
    for e in entries.flatten() {
        let name = e.file_name().to_string_lossy().into_owned();
        let path = e.path();
-        if path.is_dir() && path.join("pack.mcmeta").exists() {
+        if path.is_dir() && folder_metadata_present(&path) {
            packs.push(DataPack {
                id: format!("file/{name}"),
                source: Source::Dir(path),
@@ -168,6 +169,22 @@ pub fn discover_folder(dir: &Path) -> Vec<DataPack> {
    packs.sort_by(|a, b| a.id.cmp(&b.id));
    packs
 }
+/// `Pack.readPackMetadata`: even its fallback codec requires a pack section
+/// and description. Keep this folder gate separate from format compatibility
+/// and the existing interpretation of the description component.
+fn folder_metadata_present(path: &Path) -> bool {
+    let Some(meta) = std::fs::read(path.join("pack.mcmeta"))
+        .ok()
+        .and_then(|bytes| crate::packs::parse_meta(&bytes))
+    else {
+        return false;
+    };
+    meta.as_object()
+        .and_then(|root| root.get("pack"))
+        .and_then(serde_json::Value::as_object)
+        .and_then(|pack| pack.get("description"))
+        .is_some_and(|description| !description.is_null())
+}
 /// The resources root's built-in feature packs (`ServerPacksSource`
 /// scanning the game's `data/minecraft/datapacks`): every folder with a
 /// `pack.mcmeta`, a feature pack (`PackSource.FEATURE`). Off until a world
@@ -261,6 +278,43 @@ pub fn screen_packs(dir: &Path, resources: &Path) -> Vec<crate::pack_screen::Pac
    }
    infos
 }
+/// The folder of a game folder whose packs every new world there starts with: a modpack's profile
+/// keeps the packs of its data-only jars here (`horizon-port-pack`). Each world gets its own copy,
+/// as Create World's packs do, so a world keeps working when the folder changes. Vanilla has no
+/// such folder, and without one nothing here happens.
+pub const NEW_WORLD_PACKS: &str = "new-world-datapacks";
+
+/// Create World's temporary pack folder holding `game_dir`'s [`NEW_WORLD_PACKS`], and their ids,
+/// to show them selected in the Data Packs screen. `None` when there are none.
+pub fn seed_create_world(game_dir: &Path) -> Option<(PathBuf, Vec<String>)> {
+    let from = game_dir.join(NEW_WORLD_PACKS);
+    let ids: Vec<String> = discover_folder(&from).into_iter().map(|p| p.id).collect();
+    if ids.is_empty() {
+        return None;
+    }
+    let seeded = temp_folder()
+        .map_err(|e| e.to_string())
+        .and_then(|dir| copy(&from, &dir).map(|()| dir));
+    match seeded {
+        Ok(dir) => Some((dir, ids)),
+        Err(e) => {
+            log::warn!("Horizon: data packs for new worlds: {e}");
+            None
+        }
+    }
+}
+
+/// A world about to be created without Create World (`--world`, the control socket) gets
+/// `game_dir`'s [`NEW_WORLD_PACKS`]. The game turns on every pack it finds in a world.
+pub fn install_new_world_packs(game_dir: &Path, world: &Path) -> Result<(), String> {
+    let from = game_dir.join(NEW_WORLD_PACKS);
+    let exists = |name: &str| world.join(name).exists();
+    if !from.is_dir() || exists("level.dat") || exists("level.dat_old") {
+        return Ok(());
+    }
+    copy(&from, &world.join("datapacks"))
+}
+
 /// A new empty folder for Create World's packs
 /// (`Files.createTempDirectory("mcworld-")`).
 pub fn temp_folder() -> std::io::Result<PathBuf> {
@@ -608,7 +662,7 @@ pub struct DataStore {
    /// `item_modifier` files, for `/item modify`.
    pub item_modifiers: BTreeMap<String, serde_json::Value>,
    /// The content tables' raw files from the packs after the built-in one:
-    /// `recipe/`, `recipe_filter/`, `loot_table/`, `advancement/`, `dialog/`, `damage_type/`, `data_maps/` and `tags/…/` files, by
+    /// `recipe/`, `recipe_filter/`, `loot_table/`, `advancement/`, `dialog/`, `damage_type/`, `data_maps/`, `enchantment/` and `tags/…/` files, by
    /// `<kind-dir>/<ns>:<path>`, each id's files in pack order. The tables
    /// merge them over what they read from the resource root.
    pub files: BTreeMap<String, Vec<Vec<u8>>>,
@@ -617,7 +671,7 @@ pub struct DataStore {
 }
 /// `<kind-dir>/<ns>:<path>` for a pack file the content tables read:
 /// `recipe/`, `recipe_filter/`, `loot_table/`, `advancement/`, `trade_set/`,
-/// `villager_trade/`, `dialog/`, `damage_type/`, `data_maps/` or `tags/<sub>/`, where the id keeps the sub
+/// `villager_trade/`, `dialog/`, `damage_type/`, `data_maps/`, `enchantment/` or `tags/<sub>/`, where the id keeps the sub
 /// path so a nested tag kind stays addressable.
 fn content_id(file: &str) -> Option<String> {
    let rest = file.strip_prefix("data/")?;
@@ -625,7 +679,7 @@ fn content_id(file: &str) -> Option<String> {
    let (kind, rest) = rest.split_once('/')?;
    let kind = match kind {
        "recipe" | "recipe_filter" | "loot_table" | "advancement" | "trade_set"
-        | "villager_trade" | "dialog" | "damage_type" | "data_maps" => kind,
+        | "villager_trade" | "dialog" | "damage_type" | "data_maps" | "enchantment" => kind,
        // A tag id is `{ns}:{path-under-tags}` (`tags/worldgen/biome/
        // test:sub/mytag`), the whole path after the namespace, so nested
        // registries keep their directory (`TagLoader`'s id shape).
@@ -659,6 +713,7 @@ impl DataStore {
                "damage_type",
                "data_maps",
                "dialog",
+                "enchantment",
                "function",
                "item_modifier",
                "loot_table",
@@ -714,15 +769,55 @@ impl DataStore {
        }
        s
    }
-    /// `FunctionManager.getTag`: the functions a tag expands to (nested tags
-    /// included, each function once).
+    /// `ServerFunctionLibrary.getTag`: only valid function tags expand
+    /// (nested tags included, each function once).
    pub fn tag_functions(&self, id: &str) -> Vec<String> {
        let mut out = Vec::new();
        let mut seen_fns = std::collections::HashSet::new();
        let mut seen_tags = std::collections::HashSet::new();
-        self.expand(id, &mut out, &mut seen_fns, &mut seen_tags);
+        let invalid = self.invalid_function_tags(id);
+        self.expand(id, &mut out, &mut seen_fns, &mut seen_tags, &invalid);
        out
    }
+    /// `TagLoader.tryBuildTag`: missing required members invalidate their tag and
+    /// required parents. Optional invalid children contribute nothing.
+    /// Resolve against the current accepted function map, without caching a
+    /// candidate store or changing the existing expansion's cycle handling.
+    fn invalid_function_tags<'a>(&'a self, id: &'a str) -> std::collections::HashSet<&'a str> {
+        let mut invalid = std::collections::HashSet::new();
+        let mut parents: std::collections::HashMap<&str, Vec<&str>> =
+            std::collections::HashMap::new();
+        let mut seen = std::collections::HashSet::new();
+        let mut pending = vec![id];
+        while let Some(tag) = pending.pop() {
+            if !seen.insert(tag) {
+                continue;
+            }
+            let Some(entries) = self.function_tags.get(tag) else {
+                invalid.insert(tag);
+                continue;
+            };
+            for (entry, required) in entries {
+                if let Some(child) = entry.strip_prefix('#') {
+                    pending.push(child);
+                    if *required {
+                        parents.entry(child).or_default().push(tag);
+                    }
+                } else if *required && !self.functions.contains_key(entry) {
+                    invalid.insert(tag);
+                }
+            }
+        }
+        pending.extend(invalid.iter().copied());
+        while let Some(child) = pending.pop() {
+            for &parent in parents.get(child).into_iter().flatten() {
+                if invalid.insert(parent) {
+                    pending.push(parent);
+                }
+            }
+        }
+        invalid
+    }
    /// Depth-first walk keeping first-seen order. Each tag is expanded at most
    /// once, so reference cycles end and nesting depth is not capped.
    fn expand<'a>(
@@ -731,18 +826,19 @@ impl DataStore {
        out: &mut Vec<String>,
        seen_fns: &mut std::collections::HashSet<&'a str>,
        seen_tags: &mut std::collections::HashSet<&'a str>,
+        invalid: &std::collections::HashSet<&'a str>,
    ) {
-        if !seen_tags.insert(id) {
+        if invalid.contains(id) || !seen_tags.insert(id) {
            return;
        }
        let Some(entries) = self.function_tags.get(id) else {
            return;
        };
-        for (e, required) in entries {
+        for (e, _) in entries {
            match e.strip_prefix('#') {
-                Some(inner) => self.expand(inner, out, seen_fns, seen_tags),
+                Some(inner) => self.expand(inner, out, seen_fns, seen_tags, invalid),
                None => {
-                    if (self.functions.contains_key(e) || *required) && seen_fns.insert(e) {
+                    if self.functions.contains_key(e) && seen_fns.insert(e) {
                        out.push(e.clone());
                    }
                }
@@ -924,6 +1020,97 @@ pub fn worldgen_overrides(
 mod tests {
    use super::*;

+    #[test]
+    fn folder_metadata_is_required_before_contents_are_discovered() {
+        let root =
+            std::env::temp_dir().join(format!("horizon-folder-metadata-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&root);
+        for (name, metadata) in [
+            ("broken", Some("{")),
+            ("root_empty", Some("{}")),
+            ("root_array", Some("[]")),
+            ("pack_empty", Some(r#"{"pack":{}}"#)),
+            ("pack_string", Some(r#"{"pack":"bad"}"#)),
+            ("missing", None),
+            (
+                "full",
+                Some(
+                    r#"{"pack":{"description":"full","pack_format":121,"min_format":[121,0],"max_format":[121,0]}}"#,
+                ),
+            ),
+            (
+                "description",
+                Some(r#"{"pack":{"description":"description only"}}"#),
+            ),
+            ("numeric", Some(r#"{"pack":{"description":42}}"#)),
+            ("null", Some(r#"{"pack":{"description":null}}"#)),
+            ("bom", Some("\u{feff}{\"pack\":{\"description\":\"BOM\"}}")),
+            (
+                "comment",
+                Some("{\"pack\":{\"description\":\"comment\"}}\n// trailing"),
+            ),
+        ] {
+            let dir = root.join(name);
+            std::fs::create_dir_all(dir.join("data/h146/function")).unwrap();
+            std::fs::write(
+                dir.join(format!("data/h146/function/{name}.mcfunction")),
+                "scoreboard players set admitted h146 1\n",
+            )
+            .unwrap();
+            if let Some(metadata) = metadata {
+                std::fs::write(dir.join("pack.mcmeta"), metadata).unwrap();
+            }
+        }
+        let packs = discover_folder(&root);
+        assert_eq!(
+            packs.iter().map(|p| p.id.as_str()).collect::<Vec<_>>(),
+            [
+                "file/bom",
+                "file/comment",
+                "file/description",
+                "file/full",
+                "file/numeric"
+            ]
+        );
+        let store = DataStore::load(&packs.iter().collect::<Vec<_>>());
+        assert_eq!(
+            store
+                .functions
+                .keys()
+                .map(String::as_str)
+                .collect::<Vec<_>>(),
+            [
+                "h146:bom",
+                "h146:comment",
+                "h146:description",
+                "h146:full",
+                "h146:numeric"
+            ]
+        );
+        let numeric = packs.iter().find(|p| p.id == "file/numeric").unwrap();
+        let raw: serde_json::Value =
+            serde_json::from_slice(&numeric.read("pack.mcmeta").unwrap()).unwrap();
+        assert_eq!(raw["pack"]["description"], 42);
+        // Builtin and feature construction still have their independent paths.
+        let resources = root.join("resources");
+        let feature = resources.join("data/minecraft/datapacks/feature");
+        std::fs::create_dir_all(&feature).unwrap();
+        std::fs::write(
+            feature.join("pack.mcmeta"),
+            r#"{"pack":{"description":"feature"}}"#,
+        )
+        .unwrap();
+        assert_eq!(
+            feature_packs(&resources)
+                .iter()
+                .map(|p| p.id.as_str())
+                .collect::<Vec<_>>(),
+            ["feature"]
+        );
+        assert_eq!(DataPack::builtin(&resources).id, "vanilla");
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
    #[test]
    fn data_map_files_are_content_files_keyed_by_map_namespace_and_registry() {
        assert_eq!(
@@ -951,6 +1138,35 @@ mod tests {
        let _ = std::fs::remove_dir_all(&root);
    }

+    #[test]
+    fn a_game_folder_s_new_world_packs_go_into_new_worlds_only() {
+        let root = std::env::temp_dir().join(format!("hz-new-world-packs-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&root);
+        let (game, world, old) = (root.join("game"), root.join("new"), root.join("old"));
+        assert!(seed_create_world(&game).is_none());
+        assert_eq!(install_new_world_packs(&game, &world), Ok(()));
+        assert!(!world.join("datapacks").exists());
+        for pack in ["void", "islands"] {
+            let dir = game.join(NEW_WORLD_PACKS).join(pack);
+            std::fs::create_dir_all(dir.join("data/v/function")).unwrap();
+            std::fs::write(dir.join("pack.mcmeta"), r#"{"pack":{"description":""}}"#).unwrap();
+            std::fs::write(dir.join("data/v/function/a.mcfunction"), "say a").unwrap();
+        }
+        let (temp, ids) = seed_create_world(&game).unwrap();
+        assert_eq!(ids, ["file/islands", "file/void"]);
+        assert!(temp.join("void/data/v/function/a.mcfunction").is_file());
+        let _ = std::fs::remove_dir_all(&temp);
+        install_new_world_packs(&game, &world).unwrap();
+        let ids: Vec<String> = discover(&world).into_iter().map(|p| p.id).collect();
+        assert_eq!(ids, ["file/islands", "file/void"]);
+        // A world that exists already keeps the packs it has.
+        std::fs::create_dir_all(&old).unwrap();
+        std::fs::write(old.join("level.dat"), "").unwrap();
+        install_new_world_packs(&game, &old).unwrap();
+        assert!(discover(&old).is_empty());
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
    #[test]
    fn enabled_packs_override_worldgen_in_order() {
        let dir = std::env::temp_dir().join(format!("hz-datapack-worldgen-{}", std::process::id()));
@@ -961,7 +1177,7 @@ mod tests {
            std::fs::write(path, t).unwrap();
        };
        for pack in ["a", "b", "off"] {
-            write(pack, "pack.mcmeta", "{}");
+            write(pack, "pack.mcmeta", r#"{"pack":{"description":"fixture"}}"#);
            write(pack, "data/minecraft/worldgen/noise/cave.json", pack);
            write(pack, "data/p/structure/room/a.nbt", pack);
            write(
@@ -1132,6 +1348,20 @@ mod tests {
    #[test]
    fn tag_resolution_dedupes_fast_ends_cycles_and_nests_deeply() {
        let mut store = DataStore::default();
+        // Every referenced function exists; missing required ones invalidate a tag.
+        for id in (0..25_000)
+            .map(|i| format!("t:f{i}"))
+            .chain(["t:x", "t:y", "t:deep"].map(str::to_owned))
+        {
+            store.functions.insert(
+                id.clone(),
+                Function {
+                    id,
+                    lines: Vec::new(),
+                    parameters: Vec::new(),
+                },
+            );
+        }
        let big: Vec<(String, bool)> = (0..50_000)
            .map(|i| (format!("t:f{}", i % 25_000), true))
            .collect();
@@ -1216,13 +1446,13 @@ mod tests {
        write(
            "fns",
            "pack.mcmeta",
-            r#"{"pack":{"min_format":121,"max_format":121}}"#,
+            r#"{"pack":{"description":"fixture","min_format":121,"max_format":121}}"#,
        );
        write("fns", "data/x/function/f.mcfunction", "say hi");
        write(
            "off",
            "pack.mcmeta",
-            r#"{"pack":{"min_format":121,"max_format":121}}"#,
+            r#"{"pack":{"description":"fixture","min_format":121,"max_format":121}}"#,
        );
        std::fs::create_dir_all(&dir).unwrap();
        let mut zip = zip::ZipWriter::new(std::fs::File::create(dir.join("old.zip")).unwrap());
@@ -399,8 +399,11 @@ pub fn apply_weather(sky: &mut Sky, rain: f32, thunder: f32) {
 pub fn sky_darken(environment: &Environment, day_time: i64, rain: f32, thunder: f32) -> i32 {
    let mut sky = environment.sample(day_time, None, None);
    apply_weather(&mut sky, rain, thunder);
-    // Level.updateSkyBrightness: darkening from the sky light level.
-    (15.0 - 15.0 * sky.sky_light_level).round() as i32
+    // Level.updateSkyBrightness: `(int)(15.0F - skyLightLevel)`, the float
+    // truncated, not rounded (#11323): the darkening steps up only once the
+    // light has fallen a whole level. `sky_light_level` is the attribute as a
+    // fraction of 15, so the product is its raw value in `f32`.
+    (15.0 - 15.0 * sky.sky_light_level) as i32
 }

 #[cfg(test)]
@@ -5,7 +5,7 @@ use crate::{
    lang,
    options_ui::{Event, Page},
    settings::Settings,
-    settings_shell::{Group, Output, Row, Screen, Sheet, Value},
+    settings_shell::{self as shell, Group, Output, Row, Screen, Sheet, Value},
 };

 const TITLE: &str = "horizon.pages.extras";
@@ -85,6 +85,10 @@ impl Screen for ExtrasScreen {
    fn note_lines(&self) -> usize {
        NOTE_LINES
    }
+    /// The rows read the extras, the mods and whether cosmetics are offered.
+    fn stamp(&self, s: &Settings) -> u64 {
+        shell::stamp_of(&(&s.extras, &s.mods, horizon_cosmetics::enabled()))
+    }
    fn sheets(&self, s: &Settings) -> Vec<Sheet<(), ExtraRow>> {
        let mut groups = vec![Group {
            name: MODS,
@@ -228,4 +232,37 @@ mod tests {
        assert!(s.extras.sort);
        assert_eq!(screen.wheel_step(&mut s, ExtraRow::Zoom(0), true), None);
    }
+
+    /// A page with no page list has Done under the search field: Down goes to the first row
+    /// instead, from the keys and, as the frame declares it, from a controller's focus.
+    #[test]
+    fn down_from_the_search_field_lands_on_the_first_row() {
+        use crate::{hud::HudBatch, settings_shell::Columns, ui};
+        use winit::keyboard::KeyCode as K;
+        let atlas = crate::hud::HudAtlas::build(std::path::Path::new("/nonexistent")).unwrap();
+        let mut s = Settings::default();
+        let mut shell = Shell::<ExtrasScreen>::default();
+        let mut batch = HudBatch::new([1708, 960]);
+        shell.draw(&s, &mut batch, &atlas, (0.0, 0.0), false, None);
+        crate::widgets::end_frame(1);
+        let size = (batch.width, batch.height);
+        let cols = Columns::of(size.0, size.1).with_note_lines(NOTE_LINES);
+        // The Mods group's note can't take the focus: the first item can.
+        let first = ExtraRow::Item(Item::OwnNameTag);
+        let at = shell.point_at(&s, size, first);
+        let [x, y, w, h] = crate::widgets::linked_step(cols.search(), true).unwrap();
+        assert!(ui::hovered(at, x, y, w, h));
+        assert_eq!(crate::widgets::linked_step(cols.search(), false), None);
+        let [x, y, w, h] = cols.search();
+        shell.click(
+            &mut s,
+            (x + w / 2.0, y + h / 2.0),
+            size,
+            false,
+            false,
+            false,
+        );
+        shell.key(&mut s, K::ArrowDown, None, false, size);
+        assert_eq!(shell.focused_row(), Some(first));
+    }
 }
@@ -9,6 +9,7 @@ use crate::{
    environment::Sky,
    world::World,
 };
+use horizon_core::random::{LegacyRandom, RandomSource};
 use std::path::Path;

 /// `FogType` of the camera position.
@@ -64,7 +65,7 @@ impl FogTables {
 }

 /// Fog state that evolves over time.
-#[derive(Clone, Copy, Debug, Default)]
+#[derive(Clone, Debug)]
 pub struct FogState {
    /// `LocalPlayer.waterVisionTime` (0..600).
    pub water_vision_time: i32,
@@ -72,24 +73,28 @@ pub struct FogState {
    pub rain_fog_multiplier: f32,
    /// `LightmapRenderStateExtractor.blockLightFlicker`.
    pub block_light_flicker: f32,
-    flicker_seed: u64,
+    /// `LightmapRenderStateExtractor.random`: `RandomSource.create()`.
+    flicker_random: LegacyRandom,
+}
+impl Default for FogState {
+    fn default() -> Self {
+        Self {
+            water_vision_time: 0,
+            rain_fog_multiplier: 0.0,
+            block_light_flicker: 0.0,
+            flicker_random: crate::random_source::create(),
+        }
+    }
 }
 impl FogState {
-    fn next_float(&mut self) -> f32 {
-        // splitmix64: the vanilla source is unseeded `RandomSource.create()`.
-        self.flicker_seed = self.flicker_seed.wrapping_add(0x9E37_79B9_7F4A_7C15);
-        let mut z = self.flicker_seed;
-        z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
-        z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
-        ((z ^ (z >> 31)) >> 40) as f32 / (1u32 << 24) as f32
-    }
    /// `LightmapRenderStateExtractor.tick`: the torch light flickers.
    pub fn tick_flicker(&mut self) {
+        let r = &mut self.flicker_random;
        let (a, b, c, d) = (
-            self.next_float(),
-            self.next_float(),
-            self.next_float(),
-            self.next_float(),
+            r.next_float(),
+            r.next_float(),
+            r.next_float(),
+            r.next_float(),
        );
        self.block_light_flicker += (a - b) * c * d * 0.1;
        self.block_light_flicker *= 0.9;
@@ -750,7 +755,7 @@ mod tests {
            rain_fog_multiplier: 0.1,
            ..FogState::default()
        };
-        let mut settled = start;
+        let mut settled = start.clone();
        settle_rain_fog(&mut settled, 0.5, 15, true);
        assert_eq!(settled.rain_fog_multiplier, 0.5);
        let mut eased = start;
@@ -126,11 +126,16 @@ struct Cache {
    random: horizon_core::random::LegacyRandom,
 }
 pub struct Font {
-    /// The atlas rects of the sheets under `textures/font`.
+    /// The atlas rects of every texture, by resource name: a bitmap provider's
+    /// `file` may name any texture, not only one under `textures/font`.
    sheets: HashMap<String, Rect>,
    missing: Glyph,
    white: Rect,
    root: PathBuf,
+    /// The game's own resources, below a pack overlay: a font file the overlay
+    /// lacks (a pack adds providers over vanilla's, or the overlay left a
+    /// directory out) is read from here, as vanilla's resource stack does.
+    fallback: Option<PathBuf>,
    /// Atlas size and the reserved dynamic region (y, height).
    atlas: (u32, u32),
    region: (u32, u32),
@@ -199,6 +204,13 @@ fn parse_hex(text: &[u8], out: &mut HashMap<u32, HexGlyph>) {
        out.insert(codepoint, HexGlyph { rows, left, right });
    }
 }
+/// A resource file's bytes, from `root` or, when the overlay lacks it, from
+/// the game's own resources below (`defaults`).
+fn read_resource(root: &Path, defaults: Option<&Path>, path: &str) -> Option<Vec<u8>> {
+    std::fs::read(root.join(path))
+        .ok()
+        .or_else(|| defaults.and_then(|d| std::fs::read(d.join(path)).ok()))
+}
 fn read_json(root: &Path, path: &str) -> Option<serde_json::Value> {
    serde_json::from_slice(&std::fs::read(root.join(path)).ok()?).ok()
 }
@@ -281,6 +293,7 @@ fn hex_advance(h: &HexGlyph) -> f32 {
 /// pixels, copied into the atlas when first drawn.
 fn load_bitmap(
    root: &Path,
+    defaults: Option<&Path>,
    p: &serde_json::Value,
    sheets: &HashMap<String, Rect>,
    pixels: &[u8],
@@ -290,22 +303,36 @@ fn load_bitmap(
    let mut out = HashMap::new();
    let file = p["file"].as_str().unwrap_or("");
    let (ns, name) = file.split_once(':').unwrap_or(("minecraft", file));
-    let in_atlas = (ns == "minecraft")
-        .then(|| sheets.get(name.trim_end_matches(".png")).copied())
-        .flatten();
+    let name = name.trim_end_matches(".png");
+    // The atlas names the default namespace's textures by their path and every
+    // other namespace's as `namespace:path` (HudAtlas::build).
+    let atlas_name = if ns == "minecraft" {
+        name.to_owned()
+    } else {
+        format!("{ns}:{name}")
+    };
+    let in_atlas = sheets.get(&atlas_name).copied();
    // The sheet: its size, and its pixels when they are not in the atlas.
    let (sw, sh, sheet) = match in_atlas {
        Some(rect) => {
            let (w, h) = rect.texels(atlas);
            (w, h, None)
        }
-        None => match crate::hud::decode(&root.join(resource_path(file, "textures", ""))) {
-            Ok((w, h, rgba)) => (w, h, Some(Arc::new((w, rgba)))),
-            Err(_) => {
-                log::warn!("font sheet {file} could not be read");
-                return out;
+        None => {
+            let path = resource_path(file, "textures", "");
+            let sheet = crate::hud::decode(&root.join(&path)).or_else(|first| {
+                defaults
+                    .and_then(|d| crate::hud::decode(&d.join(&path)).ok())
+                    .ok_or(first)
+            });
+            match sheet {
+                Ok((w, h, rgba)) => (w, h, Some(Arc::new((w, rgba)))),
+                Err(_) => {
+                    log::warn!("font sheet {file} could not be read");
+                    return out;
+                }
            }
-        },
+        }
    };
    let rows: Vec<Vec<char>> = p["chars"]
        .as_array()
@@ -382,11 +409,13 @@ fn load_bitmap(
 }
 /// `TrueTypeGlyphProviderDefinition.load`: a TrueType file (not CFF) under
 /// `font/`, its Unicode characters but the `skip` ones.
-fn load_true_type(root: &Path, p: &serde_json::Value) -> Option<TrueType> {
+fn load_true_type(root: &Path, defaults: Option<&Path>, p: &serde_json::Value) -> Option<TrueType> {
    let file = p["file"].as_str()?;
-    let data = std::fs::read(root.join(resource_path(file, "font", "")))
-        .map_err(|e| log::warn!("font file {file}: {e}"))
-        .ok()?;
+    let path = resource_path(file, "font", "");
+    let Some(data) = read_resource(root, defaults, &path) else {
+        log::warn!("font file {file} could not be read");
+        return None;
+    };
    // FT_Get_Font_Format must say TrueType: CFF outlines ("OTTO") are refused.
    if data.starts_with(b"OTTO") {
        log::warn!("font file {file} is not in TTF format");
@@ -486,13 +515,16 @@ impl TrueType {
        )
    }
 }
-fn load_hex(root: &Path, p: &serde_json::Value) -> HashMap<u32, HexGlyph> {
+fn load_hex(root: &Path, defaults: Option<&Path>, p: &serde_json::Value) -> HashMap<u32, HexGlyph> {
    let mut glyphs = HashMap::new();
    let Some(file) = p["hex_file"].as_str() else {
        return glyphs;
    };
-    let path = root.join(resource_path(file, "", "").replace("//", "/"));
-    let Ok(zip) = Zip::open(&path) else {
+    let path = resource_path(file, "", "").replace("//", "/");
+    let Some(zip) = Zip::open(&root.join(&path))
+        .ok()
+        .or_else(|| defaults.and_then(|d| Zip::open(&d.join(&path)).ok()))
+    else {
        return glyphs;
    };
    let names: Vec<String> = zip
@@ -603,7 +635,24 @@ impl Font {
        region: (u32, u32),
        white: Rect,
    ) -> Self {
-        Self::load_with(root, sprites, pixels, atlas, region, white, false)
+        Self::load_with(root, None, sprites, pixels, atlas, region, white, false)
+    }
+    /// [`Font::load`] over a pack overlay: a sheet, TrueType file or Unihex
+    /// file the overlay lacks is read from `defaults`, the game's own
+    /// resources, as vanilla's resource stack does. (Definitions stay the
+    /// overlay's: a pack's filter may hide one from a lower pack.)
+    #[allow(clippy::too_many_arguments)]
+    pub fn load_over(
+        root: &Path,
+        defaults: &Path,
+        sprites: &HashMap<String, Rect>,
+        pixels: &[u8],
+        atlas: (u32, u32),
+        region: (u32, u32),
+        white: Rect,
+    ) -> Self {
+        let fallback = (root != defaults).then_some(defaults);
+        Self::load_with(root, fallback, sprites, pixels, atlas, region, white, false)
    }
    /// A server measures text but never draws it. Decode bitmap sheets only
    /// to obtain advances, then release their pixels; never rasterize glyphs.
@@ -616,10 +665,21 @@ impl Font {
            w: 1,
            h: 1,
        };
-        Self::load_with(root, &HashMap::new(), &[], (1, 1), (0, 0), white, true)
+        Self::load_with(
+            root,
+            None,
+            &HashMap::new(),
+            &[],
+            (1, 1),
+            (0, 0),
+            white,
+            true,
+        )
    }
+    #[allow(clippy::too_many_arguments)]
    fn load_with(
        root: &Path,
+        fallback: Option<&Path>,
        sprites: &HashMap<String, Rect>,
        pixels: &[u8],
        atlas: (u32, u32),
@@ -627,11 +687,7 @@ impl Font {
        white: Rect,
        metrics_only: bool,
    ) -> Self {
-        let sheets = sprites
-            .iter()
-            .filter(|(k, _)| k.starts_with("font/"))
-            .map(|(k, v)| (k.clone(), *v))
-            .collect();
+        let sheets = sprites.clone();
        let font = Self {
            sheets,
            missing: Glyph {
@@ -645,6 +701,7 @@ impl Font {
            },
            white,
            root: root.to_owned(),
+            fallback: fallback.map(|p| p.to_owned()),
            atlas,
            region,
            metrics_only,
@@ -656,11 +713,8 @@ impl Font {
                    pending: Vec::new(),
                    full: false,
                },
-                random: horizon_core::random::LegacyRandom::new(
-                    std::time::SystemTime::now()
-                        .duration_since(std::time::UNIX_EPOCH)
-                        .map_or(0, |d| d.as_nanos() as i64),
-                ),
+                // `Font.random`: `RandomSource.create()`.
+                random: crate::random_source::create(),
            }),
            generation: std::cell::Cell::new(next_generation()),
            uniform: false,
@@ -698,6 +752,7 @@ impl Font {
                    Filter::of(p),
                    load_bitmap(
                        &self.root,
+                        self.fallback.as_deref(),
                        p,
                        &self.sheets,
                        pixels,
@@ -708,7 +763,7 @@ impl Font {
                "unihex" => Some(Provider::Unihex(Filter::of(p), p.clone(), None)),
                "ttf" => Some(Provider::TrueType(
                    Filter::of(p),
-                    Box::new(load_true_type(&self.root, p)?),
+                    Box::new(load_true_type(&self.root, self.fallback.as_deref(), p)?),
                )),
                _ => None,
            })
@@ -868,7 +923,8 @@ impl Font {
                    }
                }
                Provider::Unihex(filter, def, glyphs) if filter.passes(uniform, japanese) => {
-                    let glyphs = glyphs.get_or_insert_with(|| load_hex(&self.root, def));
+                    let glyphs = glyphs
+                        .get_or_insert_with(|| load_hex(&self.root, self.fallback.as_deref(), def));
                    if let Some(h) = glyphs.get(&u32::from(c)).copied()
                        && !(non_fishy && fishy_advance(hex_advance(&h)))
                    {
@@ -1026,7 +1082,8 @@ impl Font {
                    }
                }
                Provider::Unihex(filter, def, glyphs) if filter.passes(uniform, japanese) => {
-                    let glyphs = glyphs.get_or_insert_with(|| load_hex(&self.root, def));
+                    let glyphs = glyphs
+                        .get_or_insert_with(|| load_hex(&self.root, self.fallback.as_deref(), def));
                    if let Some(h) = glyphs.get(&u32::from(c)) {
                        return Some(hex_advance(h));
                    }
@@ -1512,6 +1569,52 @@ mod tests {
        assert!(texels.iter().any(|t| t[0] == 255));
    }

+    /// A bitmap provider's `file` can name any texture. When the atlas has that
+    /// texture (HUD packs keep their glyph sheets outside `textures/font`), the
+    /// glyphs are read from it instead of being copied into the small run-time
+    /// region one by one; the region then cannot fill up and turn later glyphs
+    /// into the missing one, whose advance shifts the rest of a HUD line.
+    #[test]
+    fn a_bitmap_sheet_outside_font_is_read_from_the_atlas() {
+        let sheet = png(16, 8, |x, _| x < 2 || (8..14).contains(&x));
+        let (_, _, pixels) = crate::hud::decode_bytes(&sheet).unwrap();
+        let rect = Rect {
+            u0: 0.0,
+            v0: 0.0,
+            u1: 1.0,
+            v1: 1.0,
+            w: 16,
+            h: 8,
+        };
+        for (ns, file, key) in [
+            ("minecraft", "minecraft:hud/sheet.png", "hud/sheet"),
+            (
+                "hudengine",
+                "hudengine:font/sheet.png",
+                "hudengine:font/sheet",
+            ),
+        ] {
+            let def = format!(
+                r#"{{"providers":[{{"type":"bitmap","file":"{file}","ascent":7,"chars":["ab"]}}]}}"#
+            );
+            // The image is only in the atlas: the pack's copy is not on disk.
+            let root = root(
+                ns,
+                &[("assets/minecraft/font/default.json", def.as_bytes())],
+            );
+            let sprites = HashMap::from([(key.to_string(), rect)]);
+            let font = Font::load(&root, &sprites, &pixels, (16, 8), (0, 8), white());
+            let _ = std::fs::remove_dir_all(&root);
+            assert_eq!(font.glyph('a').advance, 3.0, "{ns}");
+            assert_eq!(font.glyph('b').advance, 7.0, "{ns}");
+            assert!(font.glyph('a').rect.is_some(), "{ns}");
+            assert!(
+                font.take_patches().is_empty(),
+                "{ns}: the atlas sheet is not copied into the run-time region"
+            );
+        }
+    }
+
    #[test]
    fn styles_pick_their_font_and_unknown_fonts_draw_missing_glyphs() {
        let sheet = png(16, 8, |x, _| x < 2 || (8..14).contains(&x));
@@ -162,6 +162,7 @@ mod arena;
 pub mod capture;
 pub mod compositor;
 pub(crate) mod core_lines;
+pub(crate) mod core_sky;
 mod cull;
 mod end_sky;
 pub mod entity_skin;
@@ -171,7 +172,10 @@ mod gpu_culling;
 mod hdr;
 mod hdr_icc;
 mod hdr_stats;
+pub(crate) mod hud_coverage;
 pub use hdr::Calibration as HdrCalibration;
+mod hold;
+pub use hold::WorldHold;
 pub mod block_light;
 mod custom_sky;
 mod displace;
@@ -444,6 +448,52 @@ struct GpuStaticEntitySection {
    vertices: u32,
 }
 pub type SectionKey = (i32, i32, i32);
+/// What a section's mesh brings with it besides its quads (`Renderer::upload`): placed with
+/// the mesh, now or when a hold lets go of it.
+struct MeshFacts<'a> {
+    visibility: u64,
+    block_entities: &'a [([i32; 3], u32)],
+    lights: &'a [([i32; 3], u32)],
+    bounds: Option<[glam::Vec3; 2]>,
+    /// It has translucent quads.
+    translucent: bool,
+    /// It has no quads at all: that is its mesh.
+    empty: bool,
+}
+impl<'a> MeshFacts<'a> {
+    fn of(mesh: &'a SectionMesh) -> Self {
+        Self {
+            visibility: mesh.visibility,
+            block_entities: &mesh.block_entities,
+            lights: &mesh.lights,
+            bounds: mesh.bounds,
+            translucent: !mesh.translucent.is_empty(),
+            empty: mesh.solid.is_empty() && mesh.translucent.is_empty(),
+        }
+    }
+}
+/// A section's new mesh waiting behind a hold (gfx/hold.rs): uploaded, with what goes with it.
+struct HeldMesh {
+    gpu: Option<SectionGpu>,
+    visibility: u64,
+    block_entities: Vec<([i32; 3], u32)>,
+    lights: Vec<([i32; 3], u32)>,
+    bounds: Option<[glam::Vec3; 2]>,
+    translucent: bool,
+    empty: bool,
+}
+impl HeldMesh {
+    fn facts(&self) -> MeshFacts<'_> {
+        MeshFacts {
+            visibility: self.visibility,
+            block_entities: &self.block_entities,
+            lights: &self.lights,
+            bounds: self.bounds,
+            translucent: self.translucent,
+            empty: self.empty,
+        }
+    }
+}
 /// The water mirror's targets: the world as a camera mirrored about the water plane sees
 /// it, at half the world's resolution (the material stage's `reflection`).
 struct MirrorTarget {
@@ -1165,12 +1215,15 @@ pub struct Renderer {
    lines_secondary: wgpu::RenderPipeline,
    /// A resource pack's `core/rendertype_lines`, which draws the block outline in their place.
    core_lines: Option<core_lines::CoreLines>,
+    /// The packs' `core/sky` and `core/stars`, drawn in place of the native sky and stars.
+    core_sky: Option<core_sky::CoreSky>,
    /// Gizmo lines: opaque ones (`RenderTypes.lines`, which writes depth),
    /// translucent ones (`RenderTypes.linesTranslucentNoDepthWrite`) and the
    /// always-on-top ones.
    debug_lines_opaque: wgpu::RenderPipeline,
    debug_lines: wgpu::RenderPipeline,
    debug_lines_on_top: wgpu::RenderPipeline,
+    debug_crosshair: Option<wgpu::RenderPipeline>,
    debug_line_buffer: wgpu::Buffer,
    debug_line_capacity: u64,
    /// The terrain resources with the debug crosshair's projection
@@ -1191,6 +1244,8 @@ pub struct Renderer {
    static_entity_catalog_revision: u64,
    static_entity_frame_stats: StaticCacheFrameStats,
    hdr_mark_pipeline: wgpu::RenderPipeline,
+    /// `hdr_mark_pipeline` at `entity_pipeline`'s depth bias, for what that drew.
+    hdr_entity_mark_pipeline: wgpu::RenderPipeline,
    hdr_hand_unmark_pipeline: wgpu::RenderPipeline,
    hdr_mark_lightning_pipeline: wgpu::RenderPipeline,
    weather: weather::Weather,
@@ -1328,6 +1383,9 @@ pub struct Renderer {
    lod_retiring: crate::fast_hash::FxHashSet<SectionKey>,
    /// Removed sections fading out over far terrain (`leave_section`).
    lod_leaving: Vec<(SectionKey, std::time::Instant)>,
+    /// A mod's hold on the terrain's picture (`hold_world`, gfx/hold.rs) and the new meshes
+    /// waiting behind it.
+    hold: hold::Hold<HeldMesh>,
    /// Finished tile meshes `upload_lods` has yet to upload.
    lod_pending: Option<lod::Pending>,
    detail_columns: FxHashMap<(i32, i32), SectionMask>,
@@ -1424,6 +1482,8 @@ pub struct Renderer {
    /// device draws and blends into it, or `LINEAR_FRAME` (`frame_format`). A 16-bit frame
    /// with HDR off since reaches the swapchain through `readback`.
    frame_format: wgpu::TextureFormat,
+    /// The no-pack float HDR lane, with independent blending and an R8 coverage target.
+    hud_coverage: bool,
    /// Whether a pack picked or dropped since the renderer was made has been told it runs on
    /// the frame that exists (`set_native_shader_pack`).
    frame_kept_logged: bool,
@@ -1453,6 +1513,9 @@ pub struct Renderer {
    /// The block sprites as one atlas, while a shader pack is loaded.
    pack_atlas: Option<pack_atlas::PackAtlas>,
    pack_material_atlases: Option<[pack_atlas::PackAtlas; 2]>,
+    /// The shared atlas's LabPBR normal and specular paged maps (`set_shared_material_maps`),
+    /// which shader packs read for entities, items and the hand.
+    shared_material_maps: [Option<wgpu::Texture>; 2],
    /// The pack's terrain program reads flat draws' vertices (`pack_terrain_inputs`).
    pack_terrain_flat: bool,
    /// OptiFine/Iris separate ambient occlusion: pass vertex alpha to hz_Color.a.
@@ -2450,6 +2513,14 @@ impl Renderer {
                "near_section_vertices",
                self.sections.values().map(used).sum(),
            ),
+            (
+                "held_section_vertices",
+                self.hold
+                    .sections()
+                    .filter_map(|held| held.gpu.as_ref())
+                    .map(used)
+                    .sum(),
+            ),
            (
                "far_tile_vertices",
                self.lods.values().map(|tile| used(&tile.mesh)).sum(),
@@ -2693,6 +2764,13 @@ impl Renderer {
            config.format,
            linear,
        );
+        let hud_coverage = hud_coverage::supported(
+            linear,
+            hdr_output.is_some(),
+            device.limits().max_color_attachments,
+            adapter.get_downlevel_capabilities().flags,
+            adapter.get_texture_format_features(hud_coverage::FORMAT),
+        );
        if previous.is_none() {
            startup_step(format_args!("creating the pipelines"));
        }
@@ -2843,8 +2921,9 @@ impl Renderer {
                             cull: Option<wgpu::Face>,
                             depth_write: bool,
                             depth_test: bool,
-                             blend: Option<wgpu::BlendState>| {
-            kept.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                             blend: Option<wgpu::BlendState>,
+                             coverage: bool| {
+            let desc = wgpu::RenderPipelineDescriptor {
                label: Some(label),
                layout: Some(layout),
                vertex: wgpu::VertexState {
@@ -2885,7 +2964,17 @@ impl Renderer {
                }),
                multiview_mask: None,
                cache: None,
-            })
+            };
+            if coverage {
+                hud_coverage::pipeline(
+                    &device,
+                    &desc,
+                    wgpu::ShaderSource::Wgsl(include_str!("terrain.wgsl").into()),
+                )
+                .expect("the debug crosshair's coverage")
+            } else {
+                kept.create_render_pipeline(&desc)
+            }
        };
        let pipeline_in = |layout: &wgpu::PipelineLayout,
                           label: &str,
@@ -2909,6 +2998,7 @@ impl Renderer {
                depth_write,
                depth_test,
                blend,
+                false,
            )
        };
        // A solid terrain pipeline (back faces culled, depth written, no blend) without HDR
@@ -2931,6 +3021,7 @@ impl Renderer {
                    true,
                    true,
                    None,
+                    false,
                )
            };
            SolidPipeline {
@@ -3175,6 +3266,22 @@ impl Renderer {
            false,
            Some(alpha_blend),
        );
+        let debug_crosshair = hud_coverage.then(|| {
+            pipeline_with(
+                &sprite_constants,
+                &layout,
+                "3d crosshair coverage",
+                "vs_debug_line",
+                "fs_debug_line",
+                &debug_line_buffers,
+                wgpu::PrimitiveTopology::TriangleStrip,
+                None,
+                false,
+                false,
+                Some(alpha_blend),
+                true,
+            )
+        });
        drop(terrain_step);
        let globals = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Horizon globals"),
@@ -3528,6 +3635,7 @@ impl Renderer {
            &atlas_view,
            &glint_view,
            &glint_sampler,
+            hud_coverage,
        )?;
        hud.atlas_texture = Some(atlas.clone());
        let entity_step = crate::spans::startup::step("renderer.entity_pipelines");
@@ -3966,17 +4074,19 @@ impl Renderer {
        // paths here, so their fp32 depths of the same plane differ by a few dozen
        // ulps and the tie came out either way, as a jagged strip of the trapdoor
        // through the hull's floor. The same constant as the shadows' covers that
-        // spread; a model's feet sit 0.001 above the ground, far beyond it.
+        // spread; a model's feet sit 0.001 above the ground, far beyond it. HDR output's
+        // marks on what it draws take it too (`hdr_entity_mark_pipeline`).
+        let entity_bias = wgpu::DepthBiasState {
+            constant: 128,
+            slope_scale: 0.0,
+            clamp: 0.0,
+        };
        let entity_pipeline = entity_pipeline(
            "Entities",
            None,
            true,
            wgpu::CompareFunction::GreaterEqual,
-            wgpu::DepthBiasState {
-                constant: 128,
-                slope_scale: 0.0,
-                clamp: 0.0,
-            },
+            entity_bias,
            alpha_blend,
            false,
        );
@@ -4048,12 +4158,26 @@ impl Renderer {
            "fs_hdr_mark",
            wgpu::ColorWrites::ALPHA,
        );
+        // The same at `entity_pipeline`'s depth bias, for what it drew (entities, the hand,
+        // translucent particles): without it the marks test a hair behind the depth it left
+        // and never land.
+        let hdr_entity_mark_pipeline = entity_pipeline_with(
+            "HDR entity mark",
+            None,
+            false,
+            wgpu::CompareFunction::GreaterEqual,
+            entity_bias,
+            wgpu::BlendState::REPLACE,
+            false,
+            "fs_hdr_mark",
+            wgpu::ColorWrites::ALPHA,
+        );
        let hdr_hand_unmark_pipeline = entity_pipeline_with(
            "HDR hand unmark",
            None,
            false,
            wgpu::CompareFunction::GreaterEqual,
-            Default::default(),
+            entity_bias,
            wgpu::BlendState::REPLACE,
            false,
            "fs_hdr_hand_unmark",
@@ -4487,6 +4611,10 @@ impl Renderer {
        });
        let static_entity_index_quads = 1 << 14;
        let static_entity_indices = Self::quad_indices(&device, static_entity_index_quads);
+        let indirect_execution = adapter
+            .get_downlevel_capabilities()
+            .flags
+            .contains(wgpu::DownlevelFlags::INDIRECT_EXECUTION);
        let flat_wanted = flat::wanted(&adapter, &device);
        // Metal draws solid terrain in two passes (`split_solid`): meshes put all
        // their opaque quads first, so each pass draws its part in a run or two.
@@ -4506,7 +4634,11 @@ impl Renderer {
                attributes: &TERRAIN_ATTRIBUTES,
            })];
            let info = adapter.get_info();
+            // Metal's per-section path drops cutout leaves (the canopy above trunks vanishes),
+            // and cave culling can drop the listed count below MIN_SECTIONS on a normal view:
+            // so Metal draws vanilla terrain flat at any count.
            let min_sections = if flat::is_broken_intel_vulkan(&info)
+                || info.backend == wgpu::Backend::Metal
                || std::env::var("HORIZON_FLAT_DRAWS").as_deref() == Ok("1")
            {
                0
@@ -4521,6 +4653,7 @@ impl Renderer {
                &bindings,
                arena.page_vertices(),
                min_sections,
+                indirect_execution,
                |layout, label, vertex, fragment, blend, cull, pulled| {
                    let buffers: &[Option<wgpu::VertexBufferLayout<'_>>] =
                        if pulled { &[] } else { &buffers };
@@ -4581,10 +4714,7 @@ impl Renderer {
        let multi_draw = device
            .features()
            .contains(wgpu::Features::INDIRECT_FIRST_INSTANCE)
-            && adapter
-                .get_downlevel_capabilities()
-                .flags
-                .contains(wgpu::DownlevelFlags::INDIRECT_EXECUTION);
+            && indirect_execution;
        let batchable = translucent_batchable(&adapter.get_info(), multi_draw);
        crate::graphics::offer_translucent_batching(batchable);
        let translucent_batching = batchable && translucent_batching;
@@ -4743,9 +4873,11 @@ impl Renderer {
            lines,
            lines_secondary,
            core_lines: None,
+            core_sky: None,
            debug_lines_opaque,
            debug_lines,
            debug_lines_on_top,
+            debug_crosshair,
            debug_line_buffer,
            debug_line_capacity: 4096,
            crosshair_group,
@@ -4757,6 +4889,7 @@ impl Renderer {
            entity_pipeline,
            static_entity_pipeline,
            hdr_mark_pipeline,
+            hdr_entity_mark_pipeline,
            hdr_hand_unmark_pipeline,
            hdr_mark_lightning_pipeline,
            weather,
@@ -4860,6 +4993,7 @@ impl Renderer {
            lod_cutout: Default::default(),
            lod_retiring: Default::default(),
            lod_leaving: Vec::new(),
+            hold: Default::default(),
            lod_pending: None,
            detail_columns: Default::default(),
            detail_revision: 0,
@@ -4905,6 +5039,7 @@ impl Renderer {
            emission_stats,
            hdr_output,
            frame_format,
+            hud_coverage,
            frame_kept_logged: false,
            hdr_marker: None,
            pack_post: None,
@@ -4918,6 +5053,7 @@ impl Renderer {
            pack_weather: None,
            pack_atlas: None,
            pack_material_atlases: None,
+            shared_material_maps: [None, None],
            pack_terrain_flat: false,
            separate_ao: false,
            pack_lava_layers: Vec::new(),
@@ -4963,7 +5099,7 @@ impl Renderer {
        pass.draw_indexed(0..quads * 6, (first * 4) as i32, 0..1);
        if self.hdr.is_some() {
            // Drawn into the world: the light sources it holds are marked as the world's are.
-            pass.set_pipeline(&self.hdr_mark_pipeline);
+            pass.set_pipeline(&self.hdr_entity_mark_pipeline);
            pass.draw_indexed(0..quads * 6, (first * 4) as i32, 0..1);
        }
    }
@@ -5009,6 +5145,47 @@ impl Renderer {
        }
        pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
    }
+    /// The shared atlas's LabPBR maps (`HudAtlas::material_maps`), uploaded for the shader packs
+    /// loaded from now on; a map too large for this GPU is left out.
+    pub fn set_shared_material_maps(&mut self, maps: &[Option<crate::paged_maps::PagedMap>; 2]) {
+        let limit = self.device.limits().max_texture_dimension_2d;
+        let sizes: Vec<String> = (maps.iter().zip(["normals", "specular"]))
+            .filter_map(|(m, name)| {
+                m.as_ref()
+                    .map(|m| format!("{name} {}x{}", m.width, m.height))
+            })
+            .collect();
+        if !sizes.is_empty() {
+            let bytes: usize = maps.iter().flatten().map(|m| m.pixels.len()).sum();
+            log::info!(
+                "shared atlas LabPBR maps: {} ({:.1} MiB)",
+                sizes.join(", "),
+                bytes as f64 / f64::from(1 << 20)
+            );
+        }
+        self.shared_material_maps = maps.each_ref().map(|map| {
+            let map = map.as_ref().filter(|m| m.width.max(m.height) <= limit)?;
+            Some(self.device.create_texture_with_data(
+                &self.queue,
+                &wgpu::TextureDescriptor {
+                    label: Some("Shared atlas material map"),
+                    size: wgpu::Extent3d {
+                        width: map.width,
+                        height: map.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,
+                &map.pixels,
+            ))
+        });
+    }
    /// The pack's OptiFine custom sky layer textures (`crate::custom_sky::CustomSky::load`).
    pub fn set_custom_sky(&mut self, pack: &crate::custom_sky::CustomSky) {
        self.custom_sky.set_pack(&self.device, &self.queue, pack);
@@ -5025,6 +5202,15 @@ impl Renderer {
        self.core_lines =
            program.and_then(|program| core_lines::CoreLines::new(&self.device, format, program));
    }
+    /// The resource packs' `core/sky` and `core/stars` (`HudAtlas::sky_shader`,
+    /// `stars_shader`), or the built-in sky and stars.
+    pub fn set_sky_shaders(
+        &mut self,
+        disc: Option<&horizon_shaders::CoreProgram>,
+        stars: Option<&horizon_shaders::CoreProgram>,
+    ) {
+        self.core_sky = core_sky::CoreSky::new(&self.device, self.frame_format, disc, stars);
+    }
    /// 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) {
@@ -5454,12 +5640,28 @@ impl Renderer {
        if let Some(copies) = &mut self.capture_copies {
            copies.section(key, mesh);
        }
+        if self.hold.holds(key) && self.shown(key) && self.upload_held(key, mesh) {
+            return;
+        }
+        if let Some(gpu) = self.hold.take(key).and_then(|held| held.gpu) {
+            self.release_mesh(gpu);
+        }
+        let facts = MeshFacts::of(mesh);
+        let fading = self.before_mesh(key, &facts);
+        let section = self.upload_mesh(mesh);
+        self.after_mesh(key, &facts, section, fading);
+    }
+    /// What goes with section `key`'s new mesh, before its quads go in: its old mesh is
+    /// released. The fade it keeps.
+    fn before_mesh(&mut self, key: SectionKey, mesh: &MeshFacts) -> Option<Instant> {
        self.occlusion.set(key, mesh.visibility);
        let changed = if mesh.block_entities.is_empty() {
            self.block_entities.remove(&key).is_some()
        } else {
-            let old = self.block_entities.insert(key, mesh.block_entities.clone());
-            old.as_deref() != Some(&mesh.block_entities[..])
+            let old = self
+                .block_entities
+                .insert(key, mesh.block_entities.to_vec());
+            old.as_deref() != Some(mesh.block_entities)
        };
        if changed {
            self.block_entity_revision = next_block_entity_revision();
@@ -5478,8 +5680,8 @@ impl Renderer {
        let lights_changed = if mesh.lights.is_empty() {
            self.light_blocks.remove(&key).is_some()
        } else {
-            let old = self.light_blocks.insert(key, mesh.lights.clone());
-            old.as_deref() != Some(&mesh.lights[..])
+            let old = self.light_blocks.insert(key, mesh.lights.to_vec());
+            old.as_deref() != Some(mesh.lights)
        };
        if lights_changed {
            self.light_revision += 1;
@@ -5487,7 +5689,7 @@ impl Renderer {
        if !self.lod_retiring.is_empty() {
            self.lod_retiring.remove(&key);
        }
-        if !mesh.translucent.is_empty() && !self.sections.contains(key) {
+        if mesh.translucent && !self.sections.contains(key) {
            // New translucent terrain, not an edit's remesh: large pages wait for it.
            self.shrink_gate.wait(Instant::now(), SHRINK_SETTLE);
        }
@@ -5506,13 +5708,19 @@ impl Renderer {
            self.newest_upload = Some(now);
        }
        self.release_section(key);
-        let section = self
-            .upload_mesh(mesh)
-            .map(|section| SectionGpu { fading, ..section });
-        self.set_detail(
-            key,
-            section.is_some() || (mesh.solid.is_empty() && mesh.translucent.is_empty()),
-        );
+        fading
+    }
+    /// Section `key`'s new mesh drawn from now on, its quads uploaded (`section`: none when it
+    /// has none, or the arena had no room).
+    fn after_mesh(
+        &mut self,
+        key: SectionKey,
+        mesh: &MeshFacts,
+        section: Option<SectionGpu>,
+        fading: Option<Instant>,
+    ) {
+        let section = section.map(|section| SectionGpu { fading, ..section });
+        self.set_detail(key, section.is_some() || mesh.empty);
        if let Some(mut section) = section {
            let sections = self.layout.sections();
            if let Some(gpu) = &mut self.gpu_culling
@@ -5536,6 +5744,94 @@ impl Renderer {
                .insert_marked(key, section, mesh.bounds, marked);
        }
    }
+    /// Whether section `key` has its mesh on screen (`set_detail`): an empty one counts.
+    fn shown(&self, key: SectionKey) -> bool {
+        self.detail_columns
+            .get(&(key.0, key.2))
+            .is_some_and(|mask| mask.contains(key.1 as usize))
+    }
+    /// The bytes a section's quads take in the arenas.
+    fn mesh_bytes(gpu: Option<&SectionGpu>) -> u64 {
+        let stride = std::mem::size_of::<TerrainVertex>() as u64;
+        gpu.map_or(0, |s| {
+            (s.solid_slots + u64::from(s.translucent) * 4) * stride
+        })
+    }
+    /// A mod's hold on the terrain's picture (gfx/hold.rs, `WorldHold`), asked once a frame
+    /// before the frame's uploads: while held, a section on screen that is meshed again waits,
+    /// uploaded, behind the mesh drawn. What no longer waits takes its place on this frame.
+    pub fn hold_world(&mut self, ask: &WorldHold) {
+        let waiting = match self.hold.ask(ask, Instant::now()) {
+            hold::Release::None => return,
+            hold::Release::All => self.hold.take_all(),
+            hold::Release::Outside => self.hold.take_outside(),
+        };
+        self.place_held(waiting);
+    }
+    /// Whether a mod's hold covers chunk column `column` (`hold_world`): what changes there waits.
+    pub fn world_holds_column(&self, column: (i32, i32)) -> bool {
+        self.hold.holds((column.0, 0, column.1))
+    }
+    /// Section `key`'s new mesh waits behind the hold, uploaded. False when the arena has no
+    /// room for it: what waited takes its place (giving the old meshes back), the hold is
+    /// spent, and this one goes in as ever.
+    fn upload_held(&mut self, key: SectionKey, mesh: &SectionMesh) -> bool {
+        let facts = MeshFacts::of(mesh);
+        let gpu = self.upload_mesh(mesh);
+        if gpu.is_none() && !facts.empty {
+            log::warn!("Horizon: no memory left for a held world's new sections: let go");
+            self.hold.spend();
+            let waiting = self.hold.take_all();
+            self.place_held(waiting);
+            return false;
+        }
+        let bytes = Self::mesh_bytes(gpu.as_ref());
+        let held = HeldMesh {
+            gpu,
+            visibility: facts.visibility,
+            block_entities: facts.block_entities.to_vec(),
+            lights: facts.lights.to_vec(),
+            bounds: facts.bounds,
+            translucent: facts.translucent,
+            empty: facts.empty,
+        };
+        let (old, over) = self.hold.wait(key, held, bytes);
+        if let Some(gpu) = old.and_then(|old| old.gpu) {
+            self.release_mesh(gpu);
+        }
+        if over {
+            log::warn!(
+                "Horizon: a held world's new sections came to {} MiB: let go",
+                self.hold.bytes() >> 20
+            );
+            self.hold.spend();
+            let waiting = self.hold.take_all();
+            self.place_held(waiting);
+        }
+        true
+    }
+    /// Sections that waited behind the hold take their place, on this frame.
+    fn place_held(&mut self, waiting: Vec<(SectionKey, HeldMesh)>) {
+        if waiting.is_empty() {
+            return;
+        }
+        let (count, started) = (waiting.len(), Instant::now());
+        let bytes: u64 = waiting
+            .iter()
+            .map(|(_, held)| Self::mesh_bytes(held.gpu.as_ref()))
+            .sum();
+        for (key, mut held) in waiting {
+            let gpu = held.gpu.take();
+            let facts = held.facts();
+            let fading = self.before_mesh(key, &facts);
+            self.after_mesh(key, &facts, gpu, fading);
+        }
+        log::debug!(
+            "Horizon: {count} held sections ({} MiB) took their place in {:.1} ms",
+            bytes >> 20,
+            started.elapsed().as_secs_f64() * 1e3
+        );
+    }
    fn upload_mesh(&mut self, mesh: &SectionMesh) -> Option<SectionGpu> {
        let solid = (mesh.solid.len() / 4) as u32;
        let translucent = (mesh.translucent.len() / 4) as u32;
@@ -5828,7 +6124,13 @@ impl Renderer {
        let meshes = self
            .sections
            .values_mut()
-            .chain(self.lods.values_mut().flat_map(|tile| tile.meshes_mut()));
+            .chain(self.lods.values_mut().flat_map(|tile| tile.meshes_mut()))
+            // (meshes waiting behind a hold move with the rest, or they would keep the page)
+            .chain(
+                self.hold
+                    .sections_mut()
+                    .filter_map(|held| held.gpu.as_mut()),
+            );
        let flat = self
            .flat
            .as_mut()
@@ -5871,7 +6173,12 @@ impl Renderer {
                let meshes = self
                    .sections
                    .values_mut()
-                    .chain(self.lods.values_mut().flat_map(|tile| tile.meshes_mut()));
+                    .chain(self.lods.values_mut().flat_map(|tile| tile.meshes_mut()))
+                    .chain(
+                        self.hold
+                            .sections_mut()
+                            .filter_map(|held| held.gpu.as_mut()),
+                    );
                match begin_shrink(arena, &self.device, meshes, *part) {
                    Some(true) => break,
                    Some(false) => wait = SHRINK_RETRY, // the other arena may still go
@@ -5895,7 +6202,13 @@ impl Renderer {
        let meshes = self
            .sections
            .values_mut()
-            .chain(self.lods.values_mut().flat_map(|tile| tile.meshes_mut()));
+            .chain(self.lods.values_mut().flat_map(|tile| tile.meshes_mut()))
+            // (meshes waiting behind a hold move with the rest, or they would keep the page)
+            .chain(
+                self.hold
+                    .sections_mut()
+                    .filter_map(|held| held.gpu.as_mut()),
+            );
        // As many quads a frame either way: a quad's indices are a quarter of its bytes.
        let cap = match part {
            Part::Indices => COMPACT_BUDGET / 4,
@@ -6068,6 +6381,8 @@ impl Renderer {
        self.newest_lod_fade = None;
        self.block_entity_revision = next_block_entity_revision();
        self.sections.clear();
+        // (a hold on land that is gone ends; the arenas' clearing below takes what waited)
+        self.hold.clear();
        self.lods.clear();
        self.lod_cutout.clear();
        self.lod_retiring.clear();
@@ -6138,6 +6453,13 @@ impl Renderer {
        if want == self.packed_quads {
            return;
        }
+        let held_packed = |held: &HeldMesh| held.gpu.as_ref().is_some_and(|s| s.packed);
+        if !want && self.hold.sections().any(held_packed) {
+            // (held meshes in the layout going away take their place, and go with the rest)
+            self.hold.spend();
+            let waiting = self.hold.take_all();
+            self.place_held(waiting);
+        }
        self.packed_quads = want;
        packed::pack_quads(want);
        if !want && self.sections.values().any(|s| s.packed) {
@@ -6245,6 +6567,11 @@ impl Renderer {
        if let Some(copies) = &mut self.capture_copies {
            copies.remove_columns(&columns);
        }
+        if !self.hold.is_empty() && !columns.is_empty() {
+            let gone = columns.iter().copied().collect();
+            let held = self.hold.take_columns(&gone);
+            self.release_meshes(held.into_iter().filter_map(|held| held.gpu).collect());
+        }
        // Most of the view at once (a teleport at render distance 32 drops some 3700
        // columns): a pass over each store instead of a lookup per section key, which
        // took 10 ms of one frame. Far terrain fades the sections out instead.
@@ -6497,8 +6824,9 @@ impl Renderer {
                DisplayWatch::default()
            };
            let format = self.frame_format;
-            self.hdr =
-                output.map(|output| hdr::Hdr::new(&self.device, &self.queue, format, output));
+            self.hdr = output.map(|output| {
+                hdr::Hdr::new(&self.device, &self.queue, format, output, self.hud_coverage)
+            });
            if let Some(hdr) = &mut self.hdr {
                hdr.look = self.hdr_lighting_setting;
            }
@@ -6590,7 +6918,16 @@ impl Renderer {
        self.frame_gen.on = on;
    }
    /// `upscale`: output pixels per rendered pixel, for TAA to rebuild (1: native).
-    pub fn set_world_post(&mut self, scale: f32, antialias: bool, taa: bool, upscale: f32) {
+    /// `sharpness`: how much TAA's upscaled picture is sharpened, 0..=1.
+    pub fn set_world_post(
+        &mut self,
+        scale: f32,
+        antialias: bool,
+        taa: bool,
+        upscale: f32,
+        sharpness: f32,
+    ) {
+        self.world_post.set_sharpness(&self.device, sharpness);
        let taa = taa && self.world_post.supports_taa();
        self.world_post.scale = scale.clamp(0.25, 2.0);
        self.world_post.antialias = antialias && !taa;
@@ -6682,7 +7019,7 @@ impl Renderer {
        dimension: i32,
        post: std::result::Result<Option<pack_post::PackPost>, pack_post::Refused>,
    ) -> std::result::Result<Option<(Vec<String>, Vec<String>)>, pack_post::Refused> {
-        let post = match post {
+        let mut post = match post {
            Ok(post) => post,
            Err(e) => {
                self.pack_post = Some((dimension, None));
@@ -6691,6 +7028,12 @@ impl Renderer {
                return Err(e);
            }
        };
+        if let Some(post) = post.as_mut() {
+            post.set_paged_maps(
+                (self.shared_material_maps.each_ref())
+                    .map(|t| t.as_ref().map(|t| t.create_view(&Default::default()))),
+            );
+        }
        let report = post.as_ref().map(|p| {
            let programs = p.programs().into_iter().map(str::to_owned).collect();
            (programs, p.notes.clone())
@@ -8799,6 +9142,39 @@ impl Renderer {
                self.uploads.buffer(&mut encoder, core.uniform(), 0, &data);
            }
        }
+        // A pack's core/sky and core/stars: the disc with the sky colour, the stars with their
+        // brightness, both turned with the camera only (SkyRenderer's model view).
+        if let Some(core) = &self.core_sky
+            && !frame.title
+        {
+            let size = [self.config.width, self.config.height];
+            let block = crate::post_chain::Globals {
+                glint_alpha: frame.glint_alpha,
+                ..frame.post_effects.globals
+            }
+            .bytes(size, frame.post_effects.menu_blur_radius as i32);
+            let [sky_end, clouds_end, ..] = globals.fog_ends;
+            let fog = [fog[0], fog[1], fog[2], fog[3], sky_end, clouds_end];
+            let view = views.primary();
+            // Far enough for the disc's rim, 512 out: the sky draws without a depth test.
+            let fov = (2.0 * view.tan_half_fov.atan()).to_degrees();
+            let projection = jitter * world_projection(fov, view.aspect, 2048.0) * pose;
+            let [r, g, b, ..] = frame.sky.sky_color;
+            let sky =
+                core_sky::uniforms(block, projection, view.view, [r, g, b, 1.0], fog_color, fog);
+            let stars = frame.stars.map(|(rotation, brightness)| {
+                let b = brightness.clamp(0.0, 1.0);
+                core_sky::uniforms(
+                    block,
+                    projection,
+                    view.view * rotation,
+                    [b; 4],
+                    fog_color,
+                    fog,
+                )
+            });
+            core.prepare(&mut self.uploads, &mut encoder, &sky, stars.as_deref());
+        }
        let skin = frame.skin.filter(|skin| match &mut self.entity_skin {
            Some(skinner) => skinner.register(&self.device, &mut self.uploads, &mut encoder, skin),
            None => false,
@@ -9888,8 +10264,16 @@ impl Renderer {
                    {
                        Some((sky, native)) => sky.draw(&mut pass, native),
                        None => {
-                            pass.set_pipeline(&self.sky_base);
-                            pass.draw(0..3, 0..1);
+                            match self.core_sky.as_ref().filter(|c| c.draws_disc()) {
+                                Some(core) => {
+                                    core.draw_disc(&mut pass);
+                                    pass.set_bind_group(0, &self.group, &[]);
+                                }
+                                None => {
+                                    pass.set_pipeline(&self.sky_base);
+                                    pass.draw(0..3, 0..1);
+                                }
+                            }
                            if frame.sky.sunrise_color[3] > 0.001 {
                                pass.set_pipeline(&self.sunrise_pipeline);
                                pass.set_vertex_buffer(0, self.sunrise_buffer.slice(..));
@@ -9940,7 +10324,10 @@ impl Renderer {
                    .as_ref()
                    .is_some_and(|n| n.sky.is_some() && !n.vanilla_stars);
                if !frame.title && frame.stars.is_some() && !pack_draws_sky && !own_stars {
-                    self.stars.draw(&mut pass);
+                    match self.core_sky.as_ref().filter(|c| c.draws_stars()) {
+                        Some(core) => core.draw_stars(&mut pass),
+                        None => self.stars.draw(&mut pass),
+                    }
                    pass.set_bind_group(0, &self.group, &[]);
                }
                if !frame.title && frame.dark_disc && !pack_draws_sky {
@@ -10285,7 +10672,7 @@ impl Renderer {
                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
                pass.draw_indexed(0..entity_quads * 6, 0, 0..1);
                if self.hdr.is_some() {
-                    pass.set_pipeline(&self.hdr_mark_pipeline);
+                    pass.set_pipeline(&self.hdr_entity_mark_pipeline);
                    pass.draw_indexed(0..entity_quads * 6, 0, 0..1);
                }
                pass.set_bind_group(0, &self.group, &[]);
@@ -10747,7 +11134,7 @@ impl Renderer {
                );
                if self.hdr.is_some() {
                    // Fireworks: their sparks are translucent-layer particles.
-                    pass.set_pipeline(&self.hdr_mark_pipeline);
+                    pass.set_pipeline(&self.hdr_entity_mark_pipeline);
                    pass.draw_indexed(
                        0..translucent_particle_quads * 6,
                        ((base_quads - translucent_item_quads - translucent_particle_quads) * 4)
@@ -11097,10 +11484,18 @@ impl Renderer {
            );
        }
        laps.lap("r_passes");
+        // What an SDR picture of the frame shows: on HDR output's layered frame its HUD target,
+        // the HUD over the world clipped to white.
+        let sdr_texture = self
+            .hdr
+            .as_ref()
+            .and_then(|h| h.hud())
+            .cloned()
+            .unwrap_or_else(|| target_texture.clone());
        // Under `HORIZON_FRAMEGEN_DEBUG=generated` a screenshot is the made frame.
        let shown_texture = match &fg_frames {
            Some((_, generated)) if fg_made && frame_gen::generated_only() => generated,
-            _ => &target_texture,
+            _ => &sdr_texture,
        };
        let readback = readback.or_else(|| {
            self.screenshot
@@ -11138,7 +11533,7 @@ impl Renderer {
            (Some(_), None) => {
                if let Some(image) = &self.offscreen {
                    self.readback
-                        .draw_onto(&self.device, &mut encoder, &target_texture, image);
+                        .draw_onto(&self.device, &mut encoder, &sdr_texture, image);
                }
            }
            (None, _) => {}
@@ -11329,8 +11724,15 @@ impl Renderer {
        } else {
            None
        };
+        // HDR output's layered frame keeps the world after the hand and the camera overlays,
+        // as light (`Hdr::layered`); else it is kept here, before them.
+        let layered = self.hdr.as_ref().is_some_and(|h| h.layered());
        if let Some(hdr) = &self.hdr {
-            hdr.keep_world(encoder, timing.as_mut());
+            if layered {
+                hdr.begin(&self.queue, !frame.title);
+            } else {
+                hdr.keep_world(encoder, timing.as_mut());
+            }
        }
        if overlay.hand_quads > 0 {
            let attachments = [Some(wgpu::RenderPassColorAttachment {
@@ -11369,7 +11771,14 @@ impl Renderer {
            drop(pass);
            if let Some(hdr) = &self.hdr {
                hdr.mark_hand(encoder, timing.as_mut());
-                if let Some(view) = hdr.hand_light_view() {
+                // On the layered frame the hand's marks go to the frame, before they become
+                // light with the world's.
+                let marks = if layered {
+                    Some(view_target.clone())
+                } else {
+                    hdr.hand_light_view()
+                };
+                if let Some(view) = marks {
                    // The light sources in the hand may shine, the rest of it stays at the
                    // world's brightness: nothing the world kept here shows through it.
                    let attachments = [Some(wgpu::RenderPassColorAttachment {
@@ -11401,11 +11810,19 @@ impl Renderer {
                    let quads = 0..overlay.hand_quads * 6;
                    pass.set_pipeline(&self.hdr_hand_unmark_pipeline);
                    pass.draw_indexed(quads.clone(), overlay.first_hand_vertex, 0..1);
-                    pass.set_pipeline(&self.hdr_mark_pipeline);
+                    pass.set_pipeline(&self.hdr_entity_mark_pipeline);
                    pass.draw_indexed(quads, overlay.first_hand_vertex, 0..1);
                }
            }
        }
+        // The layered frame's marks become light: what draws from here draws on light, and
+        // nothing is lifted after.
+        if layered
+            && !frame.title
+            && let Some(hdr) = &self.hdr
+        {
+            hdr.resolve(encoder, timing.as_mut());
+        }
        // A native mod's turn after the hand, on the real frame only.
        if overlay.real && !frame.title {
            native_render::native_hand_drawn(&mut native_render::HandDrawn {
@@ -11538,11 +11955,25 @@ impl Renderer {
                }
            }
        }
+        if layered && let Some(hdr) = &self.hdr {
+            hdr.keep_world(encoder, timing.as_mut());
+        }
+        // What the HUD and menus draw on: the layered frame's HUD target, else the frame.
+        let hud = self
+            .hdr
+            .as_ref()
+            .and_then(|h| h.hud())
+            .map(|t| t.create_view(&Default::default()));
+        let hud_target = hud.as_ref().unwrap_or(view_target);
+        let coverage = self.hdr.as_ref().and_then(|h| h.coverage_view());
+        if let Some(view) = &coverage {
+            hud_coverage::clear(encoder, view);
+        }
        // GameRenderer.render3dHud: the debug crosshair after the hand and
        // the screen effects.
        if overlay.crosshair > 0 {
-            let attachments = [Some(wgpu::RenderPassColorAttachment {
-                view: view_target,
+            let mut attachments = vec![Some(wgpu::RenderPassColorAttachment {
+                view: hud_target,
                resolve_target: None,
                depth_slice: None,
                ops: wgpu::Operations {
@@ -11550,6 +11981,9 @@ impl Renderer {
                    store: wgpu::StoreOp::Store,
                },
            })];
+            if let Some(view) = &coverage {
+                attachments.push(Some(hud_coverage::attachment(view)));
+            }
            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("3d crosshair"),
                timestamp_writes: timing.as_mut().and_then(|t| t.writes("Crosshair")),
@@ -11564,7 +11998,11 @@ impl Renderer {
                }),
                ..Default::default()
            });
-            pass.set_pipeline(&self.debug_lines_on_top);
+            pass.set_pipeline(if coverage.is_some() {
+                self.debug_crosshair.as_ref().unwrap()
+            } else {
+                &self.debug_lines_on_top
+            });
            pass.set_bind_group(0, &self.crosshair_group, &[]);
            pass.set_vertex_buffer(0, self.debug_line_buffer.slice(..));
            let first = overlay.first_crosshair;
@@ -11576,7 +12014,8 @@ impl Renderer {
        let blur_at = menu_blur.map_or(0, |_| frame.hud.blur_at);
        self.hud.draw_range(
            encoder,
-            view_target,
+            hud_target,
+            coverage.as_ref(),
            &self.depth,
            frame.hud,
            [self.config.width, self.config.height],
@@ -11587,24 +12026,48 @@ impl Renderer {
            let format = self.frame_format;
            let device = &self.device;
            let software = is_software(self.info.device_type);
-            self.menu_blur
-                .get_or_insert_with(|| crate::menu_blur::MenuBlur::new(device, format, software))
-                .apply(
-                    &self.device,
+            let blur = self
+                .menu_blur
+                .get_or_insert_with(|| crate::menu_blur::MenuBlur::new(device, format, software));
+            let size = [self.config.width, self.config.height];
+            match self.hdr.as_ref().filter(|_| layered) {
+                // The blur keeps light above white: it blurs the picture so far, the HUD over
+                // the world's light, which becomes the world the menu draws over.
+                Some(hdr) => {
+                    let (_, source) = blur.source(device, size);
+                    hdr.composite(encoder, &source, timing.as_mut());
+                    blur.blur(
+                        device,
+                        &self.queue,
+                        encoder,
+                        view_target,
+                        size,
+                        radius,
+                        timing.as_mut(),
+                    );
+                    hdr.keep_world(encoder, timing.as_mut());
+                }
+                None => blur.apply(
+                    device,
                    &self.queue,
                    encoder,
                    target_texture,
                    view_target,
-                    [self.config.width, self.config.height],
+                    size,
                    radius,
                    timing.as_mut(),
-                );
+                ),
+            }
+            if let Some(view) = &coverage {
+                hud_coverage::clear(encoder, view);
+            }
        } else if let Some(blur) = &mut self.menu_blur {
            blur.release();
        }
        self.hud.draw_range(
            encoder,
-            view_target,
+            hud_target,
+            coverage.as_ref(),
            &self.depth,
            frame.hud,
            [self.config.width, self.config.height],
@@ -12145,7 +12608,7 @@ struct Overlay {
    hand_view_proj: Mat4,
 }

-fn world_projection(fov_degrees: f32, aspect: f32, far: f32) -> Mat4 {
+pub(crate) fn world_projection(fov_degrees: f32, aspect: f32, far: f32) -> Mat4 {
    Mat4::perspective_rh(fov_degrees.to_radians(), aspect, far, NEAR_PLANE)
 }

@@ -1047,7 +1047,15 @@ mod tests {
                hdr: None,
            }
        };
-        let mut flat = flat::Flat::new(&device, &terrain_layout, 4 * GRAIN, 0, pipeline, solid);
+        let mut flat = flat::Flat::new(
+            &device,
+            &terrain_layout,
+            4 * GRAIN,
+            0,
+            false,
+            pipeline,
+            solid,
+        );
        let stride = std::mem::size_of::<crate::mesher::TerrainVertex>() as u64;
        let mut translucent = Arena::translucent(&device, stride, 4 * GRAIN);
        translucent.page_limit = 4 * GRAIN;
@@ -0,0 +1,436 @@
+//! A resource pack's `core/sky` and `core/stars` shaders: the overworld's sky disc and stars drawn
+//! with the pack's GLSL (`SkyRenderer.renderSkyDisc`, `renderStars`), as a pack that adds a haze
+//! to the horizon or tints the night sky expects. Without one the sky draws natively (`fs_sky` in
+//! terrain.wgsl, stars.rs).
+
+use glam::Mat4;
+use horizon_shaders::{CoreProgram, Glue};
+use wgpu::util::DeviceExt;
+
+/// `DefaultVertexFormat.POSITION`: the disc's and the stars' vertices.
+pub(crate) const GLUE: Glue = Glue {
+    inputs: &[("Position", "vec3")],
+    prelude: "layout(location = 0) in vec3 hz_position;",
+    setup: "Position = hz_position;",
+    // 26.3's ProjMat already has wgpu's reversed 0 to 1 depth (Projection: zZeroToOne).
+    finish: "",
+    vertex_id: "int(gl_VertexIndex)",
+};
+
+/// Each uniform block's offset in the one buffer (`core_shader::BLOCKS` order).
+const BLOCK_OFFSETS: [u64; 4] = [0, 256, 512, 768];
+const BLOCK_SIZES: [u64; 4] = [48, 64, 160, 48];
+
+/// `SkyRenderer.buildSkyDisc(16)`: a fan around the point 16 above the camera, out to 512 every
+/// 45 degrees, as a triangle list.
+pub(crate) fn disc_triangles() -> Vec<[f32; 3]> {
+    let rim: Vec<[f32; 3]> = (-180..=180)
+        .step_by(45)
+        .map(|i: i32| {
+            let a = (i as f32).to_radians();
+            [512.0 * a.cos(), 16.0, 512.0 * a.sin()]
+        })
+        .collect();
+    rim.windows(2)
+        .flat_map(|edge| [[0.0, 16.0, 0.0], edge[0], edge[1]])
+        .collect()
+}
+
+/// One of the sky's pack pipelines with its vertices and uniforms.
+struct Part {
+    pipeline: wgpu::RenderPipeline,
+    group: wgpu::BindGroup,
+    uniform: wgpu::Buffer,
+    vertices: wgpu::Buffer,
+    count: u32,
+}
+
+impl Part {
+    fn new(
+        device: &wgpu::Device,
+        format: wgpu::TextureFormat,
+        program: &CoreProgram,
+        name: &str,
+        blend: Option<wgpu::BlendState>,
+        triangles: &[[f32; 3]],
+    ) -> Option<Self> {
+        // A pack's shader is untrusted: the backend failing to compile it is an internal error.
+        let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
+        let internal = device.push_error_scope(wgpu::ErrorFilter::Internal);
+        let module = |stage, module: &naga::Module| {
+            device.create_shader_module(wgpu::ShaderModuleDescriptor {
+                label: Some(&format!("Resource pack {name} ({stage})")),
+                source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module.clone())),
+            })
+        };
+        let vertex = module("vertex", &program.vertex);
+        let fragment = module("fragment", &program.fragment);
+        // Vanilla's SKY and STARS pipelines have no samplers: a pack that reads one is not used.
+        let entries: Vec<wgpu::BindGroupLayoutEntry> = (0..4)
+            .map(|binding| wgpu::BindGroupLayoutEntry {
+                binding,
+                visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
+                ty: wgpu::BindingType::Buffer {
+                    ty: wgpu::BufferBindingType::Uniform,
+                    has_dynamic_offset: false,
+                    min_binding_size: wgpu::BufferSize::new(BLOCK_SIZES[binding as usize]),
+                },
+                count: None,
+            })
+            .collect();
+        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some(name),
+            entries: &entries,
+        });
+        let uniform = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some(name),
+            size: 1024,
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        let resources: Vec<wgpu::BindGroupEntry> = (0..4)
+            .map(|i| wgpu::BindGroupEntry {
+                binding: i as u32,
+                resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
+                    buffer: &uniform,
+                    offset: BLOCK_OFFSETS[i],
+                    size: wgpu::BufferSize::new(BLOCK_SIZES[i]),
+                }),
+            })
+            .collect();
+        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some(name),
+            layout: &layout,
+            entries: &resources,
+        });
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some(name),
+            bind_group_layouts: &[Some(&layout)],
+            ..Default::default()
+        });
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some(name),
+            layout: Some(&pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &vertex,
+                entry_point: Some("main"),
+                compilation_options: Default::default(),
+                buffers: &[Some(wgpu::VertexBufferLayout {
+                    array_stride: 12,
+                    step_mode: wgpu::VertexStepMode::Vertex,
+                    attributes: &wgpu::vertex_attr_array![0 => Float32x3],
+                })],
+            },
+            primitive: wgpu::PrimitiveState::default(),
+            // The sky is drawn first, behind everything: no depth test, no depth write.
+            depth_stencil: Some(wgpu::DepthStencilState {
+                format: wgpu::TextureFormat::Depth32Float,
+                depth_write_enabled: Some(false),
+                depth_compare: Some(wgpu::CompareFunction::Always),
+                stencil: Default::default(),
+                bias: Default::default(),
+            }),
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: &fragment,
+                entry_point: Some("main"),
+                compilation_options: Default::default(),
+                targets: &[Some(wgpu::ColorTargetState {
+                    format,
+                    blend,
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            multiview_mask: None,
+            cache: None,
+        });
+        let internal = pollster::block_on(internal.pop());
+        if let Some(e) = internal.or(pollster::block_on(validation.pop())) {
+            log::warn!("the resource pack's {name} shader is not used: {e}");
+            return None;
+        }
+        let vertices = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some(name),
+            contents: bytemuck::cast_slice(triangles),
+            usage: wgpu::BufferUsages::VERTEX,
+        });
+        Some(Self {
+            pipeline,
+            group,
+            uniform,
+            vertices,
+            count: triangles.len() as u32,
+        })
+    }
+
+    fn draw(&self, pass: &mut wgpu::RenderPass<'_>) {
+        pass.set_pipeline(&self.pipeline);
+        pass.set_bind_group(0, &self.group, &[]);
+        pass.set_vertex_buffer(0, self.vertices.slice(..));
+        pass.draw(0..self.count, 0..1);
+    }
+}
+
+/// The packs' sky disc and stars pipelines, each present when a pack replaces that shader.
+pub(super) struct CoreSky {
+    disc: Option<Part>,
+    stars: Option<Part>,
+}
+
+impl CoreSky {
+    /// `None` when neither shader is replaced or neither builds.
+    pub(super) fn new(
+        device: &wgpu::Device,
+        format: wgpu::TextureFormat,
+        disc: Option<&CoreProgram>,
+        stars: Option<&CoreProgram>,
+    ) -> Option<Self> {
+        let disc = disc.and_then(|program| {
+            // RenderPipelines.SKY: ColorTargetState.DEFAULT, no blending.
+            Part::new(device, format, program, "sky", None, &disc_triangles())
+        });
+        let stars = stars.and_then(|program| {
+            // RenderPipelines.STARS: BlendFunction.OVERLAY (src alpha and one; alpha one, zero).
+            let overlay = wgpu::BlendState {
+                color: wgpu::BlendComponent {
+                    src_factor: wgpu::BlendFactor::SrcAlpha,
+                    dst_factor: wgpu::BlendFactor::One,
+                    operation: wgpu::BlendOperation::Add,
+                },
+                alpha: wgpu::BlendComponent {
+                    src_factor: wgpu::BlendFactor::One,
+                    dst_factor: wgpu::BlendFactor::Zero,
+                    operation: wgpu::BlendOperation::Add,
+                },
+            };
+            let triangles = super::stars::star_triangles();
+            Part::new(device, format, program, "stars", Some(overlay), &triangles)
+        });
+        (disc.is_some() || stars.is_some()).then_some(Self { disc, stars })
+    }
+
+    pub(super) fn draws_disc(&self) -> bool {
+        self.disc.is_some()
+    }
+
+    pub(super) fn draws_stars(&self) -> bool {
+        self.stars.is_some()
+    }
+
+    /// Uploads the disc's and the stars' blocks: `sky` and `stars` from [`uniforms`].
+    pub(super) fn prepare(
+        &self,
+        uploads: &mut super::upload::Uploads,
+        encoder: &mut wgpu::CommandEncoder,
+        sky: &[u8],
+        stars: Option<&[u8]>,
+    ) {
+        if let Some(disc) = &self.disc {
+            uploads.buffer(encoder, &disc.uniform, 0, sky);
+        }
+        if let (Some(part), Some(data)) = (&self.stars, stars) {
+            uploads.buffer(encoder, &part.uniform, 0, data);
+        }
+    }
+
+    /// The disc, in place of the native sky colour. The caller sets its own group 0 again after.
+    pub(super) fn draw_disc(&self, pass: &mut wgpu::RenderPass<'_>) {
+        if let Some(disc) = &self.disc {
+            disc.draw(pass);
+        }
+    }
+
+    /// The stars, in place of the native ones. The caller sets its own group 0 again after.
+    pub(super) fn draw_stars(&self, pass: &mut wgpu::RenderPass<'_>) {
+        if let Some(stars) = &self.stars {
+            stars.draw(pass);
+        }
+    }
+}
+
+/// The std140 blocks for one sky draw: `Globals`, `Projection` (`projection`, far enough for the
+/// disc's 512-block rim), `DynamicTransforms` (`model_view`: the camera's rotation, times the
+/// stars' rotation for them; `color`: the sky colour, or the star brightness in every channel)
+/// and `Fog` (`fog_color`, `fog`: environmental start and end, render distance start and end,
+/// sky end, clouds end).
+pub(super) fn uniforms(
+    globals: [u8; 48],
+    projection: Mat4,
+    model_view: Mat4,
+    color: [f32; 4],
+    fog_color: [f32; 4],
+    fog: [f32; 6],
+) -> Vec<u8> {
+    let mut data = vec![0f32; 256];
+    data[64..80].copy_from_slice(&projection.to_cols_array());
+    let transforms = 128;
+    data[transforms..transforms + 16].copy_from_slice(&model_view.to_cols_array());
+    data[transforms + 16..transforms + 32].copy_from_slice(&Mat4::IDENTITY.to_cols_array());
+    data[transforms + 32..transforms + 36].copy_from_slice(&color);
+    data[192..196].copy_from_slice(&fog_color);
+    data[196..202].copy_from_slice(&fog);
+    let mut bytes: Vec<u8> = bytemuck::cast_slice(&data).to_vec();
+    bytes[..48].copy_from_slice(&globals);
+    bytes
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// `buildSkyDisc(16)`: eight triangles from the point above the camera to the rim, which
+    /// starts and ends at x -512 (cos 180°) and passes through z -512, x 512 and z 512.
+    #[test]
+    fn the_disc_is_vanillas_fan_as_triangles() {
+        let triangles = disc_triangles();
+        assert_eq!(triangles.len(), 24);
+        assert!(triangles.chunks(3).all(|t| t[0] == [0.0, 16.0, 0.0]));
+        let rim: Vec<[f32; 3]> = triangles.chunks(3).map(|t| t[1]).collect();
+        let near = |a: [f32; 3], b: [f32; 3]| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-3);
+        assert!(near(rim[0], [-512.0, 16.0, 0.0]));
+        assert!(near(rim[2], [0.0, 16.0, -512.0]));
+        assert!(near(rim[4], [512.0, 16.0, 0.0]));
+        assert!(near(rim[6], [0.0, 16.0, 512.0]));
+        assert!(near(triangles[23], [-512.0, 16.0, 0.0]));
+    }
+
+    /// The prepared resources (`HORIZON_RESOURCES`, or `.local/horizon-client/<version>`), where
+    /// vanilla's sky shader and its includes are.
+    fn resources() -> std::path::PathBuf {
+        std::env::var_os("HORIZON_RESOURCES")
+            .map(std::path::PathBuf::from)
+            .unwrap_or_else(|| {
+                std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                    .join("../../.local/horizon-client")
+                    .join(horizon_core::VANILLA_VERSION)
+            })
+    }
+
+    /// Vanilla's `sky.vsh` with a pack's fragment shader that paints `ColorModulator` (the sky
+    /// colour) where the disc is: looking at the horizon, the top half of the target is the
+    /// disc, the bottom half stays clear.
+    #[test]
+    fn a_pack_sky_shader_paints_the_disc_above_the_horizon() {
+        let root = resources();
+        let Ok(vertex) =
+            std::fs::read_to_string(root.join("assets/minecraft/shaders/core/sky.vsh"))
+        else {
+            eprintln!("skipping: no prepared resources at {}", root.display());
+            return;
+        };
+        let include = |id: &str| {
+            let (namespace, path) = id.split_once(':')?;
+            std::fs::read_to_string(root.join(format!("assets/{namespace}/{path}"))).ok()
+        };
+        let fragment = "#version 330\n#include <minecraft:dynamictransforms.glsl>\n\
+            layout(location = 0) out vec4 fragColor;\n\
+            void main() {\n    fragColor = ColorModulator;\n}\n";
+        let program = horizon_shaders::translate_core(&vertex, fragment, &[], &include, &GLUE)
+            .expect("the sky shaders translate");
+        let instance = crate::gfx::test_gpu::instance();
+        let Some((device, queue)) =
+            pollster::block_on(instance.request_adapter(&Default::default()))
+                .ok()
+                .and_then(|adapter| {
+                    pollster::block_on(adapter.request_device(&Default::default())).ok()
+                })
+        else {
+            eprintln!("no GPU: skipping");
+            return;
+        };
+        const SIZE: u32 = 64;
+        let format = wgpu::TextureFormat::Rgba8Unorm;
+        let sky = CoreSky::new(&device, format, Some(&program), None).expect("the sky pipeline");
+        let projection = crate::gfx::world_projection(90.0, 1.0, 2048.0);
+        let data = uniforms(
+            [0; 48],
+            projection,
+            Mat4::IDENTITY,
+            [0.25, 0.5, 1.0, 1.0],
+            [0.0; 4],
+            [1e6; 6],
+        );
+        queue.write_buffer(&sky.disc.as_ref().unwrap().uniform, 0, &data);
+        let target = |format, usage| {
+            device.create_texture(&wgpu::TextureDescriptor {
+                label: None,
+                size: wgpu::Extent3d {
+                    width: SIZE,
+                    height: SIZE,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format,
+                usage: wgpu::TextureUsages::RENDER_ATTACHMENT | usage,
+                view_formats: &[],
+            })
+        };
+        let color = target(format, wgpu::TextureUsages::COPY_SRC);
+        let depth = target(
+            wgpu::TextureFormat::Depth32Float,
+            wgpu::TextureUsages::empty(),
+        );
+        let read = device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: u64::from(SIZE * SIZE * 4),
+            usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        let mut encoder = device.create_command_encoder(&Default::default());
+        {
+            let color_view = color.create_view(&Default::default());
+            let depth_view = depth.create_view(&Default::default());
+            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: None,
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &color_view,
+                    depth_slice: None,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                    view: &depth_view,
+                    depth_ops: Some(wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(0.0),
+                        store: wgpu::StoreOp::Store,
+                    }),
+                    stencil_ops: None,
+                }),
+                ..Default::default()
+            });
+            sky.draw_disc(&mut pass);
+        }
+        encoder.copy_texture_to_buffer(
+            color.as_image_copy(),
+            wgpu::TexelCopyBufferInfo {
+                buffer: &read,
+                layout: wgpu::TexelCopyBufferLayout {
+                    offset: 0,
+                    bytes_per_row: Some(SIZE * 4),
+                    rows_per_image: Some(SIZE),
+                },
+            },
+            color.size(),
+        );
+        queue.submit([encoder.finish()]);
+        read.slice(..)
+            .map_async(wgpu::MapMode::Read, |r| r.unwrap());
+        device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+        let pixels = read.slice(..).get_mapped_range().unwrap().to_vec();
+        let at = |x: usize, y: usize| pixels[(y * 64 + x) * 4..(y * 64 + x) * 4 + 4].to_vec();
+        // Row 0 is the top: the disc, in the sky colour; the bottom row is below the horizon.
+        let top = at(32, 4);
+        assert!(
+            top.iter()
+                .zip([64u8, 128, 255, 255])
+                .all(|(&p, w)| p.abs_diff(w) <= 1),
+            "{top:?}"
+        );
+        assert_eq!(at(32, 60), vec![0, 0, 0, 0]);
+    }
+}
@@ -106,6 +106,8 @@ pub struct Flat {
    phase2_calls: wgpu::Buffer,
    phase2_call_capacity: u64,
    phase2_call_data: Vec<[u32; 5]>,
+    /// GPU culling's phase 2 uses indirect draws; flat draws without culling do not.
+    indirect_execution: bool,
    /// The copy of phase 2's draws, and its ranges.
    phase2_group: Option<(wgpu::BindGroup, u32)>,
    /// The layout of a page's bind group 1 (shader packs' terrain pipelines share it).
@@ -365,6 +367,7 @@ impl Flat {
        terrain_layout: &wgpu::BindGroupLayout,
        page_vertices: u64,
        min_sections: usize,
+        indirect_execution: bool,
        pipeline: impl Fn(
            &wgpu::PipelineLayout,
            &str,
@@ -489,10 +492,16 @@ impl Flat {
                device,
                "Flat section draw calls, phase 2",
                20,
-                wgpu::BufferUsages::INDIRECT | storage_usage,
+                storage_usage
+                    | if indirect_execution {
+                        wgpu::BufferUsages::INDIRECT
+                    } else {
+                        wgpu::BufferUsages::empty()
+                    },
            ),
            phase2_call_capacity: 1,
            phase2_call_data: Vec::new(),
+            indirect_execution,
            phase2_group: None,
            draw_layout,
            blocks_per_page: page_vertices.div_ceil(GRAIN),
@@ -645,6 +654,7 @@ impl Flat {
        timing: Option<&mut super::pack_timing::PassTiming>,
    ) -> bool {
        self.phase2_group = None;
+        let phase2 = phase2.filter(|_| self.indirect_execution);
        let phase1_draws = if phase2.is_some() {
            phase1_draws
        } else {
@@ -753,7 +763,12 @@ impl Flat {
                device,
                "Flat section draw calls, phase 2",
                self.phase2_call_capacity * 20,
-                wgpu::BufferUsages::INDIRECT | wgpu::BufferUsages::STORAGE,
+                wgpu::BufferUsages::STORAGE
+                    | if self.indirect_execution {
+                        wgpu::BufferUsages::INDIRECT
+                    } else {
+                        wgpu::BufferUsages::empty()
+                    },
            );
        }
        if phase2_calls > 0 {
@@ -72,8 +72,29 @@ fn named(name: Option<&str>) -> Option<Output> {
 struct Targets {
    size: [u32; 2],
    frame: wgpu::Texture,
+    /// The world as `keep_world` kept it; on the layered frame, the frame as the world and the
+    /// hand marked it, for `resolve`.
    world: wgpu::Texture,
+    coverage: Option<wgpu::Texture>,
+    /// The layered frame's HUD target: what the HUD draws on.
+    hud: Option<wgpu::Texture>,
    group: wgpu::BindGroup,
+    /// The layered frame's passes' bindings: `resolve`, `keep_world` and `composite`.
+    passes: Option<[wgpu::BindGroup; 3]>,
+}
+
+/// The float frame with HUD coverage (`hud_coverage::supported`, docs/design/hdr-linear-light.md
+/// "The HUD and menus"): the world's marks become light once, after the world and the hand
+/// (`resolve`); the camera overlays draw on that light; the HUD draws on a target of its own,
+/// the world clipped to white (`keep_world`); and the last pass composites the HUD over the
+/// world's light by its coverage (`fs_hdr_layered`), as the menu blur does before it blurs
+/// (`composite`).
+struct Layered {
+    resolve: (wgpu::BindGroupLayout, wgpu::RenderPipeline),
+    keep: (wgpu::BindGroupLayout, wgpu::RenderPipeline),
+    composite: (wgpu::BindGroupLayout, wgpu::RenderPipeline),
+    /// What `resolve` and `composite` read, written before they run (`begin`).
+    params: wgpu::Buffer,
 }

 /// How one tier of light sources (`mesher::hdr_tier`) shines: `share` of the headroom for
@@ -155,6 +176,7 @@ pub struct Hdr {
    targets: Option<Targets>,
    /// `HORIZON_HDR_DEBUG=1`: grey what isn't expanded, tint what is magenta.
    debug: bool,
+    layered: Option<Layered>,
    /// Paper white and peak brightness, in nits.
    pub paper_white: f32,
    pub peak: f32,
@@ -181,28 +203,67 @@ impl Hdr {
        queue: &wgpu::Queue,
        format: wgpu::TextureFormat,
        output: Output,
+        coverage: bool,
    ) -> Self {
+        let debug = std::env::var("HORIZON_HDR_DEBUG").ok();
+        Self::with_debug(device, queue, format, output, coverage, debug.as_deref())
+    }
+
+    fn with_debug(
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        format: wgpu::TextureFormat,
+        output: Output,
+        coverage: bool,
+        debug: Option<&str>,
+    ) -> Self {
+        let coverage_debug = coverage && debug == Some("coverage");
+        // The layered frame's last pass, else today's.
+        let entry_point = if coverage { "fs_hdr_layered" } else { "fs_hdr" };
+        let mut source = include_str!("../hdr.wgsl").to_owned();
+        if coverage_debug {
+            // The debug view wraps the last pass as it is, so the picture under the tint is
+            // exactly the one without it.
+            let entry = format!(
+                "@fragment fn {entry_point}(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32>"
+            );
+            assert!(
+                source.contains(&entry),
+                "hdr.wgsl's {entry_point} changed its signature"
+            );
+            source = source.replace(&entry, "fn picture_hdr(pos: vec4<f32>) -> vec4<f32>");
+            source.push_str(&entry);
+            source.push_str(
+                r#" {
+    let picture = picture_hdr(pos);
+    let c = textureLoad(coverage, vec2<i32>(pos.xy), 0).r;
+    // Magenta at paper white, in the output's own encoding.
+    let paper = vec3(params.paper, 0.0, params.paper);
+    let magenta = select(paper, pq(BT709_TO_BT2020 * paper * 80.0), params.pq > 0.5);
+    return vec4(mix(picture.rgb, magenta, c), picture.a);
+}
+"#,
+            );
+        }
        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("Horizon HDR"),
-            source: wgpu::ShaderSource::Wgsl(include_str!("../hdr.wgsl").into()),
+            source: wgpu::ShaderSource::Wgsl(source.into()),
        });
-        let texture = |binding| wgpu::BindGroupLayoutEntry {
-            binding,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Texture {
-                sample_type: wgpu::TextureSampleType::Float { filterable: false },
-                view_dimension: wgpu::TextureViewDimension::D2,
-                multisampled: false,
-            },
-            count: None,
-        };
-        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            label: Some("Horizon HDR bindings"),
-            entries: &[
-                texture(0),
-                texture(1),
-                texture(3),
-                wgpu::BindGroupLayoutEntry {
+        // hdr.wgsl's bindings: the textures at `textures`, and its `Params` at 2 if `params`.
+        let layout = |label, textures: &[u32], params: bool| {
+            let texture = |binding| wgpu::BindGroupLayoutEntry {
+                binding,
+                visibility: wgpu::ShaderStages::FRAGMENT,
+                ty: wgpu::BindingType::Texture {
+                    sample_type: wgpu::TextureSampleType::Float { filterable: false },
+                    view_dimension: wgpu::TextureViewDimension::D2,
+                    multisampled: false,
+                },
+                count: None,
+            };
+            let mut entries: Vec<_> = textures.iter().map(|&b| texture(b)).collect();
+            if params {
+                entries.push(wgpu::BindGroupLayoutEntry {
                    binding: 2,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Buffer {
@@ -211,17 +272,22 @@ impl Hdr {
                        min_binding_size: None,
                    },
                    count: None,
-                },
-            ],
-        });
-        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-            label: Some("Horizon HDR"),
-            bind_group_layouts: &[Some(&layout)],
-            ..Default::default()
-        });
-        let pipeline_for = |format| {
+                });
+            }
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                label: Some(label),
+                entries: &entries,
+            })
+        };
+        // One full-screen pass of hdr.wgsl's `entry` into `format`, reading `layout`.
+        let pass = |label, layout: &wgpu::BindGroupLayout, entry, format| {
+            let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: Some(label),
+                bind_group_layouts: &[Some(layout)],
+                ..Default::default()
+            });
            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                label: Some("Horizon HDR"),
+                label: Some(label),
                layout: Some(&pipeline_layout),
                vertex: wgpu::VertexState {
                    module: &shader,
@@ -234,7 +300,7 @@ impl Hdr {
                multisample: Default::default(),
                fragment: Some(wgpu::FragmentState {
                    module: &shader,
-                    entry_point: Some("fs_hdr"),
+                    entry_point: Some(entry),
                    compilation_options: Default::default(),
                    targets: &[Some(wgpu::ColorTargetState {
                        format,
@@ -246,6 +312,30 @@ impl Hdr {
                cache: None,
            })
        };
+        let layout_bindings: &[u32] = if coverage { &[0, 3, 4, 5] } else { &[0, 1, 3] };
+        let display = layout("Horizon HDR bindings", layout_bindings, true);
+        let pipeline_for = |format| pass("Horizon HDR", &display, entry_point, format);
+        let params = || {
+            device.create_buffer(&wgpu::BufferDescriptor {
+                label: Some("Horizon HDR parameters"),
+                size: 64,
+                usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+                mapped_at_creation: false,
+            })
+        };
+        let layered = coverage.then(|| {
+            let with = |label, textures: &[u32], params, entry| {
+                let layout = layout(label, textures, params);
+                let pipeline = pass(label, &layout, entry, format);
+                (layout, pipeline)
+            };
+            Layered {
+                resolve: with("Horizon HDR marks to light", &[1], true, "fs_resolve"),
+                keep: with("Horizon HDR HUD backdrop", &[0], false, "fs_keep"),
+                composite: with("Horizon HDR composite", &[0, 4, 5], true, "fs_composite"),
+                params: params(),
+            }
+        });
        let alpha_pass = |label, blend| {
            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                label: Some(label),
@@ -288,27 +378,20 @@ impl Hdr {
                alpha: scale_alpha,
            }),
        );
-        let params = || {
-            device.create_buffer(&wgpu::BufferDescriptor {
-                label: Some("Horizon HDR parameters"),
-                size: 64,
-                usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-                mapped_at_creation: false,
-            })
-        };
        Self {
            logo: logo_mask(device, queue),
-            layout,
            pipeline: pipeline_for(output.format()),
+            capture_pipeline: pipeline_for(Output::Pq.format()),
+            layout: display,
            clear_alpha,
            hand_mark,
            params: params(),
-            capture_pipeline: pipeline_for(Output::Pq.format()),
            capture_params: params(),
            output,
            format,
            targets: None,
-            debug: std::env::var_os("HORIZON_HDR_DEBUG").is_some_and(|v| v == "1"),
+            debug: debug == Some("1"),
+            layered,
            paper_white: 200.0,
            peak: 1000.0,
            black: 0.0,
@@ -324,7 +407,7 @@ impl Hdr {
    /// The frame every pass draws into this frame, sized like the window.
    pub fn frame(&mut self, device: &wgpu::Device, size: [u32; 2]) -> wgpu::Texture {
        if self.targets.as_ref().is_none_or(|t| t.size != size) {
-            let texture = |label, usage| {
+            let texture = |label, format, usage| {
                device.create_texture(&wgpu::TextureDescriptor {
                    label: Some(label),
                    size: wgpu::Extent3d {
@@ -335,52 +418,185 @@ impl Hdr {
                    mip_level_count: 1,
                    sample_count: 1,
                    dimension: wgpu::TextureDimension::D2,
-                    format: self.format,
+                    format,
                    usage: usage | wgpu::TextureUsages::TEXTURE_BINDING,
                    view_formats: &[],
                })
            };
            let frame = texture(
                "Horizon HDR frame",
+                self.format,
                wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
            );
            let world = texture(
                "Horizon HDR world",
+                self.format,
                wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::RENDER_ATTACHMENT,
            );
-            let view = |t: &wgpu::Texture| t.create_view(&Default::default());
-            let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-                label: Some("Horizon HDR bindings"),
-                layout: &self.layout,
-                entries: &[
-                    wgpu::BindGroupEntry {
-                        binding: 0,
-                        resource: wgpu::BindingResource::TextureView(&view(&frame)),
-                    },
-                    wgpu::BindGroupEntry {
-                        binding: 1,
-                        resource: wgpu::BindingResource::TextureView(&view(&world)),
-                    },
-                    wgpu::BindGroupEntry {
-                        binding: 2,
-                        resource: self.params.as_entire_binding(),
-                    },
-                    wgpu::BindGroupEntry {
-                        binding: 3,
-                        resource: wgpu::BindingResource::TextureView(&self.logo),
-                    },
-                ],
+            let layered = self.layered.is_some();
+            let coverage = layered.then(|| {
+                texture(
+                    "HUD coverage",
+                    super::hud_coverage::FORMAT,
+                    wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+                )
            });
+            // In the frame's format, so the HUD's pipelines draw on it as on the frame with HDR
+            // off; the last pass clips it at white.
+            let hud = layered.then(|| {
+                texture(
+                    "HUD",
+                    self.format,
+                    wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+                )
+            });
+            let group = self.group(
+                device,
+                &frame,
+                &world,
+                coverage.as_ref(),
+                hud.as_ref(),
+                &self.params,
+            );
+            let passes = self
+                .layered
+                .as_ref()
+                .zip(coverage.as_ref().zip(hud.as_ref()))
+                .map(|(l, (coverage, hud))| {
+                    let view = |t: &wgpu::Texture| t.create_view(&Default::default());
+                    let (frame, world, coverage, hud) =
+                        (view(&frame), view(&world), view(coverage), view(hud));
+                    let entry = |binding, view| wgpu::BindGroupEntry {
+                        binding,
+                        resource: wgpu::BindingResource::TextureView(view),
+                    };
+                    let params = wgpu::BindGroupEntry {
+                        binding: 2,
+                        resource: l.params.as_entire_binding(),
+                    };
+                    let group = |layout, entries: &[wgpu::BindGroupEntry]| {
+                        device.create_bind_group(&wgpu::BindGroupDescriptor {
+                            label: Some("Horizon HDR layered bindings"),
+                            layout,
+                            entries,
+                        })
+                    };
+                    [
+                        group(&l.resolve.0, &[entry(1, &world), params.clone()]),
+                        group(&l.keep.0, &[entry(0, &frame)]),
+                        group(
+                            &l.composite.0,
+                            &[
+                                entry(0, &frame),
+                                params,
+                                entry(4, &coverage),
+                                entry(5, &hud),
+                            ],
+                        ),
+                    ]
+                });
            self.targets = Some(Targets {
                size,
                frame,
                world,
+                coverage,
+                hud,
                group,
+                passes,
            });
        }
        self.targets.as_ref().unwrap().frame.clone()
    }

+    /// The float frame with HUD coverage (`Layered`).
+    pub fn layered(&self) -> bool {
+        self.layered.is_some()
+    }
+
+    /// The layered frame's HUD target, which the HUD and menus draw on instead of the frame
+    /// once `keep_world` made it, and which an ordinary screenshot shows.
+    pub fn hud(&self) -> Option<&wgpu::Texture> {
+        self.targets.as_ref()?.hud.as_ref()
+    }
+
+    /// On the layered frame, before `resolve` and `composite`: what they read, for a frame that
+    /// drew a world (`world`) or not.
+    pub fn begin(&self, queue: &wgpu::Queue, world: bool) {
+        if let Some(l) = &self.layered {
+            queue.write_buffer(
+                &l.params,
+                0,
+                bytemuck::cast_slice(&self.params(world, false)),
+            );
+        }
+    }
+
+    /// On the layered frame, after the world and the hand drew and marked it: the marks
+    /// become light in the frame (`fs_resolve`), read from a copy of it in the world target.
+    pub fn resolve(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        timing: Option<&mut super::pack_timing::PassTiming>,
+    ) {
+        let (Some(l), Some(t)) = (&self.layered, &self.targets) else {
+            return;
+        };
+        let Some([group, ..]) = &t.passes else {
+            return;
+        };
+        encoder.copy_texture_to_texture(
+            t.frame.as_image_copy(),
+            t.world.as_image_copy(),
+            t.frame.size(),
+        );
+        let view = t.frame.create_view(&Default::default());
+        Self::draw(
+            encoder,
+            &l.resolve.1,
+            group,
+            &view,
+            "HDR marks to light",
+            timing,
+        );
+    }
+
+    /// On the layered frame: the picture so far (`fs_composite`), as the frame stores light,
+    /// into `target`, for the menu blur to blur it and make it the world (`keep_world` after).
+    pub fn composite(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        target: &wgpu::TextureView,
+        timing: Option<&mut super::pack_timing::PassTiming>,
+    ) {
+        if let (
+            Some(l),
+            Some(Targets {
+                passes: Some([_, _, group]),
+                ..
+            }),
+        ) = (&self.layered, &self.targets)
+        {
+            Self::draw(
+                encoder,
+                &l.composite.1,
+                group,
+                target,
+                "HDR composite",
+                timing,
+            );
+        }
+    }
+
+    pub fn coverage_view(&self) -> Option<wgpu::TextureView> {
+        Some(
+            self.targets
+                .as_ref()?
+                .coverage
+                .as_ref()?
+                .create_view(&Default::default()),
+        )
+    }
+
    /// The peak the HDR metadata gives: while calibration's peak step runs, PQ's own
    /// 10 000 nits, so a compositor that clips at the declared peak (KWin) lets the test
    /// patch through as bright as the display goes and the logo under it shows.
@@ -394,6 +610,9 @@ impl Hdr {
    /// Keeps the world as drawn so far, before the hand and HUD cover it, then zeroes the
    /// frame's alpha: the world's marks live on in the copy, and whatever draws from here
    /// on raises the alpha where it covers the world.
+    ///
+    /// On the layered frame the frame keeps the world, the hand and the camera overlays, as
+    /// light, and this makes the HUD's backdrop from it: clipped to white, alpha 0 (`fs_keep`).
    pub fn keep_world(
        &self,
        encoder: &mut wgpu::CommandEncoder,
@@ -402,6 +621,11 @@ impl Hdr {
        let Some(t) = &self.targets else {
            return;
        };
+        if let (Some(l), Some(hud), Some([_, group, _])) = (&self.layered, &t.hud, &t.passes) {
+            let view = hud.create_view(&Default::default());
+            Self::draw(encoder, &l.keep.1, group, &view, "HDR HUD backdrop", timing);
+            return;
+        }
        encoder.copy_texture_to_texture(
            t.frame.as_image_copy(),
            t.world.as_image_copy(),
@@ -429,13 +653,14 @@ impl Hdr {

    /// After the hand: its pixels' alpha goes down to 1/255, below anything the HUD and
    /// menus leave, so HDR output tells the hand (the world's brightness, never lifted)
-    /// from the UI (UI Brightness).
+    /// from the UI (UI Brightness). The layered frame keeps the hand before `keep_world`,
+    /// so it needs no mark there.
    pub fn mark_hand(
        &self,
        encoder: &mut wgpu::CommandEncoder,
        timing: Option<&mut super::pack_timing::PassTiming>,
    ) {
-        let Some(t) = &self.targets else {
+        let Some(t) = self.targets.as_ref().filter(|_| self.layered.is_none()) else {
            return;
        };
        let view = t.frame.create_view(&Default::default());
@@ -466,9 +691,10 @@ impl Hdr {
    }

    /// The world as `keep_world` kept it: where the hand's marks go (its alpha, which HDR output
-    /// reads for it too), and what tints the world rather than covering it.
+    /// reads for it too), and what tints the world rather than covering it. None on the
+    /// layered frame, where both draw on the frame before `keep_world`.
    pub fn hand_light_view(&self) -> Option<wgpu::TextureView> {
-        let t = self.targets.as_ref()?;
+        let t = self.targets.as_ref().filter(|_| self.layered.is_none())?;
        Some(t.world.create_view(&Default::default()))
    }

@@ -494,7 +720,15 @@ impl Hdr {
            0,
            bytemuck::cast_slice(&self.params(world, self.output == Output::Pq)),
        );
-        Self::draw(encoder, &self.pipeline, &t.group, target, timing);
+        let view = target.create_view(&Default::default());
+        Self::draw(
+            encoder,
+            &self.pipeline,
+            &t.group,
+            &view,
+            "HDR output",
+            timing,
+        );
    }

    /// The frame `present` writes, as HDR10 (BT.2020, PQ, 10 bits a channel) whatever
@@ -517,38 +751,66 @@ impl Hdr {
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
            view_formats: &[],
        });
-        let view = |t: &wgpu::Texture| t.create_view(&Default::default());
-        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("Horizon HDR screenshot bindings"),
-            layout: &self.layout,
-            entries: &[
-                wgpu::BindGroupEntry {
-                    binding: 0,
-                    resource: wgpu::BindingResource::TextureView(&view(&t.frame)),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 1,
-                    resource: wgpu::BindingResource::TextureView(&view(&t.world)),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 2,
-                    resource: self.capture_params.as_entire_binding(),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 3,
-                    resource: wgpu::BindingResource::TextureView(&self.logo),
-                },
-            ],
-        });
+        let group = self.group(
+            device,
+            &t.frame,
+            &t.world,
+            t.coverage.as_ref(),
+            t.hud.as_ref(),
+            &self.capture_params,
+        );
        queue.write_buffer(
            &self.capture_params,
            0,
            bytemuck::cast_slice(&self.params(world, true)),
        );
-        Self::draw(encoder, &self.capture_pipeline, &group, &texture, None);
+        let view = texture.create_view(&Default::default());
+        Self::draw(
+            encoder,
+            &self.capture_pipeline,
+            &group,
+            &view,
+            "HDR output",
+            None,
+        );
        Some(texture)
    }

+    fn group(
+        &self,
+        device: &wgpu::Device,
+        frame: &wgpu::Texture,
+        world: &wgpu::Texture,
+        coverage: Option<&wgpu::Texture>,
+        hud: Option<&wgpu::Texture>,
+        params: &wgpu::Buffer,
+    ) -> wgpu::BindGroup {
+        let view = |t: &wgpu::Texture| t.create_view(&Default::default());
+        let (frame, world) = (view(frame), view(world));
+        let layered = coverage.zip(hud).map(|(c, h)| (view(c), view(h)));
+        let texture = |binding, view| wgpu::BindGroupEntry {
+            binding,
+            resource: wgpu::BindingResource::TextureView(view),
+        };
+        let mut entries = vec![
+            texture(0, &frame),
+            wgpu::BindGroupEntry {
+                binding: 2,
+                resource: params.as_entire_binding(),
+            },
+            texture(3, &self.logo),
+        ];
+        match &layered {
+            Some((coverage, hud)) => entries.extend([texture(4, coverage), texture(5, hud)]),
+            None => entries.push(texture(1, &world)),
+        }
+        device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("Horizon HDR bindings"),
+            layout: &self.layout,
+            entries: &entries,
+        })
+    }
+
    /// hdr.wgsl's `Params`.
    fn params(&self, world: bool, pq: bool) -> [f32; 16] {
        let paper = self.paper_white.max(1.0);
@@ -577,16 +839,17 @@ impl Hdr {
        params
    }

+    /// One full-screen pass of `pipeline` into `view`.
    fn draw(
        encoder: &mut wgpu::CommandEncoder,
        pipeline: &wgpu::RenderPipeline,
        group: &wgpu::BindGroup,
-        target: &wgpu::Texture,
+        view: &wgpu::TextureView,
+        label: &'static str,
        timing: Option<&mut super::pack_timing::PassTiming>,
    ) {
-        let view = target.create_view(&Default::default());
        let attachments = [Some(wgpu::RenderPassColorAttachment {
-            view: &view,
+            view,
            resolve_target: None,
            depth_slice: None,
            ops: wgpu::Operations {
@@ -595,8 +858,8 @@ impl Hdr {
            },
        })];
        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: Some("Horizon HDR"),
-            timestamp_writes: timing.and_then(|t| t.writes("HDR output")),
+            label: Some(label),
+            timestamp_writes: timing.and_then(|t| t.writes(label)),
            color_attachments: &attachments,
            ..Default::default()
        });
@@ -655,9 +918,279 @@ fn scene_gain(peak: f32, paper_white: f32) -> f32 {

 #[cfg(test)]
 mod tests {
-    use super::{Output, named, pick};
+    use super::{Hdr, Output, named, pick};
    use wgpu::{SurfaceColorSpaces as S, TextureFormat as F};

+    #[test]
+    fn coverage_target_resizes_resets_and_shows_in_the_debug_view() {
+        let instance = crate::gfx::test_gpu::instance();
+        let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
+            return;
+        };
+        let Ok((device, queue)) = pollster::block_on(adapter.request_device(&Default::default()))
+        else {
+            return;
+        };
+        for enabled in [false, true] {
+            for debug in [None, Some("coverage")] {
+                let mut hdr =
+                    Hdr::with_debug(&device, &queue, F::Rgba16Float, Output::Pq, enabled, debug);
+                hdr.frame(&device, [2, 1]);
+                assert_eq!(hdr.coverage_view().is_some(), enabled);
+                hdr.frame(&device, [4, 2]);
+                let t = hdr.targets.as_ref().unwrap();
+                if let Some(coverage) = &t.coverage {
+                    assert_eq!(coverage.size(), t.frame.size());
+                }
+                let mut encoder = device.create_command_encoder(&Default::default());
+                let frame_view = t.frame.create_view(&Default::default());
+                let mut color = super::super::hud_coverage::attachment(&frame_view);
+                color.ops.load = wgpu::LoadOp::Clear(wgpu::Color::BLACK);
+                encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                    color_attachments: &[Some(color)],
+                    ..Default::default()
+                });
+                hdr.keep_world(&mut encoder, None);
+                if let Some(view) = hdr.coverage_view() {
+                    super::super::hud_coverage::clear(&mut encoder, &view);
+                    let mut color = super::super::hud_coverage::attachment(&view);
+                    color.ops.load = wgpu::LoadOp::Clear(wgpu::Color::WHITE);
+                    encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                        color_attachments: &[Some(color)],
+                        ..Default::default()
+                    });
+                }
+                let capture = hdr.capture(&device, &queue, &mut encoder, false).unwrap();
+                let buffer = super::super::copy_frame(&device, &mut encoder, &capture, [4, 2]);
+                queue.submit([encoder.finish()]);
+                buffer.map_async(wgpu::MapMode::Read, .., |r| r.unwrap());
+                device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+                let bytes = buffer.get_mapped_range(..).unwrap();
+                let pixel = u32::from_le_bytes(bytes[..4].try_into().unwrap());
+                let [r, g, b] = [0, 10, 20].map(|shift| (pixel >> shift) & 0x3ff);
+                if enabled && debug.is_some() {
+                    // Fully covered: BT.709 magenta at paper white (200 nits here) in BT.2020
+                    // PQ, not PQ's 10 000 nits (1023, 0, 1023).
+                    let near = |got: u32, want: u32| got.abs_diff(want) <= 4;
+                    assert!(near(r, 550) && near(g, 346) && near(b, 583), "{r} {g} {b}");
+                } else {
+                    assert_eq!(pixel, 0xc0000000);
+                }
+                if let Some(view) = hdr.coverage_view() {
+                    let mut encoder = device.create_command_encoder(&Default::default());
+                    super::super::hud_coverage::clear(&mut encoder, &view);
+                    let coverage = hdr.targets.as_ref().unwrap().coverage.as_ref().unwrap();
+                    let buffer = device.create_buffer(&wgpu::BufferDescriptor {
+                        label: None,
+                        size: 512,
+                        usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+                        mapped_at_creation: false,
+                    });
+                    encoder.copy_texture_to_buffer(
+                        coverage.as_image_copy(),
+                        wgpu::TexelCopyBufferInfo {
+                            buffer: &buffer,
+                            layout: wgpu::TexelCopyBufferLayout {
+                                offset: 0,
+                                bytes_per_row: Some(256),
+                                rows_per_image: None,
+                            },
+                        },
+                        coverage.size(),
+                    );
+                    queue.submit([encoder.finish()]);
+                    buffer.map_async(wgpu::MapMode::Read, .., |r| r.unwrap());
+                    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+                    assert_eq!(&buffer.get_mapped_range(..).unwrap()[..4], &[0; 4]);
+                }
+            }
+        }
+    }
+
+    fn gpu() -> Option<(wgpu::Device, wgpu::Queue)> {
+        let instance = crate::gfx::test_gpu::instance();
+        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
+        pollster::block_on(adapter.request_device(&Default::default())).ok()
+    }
+
+    /// Clears all of `texture` to `color`.
+    fn fill(encoder: &mut wgpu::CommandEncoder, texture: &wgpu::Texture, color: [f64; 4]) {
+        let view = texture.create_view(&Default::default());
+        let mut attachment = super::super::hud_coverage::attachment(&view);
+        let [r, g, b, a] = color;
+        attachment.ops.load = wgpu::LoadOp::Clear(wgpu::Color { r, g, b, a });
+        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            color_attachments: &[Some(attachment)],
+            ..Default::default()
+        });
+    }
+
+    /// The first texel of `texture` once `encoder` ran: four half floats, or 10-bit PQ codes
+    /// for HDR10.
+    fn texel(
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        mut encoder: wgpu::CommandEncoder,
+        texture: &wgpu::Texture,
+    ) -> [f32; 4] {
+        let buffer = device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: 256,
+            usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+            mapped_at_creation: false,
+        });
+        encoder.copy_texture_to_buffer(
+            texture.as_image_copy(),
+            wgpu::TexelCopyBufferInfo {
+                buffer: &buffer,
+                layout: wgpu::TexelCopyBufferLayout {
+                    offset: 0,
+                    bytes_per_row: Some(256),
+                    rows_per_image: None,
+                },
+            },
+            wgpu::Extent3d {
+                width: 1,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+        );
+        queue.submit([encoder.finish()]);
+        buffer.map_async(wgpu::MapMode::Read, .., |r| r.unwrap());
+        device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+        let bytes = buffer.get_mapped_range(..).unwrap();
+        if texture.format() == Output::Pq.format() {
+            let pixel = u32::from_le_bytes(bytes[..4].try_into().unwrap());
+            return [0, 10, 20, 30].map(|shift| ((pixel >> shift) & 0x3ff) as f32);
+        }
+        std::array::from_fn(|i| half::f16::from_le_bytes([bytes[2 * i], bytes[2 * i + 1]]).to_f32())
+    }
+
+    #[test]
+    fn the_layered_frame_shows_the_world_as_the_last_pass_lifted_it() {
+        let Some((device, queue)) = gpu() else {
+            return;
+        };
+        // What the last pass shows of a world pixel nothing covers, from today's frame
+        // (`layered` false) or the layered one, whose marks turn into light before it.
+        let shown = |layered: bool, world: [f64; 4]| {
+            let mut hdr =
+                Hdr::with_debug(&device, &queue, F::Rgba16Float, Output::Pq, layered, None);
+            let frame = hdr.frame(&device, [1, 1]);
+            let mut encoder = device.create_command_encoder(&Default::default());
+            fill(&mut encoder, &frame, world);
+            if layered {
+                hdr.begin(&queue, true);
+                hdr.resolve(&mut encoder, None);
+                hdr.keep_world(&mut encoder, None);
+                super::super::hud_coverage::clear(&mut encoder, &hdr.coverage_view().unwrap());
+            } else {
+                hdr.keep_world(&mut encoder, None);
+            }
+            let capture = hdr.capture(&device, &queue, &mut encoder, true).unwrap();
+            texel(&device, &queue, encoder, &capture)
+        };
+        // Unmarked, below white and above it; HDR lighting; light sources of each tier.
+        for world in [
+            [0.5, 0.4, 0.3, 1.0],
+            [1.5, 1.2, 0.6, 1.0],
+            [0.8, 0.7, 0.6, 0.88],
+            [0.9, 0.8, 0.4, 0.05],
+            [0.9, 0.8, 0.4, 0.2],
+            [0.9, 0.8, 0.4, 0.4],
+            [0.9, 0.8, 0.4, 0.6],
+        ] {
+            let (today, layered) = (shown(false, world), shown(true, world));
+            // Half floats round the light apart by a step at most.
+            assert!(
+                today.iter().zip(layered).all(|(a, b)| (a - b).abs() <= 1.0),
+                "{world:?}: {today:?} {layered:?}"
+            );
+            if world[3] < 1.0 {
+                assert!(layered[0] > shown(true, [world[0], world[1], world[2], 1.0])[0]);
+            }
+        }
+    }
+
+    #[test]
+    fn the_hud_lays_over_the_worlds_light_by_its_coverage() {
+        let Some((device, queue)) = gpu() else {
+            return;
+        };
+        let mut hdr = Hdr::with_debug(&device, &queue, F::Rgba16Float, Output::Pq, true, None);
+        let target = device.create_texture(&wgpu::TextureDescriptor {
+            label: None,
+            size: wgpu::Extent3d {
+                width: 1,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: F::Rgba16Float,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+            view_formats: &[],
+        });
+        // The world's light, the HUD's target over it (on the world clipped to white), its
+        // coverage, UI Brightness, and the composite, all in gamma as the frame stores them.
+        for (world, hud, coverage, ui, want) in [
+            // Nothing over it: the world, light above white included.
+            (3.0, 1.0, 0.0, 1.0, 3.0),
+            // Half-transparent black: half of the world shows, as the HUD blends.
+            (2.0, 0.5, 0.5, 1.0, 1.0),
+            // Covered: the HUD as drawn, at UI Brightness.
+            (2.0, 0.3, 1.0, 1.0, 0.3),
+            (2.0, 0.3, 1.0, 0.5, 0.3 * 0.5f32.powf(1.0 / 2.2)),
+            // Added over the world (the text highlight), which it doesn't hide.
+            (0.6, 0.8, 0.0, 1.0, 0.8),
+            // At or below white, at 100%: the HUD's picture as drawn.
+            (0.7, 0.45, 0.5, 1.0, 0.45),
+        ] {
+            hdr.ui = ui;
+            let frame = hdr.frame(&device, [1, 1]);
+            let t = hdr.targets.as_ref().unwrap();
+            let mut encoder = device.create_command_encoder(&Default::default());
+            fill(&mut encoder, &frame, [world, world, world, 1.0]);
+            fill(&mut encoder, t.hud.as_ref().unwrap(), [hud, hud, hud, 0.0]);
+            fill(&mut encoder, t.coverage.as_ref().unwrap(), [coverage; 4]);
+            hdr.begin(&queue, true);
+            hdr.composite(&mut encoder, &target.create_view(&Default::default()), None);
+            let got = texel(&device, &queue, encoder, &target);
+            assert!(
+                (got[0] - want).abs() < 0.01 && got[3] == 1.0,
+                "{world} {hud} {coverage} {ui}: {got:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn the_menu_blur_keeps_the_light_it_blurs() {
+        let Some((device, queue)) = gpu() else {
+            return;
+        };
+        let mut hdr = Hdr::with_debug(&device, &queue, F::Rgba16Float, Output::Pq, true, None);
+        let size = [8, 8];
+        let frame = hdr.frame(&device, size);
+        let mut encoder = device.create_command_encoder(&Default::default());
+        fill(&mut encoder, &frame, [4.0, 4.0, 4.0, 1.0]);
+        hdr.keep_world(&mut encoder, None);
+        super::super::hud_coverage::clear(&mut encoder, &hdr.coverage_view().unwrap());
+        let mut blur = crate::menu_blur::MenuBlur::new(&device, F::Rgba16Float, false);
+        let (_, source) = blur.source(&device, size);
+        hdr.begin(&queue, true);
+        hdr.composite(&mut encoder, &source, None);
+        let view = frame.create_view(&Default::default());
+        blur.blur(&device, &queue, &mut encoder, &view, size, 3.0, None);
+        hdr.keep_world(&mut encoder, None);
+        let hud = hdr.hud().unwrap().clone();
+        // The blurred world keeps its light, and the HUD's backdrop starts again from it.
+        let [r, ..] = texel(&device, &queue, encoder, &frame);
+        assert!((r - 4.0).abs() < 0.01, "{r}");
+        let encoder = device.create_command_encoder(&Default::default());
+        assert_eq!(texel(&device, &queue, encoder, &hud), [1.0, 1.0, 1.0, 0.0]);
+    }
+
    #[test]
    fn hdr_shaders_validate() {
        let entity = crate::overlay::wgsl_constants() + include_str!("../entity.wgsl");
@@ -0,0 +1,335 @@
+//! A held world (`WorldHold`, the native hook `native_world_hold`): the terrain goes on being
+//! drawn as it stands while what changes under it is meshed, and all of it takes its place on
+//! one frame. A section already on screen that is meshed again is uploaded to the arena as ever,
+//! over as many frames as its mesh takes to come, but waits beside the mesh drawn (`Hold`);
+//! letting go only swaps which of the two is drawn, with nothing left to upload. Sections not on
+//! screen yet (terrain streaming in) are not held.
+//!
+//! Both meshes of a waiting section are in memory, so a hold costs up to what the changed land's
+//! new meshes come to. It is bounded, and each bound lets go at once rather than losing anything:
+//! `MAX_BYTES` of waiting meshes, `MAX_HOLD` of time, and the arena running out
+//! (`Renderer::upload`). It never outlives what asked for it: the mods are asked every frame,
+//! and the sections' being cleared (the world left, another dimension) drops what waits. A hold
+//! that ended by itself (spent) stays ended until no mod has asked for a frame.
+use super::SectionKey;
+use crate::fast_hash::{FxHashMap, FxHashSet};
+use std::time::{Duration, Instant};
+
+/// The longest a hold lasts.
+pub(super) const MAX_HOLD: Duration = Duration::from_secs(30);
+/// The most bytes of new meshes that wait.
+pub(super) const MAX_BYTES: u64 = 1 << 30;
+/// The most circles a hold is kept to (`WorldHold::hold_within`).
+pub const MAX_AREAS: usize = 64;
+
+/// What the mods ask of the terrain's picture this frame (`native_world_hold`): nothing, all of
+/// it held, or only the sections inside some circles. Several mods add up: one holding all of it
+/// holds all of it, and circles join.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct WorldHold {
+    all: bool,
+    within: Vec<[f64; 3]>,
+}
+impl WorldHold {
+    /// Hold the whole world's terrain as it is drawn, this frame.
+    pub fn hold(&mut self) {
+        self.all = true;
+    }
+    /// Hold the sections whose middle lies within `radius` blocks of (`x`, `z`), this frame. A
+    /// circle that isn't finite or has a negative radius is left out, as are those past
+    /// `MAX_AREAS`.
+    pub fn hold_within(&mut self, x: f64, z: f64, radius: f64) {
+        let good = x.is_finite() && z.is_finite() && radius.is_finite() && radius >= 0.0;
+        if good && self.within.len() < MAX_AREAS {
+            self.within.push([x, z, radius]);
+        }
+    }
+    /// Whether anything is held.
+    pub fn is_held(&self) -> bool {
+        self.all || !self.within.is_empty()
+    }
+    /// Whether section `key` is in what is held: all of the world, or a circle its middle lies in.
+    pub fn covers(&self, key: SectionKey) -> bool {
+        if self.all {
+            return true;
+        }
+        let (x, z) = (f64::from(key.0) * 16.0 + 8.0, f64::from(key.2) * 16.0 + 8.0);
+        self.within
+            .iter()
+            .any(|&[cx, cz, r]| (x - cx).powi(2) + (z - cz).powi(2) <= r * r)
+    }
+}
+
+/// What a frame's ask means for the sections waiting.
+#[derive(Debug, PartialEq, Eq)]
+pub(super) enum Release {
+    /// They go on waiting.
+    None,
+    /// Those the hold no longer covers take their place.
+    Outside,
+    /// All of them take their place.
+    All,
+}
+
+/// A section waiting behind the hold and the bytes its new mesh takes.
+struct Waiting<S> {
+    section: S,
+    bytes: u64,
+}
+
+/// The renderer's side of a hold: whether it is on, what it covers, and the sections waiting.
+pub(super) struct Hold<S> {
+    ask: WorldHold,
+    since: Option<Instant>,
+    spent: bool,
+    waiting: FxHashMap<SectionKey, Waiting<S>>,
+    bytes: u64,
+}
+impl<S> Default for Hold<S> {
+    fn default() -> Self {
+        Self {
+            ask: WorldHold::default(),
+            since: None,
+            spent: false,
+            waiting: FxHashMap::default(),
+            bytes: 0,
+        }
+    }
+}
+impl<S> Hold<S> {
+    /// Whether a new mesh of section `key` waits.
+    pub fn holds(&self, key: SectionKey) -> bool {
+        self.since.is_some() && !self.spent && self.ask.covers(key)
+    }
+    pub fn is_empty(&self) -> bool {
+        self.waiting.is_empty()
+    }
+    pub fn bytes(&self) -> u64 {
+        self.bytes
+    }
+    /// A frame's ask, at `now`.
+    pub fn ask(&mut self, ask: &WorldHold, now: Instant) -> Release {
+        if !ask.is_held() {
+            let was = self.since.is_some();
+            (self.since, self.spent) = (None, false);
+            self.ask = WorldHold::default();
+            return if was && !self.waiting.is_empty() {
+                Release::All
+            } else {
+                Release::None
+            };
+        }
+        if self.spent {
+            return Release::None;
+        }
+        let since = *self.since.get_or_insert(now);
+        if now.saturating_duration_since(since) >= MAX_HOLD {
+            log::warn!(
+                "Horizon: a mod held the world for {} s: let go",
+                MAX_HOLD.as_secs()
+            );
+            self.spend();
+            return Release::All;
+        }
+        if *ask == self.ask {
+            return Release::None;
+        }
+        // (fewer circles or smaller: some of what waits is let go; more: nothing waits that didn't)
+        self.ask.clone_from(ask);
+        if self.waiting.is_empty() {
+            Release::None
+        } else {
+            Release::Outside
+        }
+    }
+    /// Ended by itself: nothing waits from now on, until no mod has asked for a frame.
+    /// What waited is the caller's to place (`take_all`) or drop.
+    pub fn spend(&mut self) {
+        self.spent = self.since.is_some();
+    }
+    /// Section `key`'s new mesh waits: the one that waited before for it comes back, to free.
+    /// The bool is whether what waits is now too much (`MAX_BYTES`).
+    pub fn wait(&mut self, key: SectionKey, section: S, bytes: u64) -> (Option<S>, bool) {
+        let old = self.take(key);
+        self.bytes += bytes;
+        self.waiting.insert(key, Waiting { section, bytes });
+        (old, self.bytes > MAX_BYTES)
+    }
+    /// Section `key`'s waiting mesh, no longer waiting.
+    pub fn take(&mut self, key: SectionKey) -> Option<S> {
+        if self.waiting.is_empty() {
+            return None;
+        }
+        let w = self.waiting.remove(&key)?;
+        self.bytes -= w.bytes;
+        Some(w.section)
+    }
+    /// Everything waiting, no longer waiting.
+    pub fn take_all(&mut self) -> Vec<(SectionKey, S)> {
+        self.bytes = 0;
+        self.waiting.drain().map(|(k, w)| (k, w.section)).collect()
+    }
+    /// What waits that the hold no longer covers.
+    pub fn take_outside(&mut self) -> Vec<(SectionKey, S)> {
+        let ask = &self.ask;
+        let all = self.since.is_none() || self.spent;
+        let out: Vec<_> = self
+            .waiting
+            .extract_if(|&k, _| all || !ask.covers(k))
+            .collect();
+        self.bytes -= out.iter().map(|(_, w)| w.bytes).sum::<u64>();
+        out.into_iter().map(|(k, w)| (k, w.section)).collect()
+    }
+    /// What waits in these columns, which are going.
+    pub fn take_columns(&mut self, columns: &FxHashSet<(i32, i32)>) -> Vec<S> {
+        if self.waiting.is_empty() {
+            return Vec::new();
+        }
+        let out: Vec<_> = self
+            .waiting
+            .extract_if(|k, _| columns.contains(&(k.0, k.2)))
+            .collect();
+        self.bytes -= out.iter().map(|(_, w)| w.bytes).sum::<u64>();
+        out.into_iter().map(|(_, w)| w.section).collect()
+    }
+    /// The sections are all gone: what waits goes with them and the hold is spent.
+    pub fn clear(&mut self) {
+        self.waiting.clear();
+        self.bytes = 0;
+        self.spend();
+    }
+    pub fn sections(&self) -> impl Iterator<Item = &S> {
+        self.waiting.values().map(|w| &w.section)
+    }
+    pub fn sections_mut(&mut self) -> impl Iterator<Item = &mut S> {
+        self.waiting.values_mut().map(|w| &mut w.section)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn all() -> WorldHold {
+        let mut h = WorldHold::default();
+        h.hold();
+        h
+    }
+    fn within(circles: &[[f64; 3]]) -> WorldHold {
+        let mut h = WorldHold::default();
+        for &[x, z, r] in circles {
+            h.hold_within(x, z, r);
+        }
+        h
+    }
+
+    #[test]
+    fn a_hold_covers_sections_by_their_middle() {
+        assert!(all().covers((900, 0, -900)));
+        assert!(!WorldHold::default().covers((0, 0, 0)));
+        assert!(within(&[[8.0, 8.0, 1.0]]).covers((0, 3, 0)));
+        assert!(!within(&[[0.0, 0.0, 11.0]]).covers((0, 3, 0)));
+        assert!(within(&[[0.0, 0.0, 12.0]]).covers((0, 3, 0)));
+        assert!(within(&[[1000.0, 0.0, 1.0], [24.0, 8.0, 0.5]]).covers((1, 0, 0)));
+        assert!(within(&[[-8.0, -8.0, 0.0]]).covers((-1, 0, -1)));
+    }
+    #[test]
+    fn bad_circles_are_left_out_and_there_are_at_most_max_areas() {
+        let h = within(&[
+            [f64::NAN, 0.0, 5.0],
+            [0.0, f64::INFINITY, 5.0],
+            [0.0, 0.0, -1.0],
+            [0.0, 0.0, f64::INFINITY],
+        ]);
+        assert!(!h.is_held());
+        let mut many = WorldHold::default();
+        for i in 0..MAX_AREAS + 10 {
+            many.hold_within(i as f64 * 100.0, 0.0, 1.0);
+        }
+        assert_eq!(many.within.len(), MAX_AREAS);
+        // (several mods: all of it from one holds all of it)
+        many.hold();
+        assert!(many.covers((-5000, 0, 5000)));
+    }
+    #[test]
+    fn a_hold_starts_and_lets_go_when_no_one_asks() {
+        let (mut g, t) = (Hold::<u32>::default(), Instant::now());
+        assert_eq!(g.ask(&WorldHold::default(), t), Release::None);
+        assert!(!g.holds((0, 0, 0)));
+        assert_eq!(g.ask(&all(), t), Release::None);
+        assert!(g.holds((0, 0, 0)));
+        assert_eq!(g.ask(&all(), t + Duration::from_secs(5)), Release::None);
+        // (nothing waited: nothing to place)
+        assert_eq!(g.ask(&WorldHold::default(), t), Release::None);
+        g.ask(&all(), t);
+        g.wait((0, 0, 0), 7, 100);
+        assert_eq!(g.ask(&WorldHold::default(), t), Release::All);
+        assert_eq!(g.take_all(), vec![((0, 0, 0), 7)]);
+        assert!(!g.holds((0, 0, 0)));
+    }
+    #[test]
+    fn a_hold_ends_by_itself_and_stays_ended_until_let_go() {
+        let (mut g, t) = (Hold::<u32>::default(), Instant::now());
+        g.ask(&all(), t);
+        assert_eq!(g.ask(&all(), t + MAX_HOLD), Release::All);
+        assert!(!g.holds((0, 0, 0)));
+        assert_eq!(g.ask(&all(), t + MAX_HOLD * 2), Release::None);
+        assert!(!g.holds((0, 0, 0)));
+        g.ask(&WorldHold::default(), t + MAX_HOLD * 2);
+        g.ask(&all(), t + MAX_HOLD * 3);
+        assert!(g.holds((0, 0, 0)));
+    }
+    #[test]
+    fn smaller_circles_let_go_what_they_leave() {
+        let (mut g, t) = (Hold::<u32>::default(), Instant::now());
+        g.ask(&within(&[[0.0, 0.0, 100.0]]), t);
+        assert!(g.holds((0, 0, 0)) && g.holds((5, 0, 0)) && !g.holds((7, 0, 0)));
+        g.wait((0, 0, 0), 1, 10);
+        g.wait((5, 0, 0), 2, 20);
+        assert_eq!(g.ask(&within(&[[0.0, 0.0, 100.0]]), t), Release::None);
+        assert_eq!(g.ask(&within(&[[0.0, 0.0, 40.0]]), t), Release::Outside);
+        assert_eq!(g.take_outside(), vec![((5, 0, 0), 2)]);
+        assert_eq!((g.sections().count(), g.bytes()), (1, 10));
+        assert!(!g.holds((5, 0, 0)));
+        // (to all of it again: nothing more is let go, and all of it waits again)
+        assert_eq!(g.ask(&all(), t), Release::Outside);
+        assert!(g.take_outside().is_empty());
+        assert!(g.holds((5, 0, 0)));
+    }
+    #[test]
+    fn what_waits_is_counted_and_capped() {
+        let (mut g, t) = (Hold::<u32>::default(), Instant::now());
+        g.ask(&all(), t);
+        assert_eq!(g.wait((0, 0, 0), 1, MAX_BYTES - 10), (None, false));
+        // (a newer mesh of the same section replaces it, and the old one comes back to free)
+        assert_eq!(g.wait((0, 0, 0), 2, MAX_BYTES - 20), (Some(1), false));
+        assert_eq!(g.bytes(), MAX_BYTES - 20);
+        assert_eq!(g.wait((1, 0, 0), 3, 20), (None, false));
+        assert_eq!(g.wait((2, 0, 0), 4, 1), (None, true));
+        assert_eq!(g.take((1, 0, 0)), Some(3));
+        assert_eq!(g.take((1, 0, 0)), None);
+        assert_eq!(g.bytes(), MAX_BYTES - 19);
+    }
+    #[test]
+    fn columns_going_and_the_sections_cleared_drop_what_waits() {
+        let (mut g, t) = (Hold::<u32>::default(), Instant::now());
+        g.ask(&all(), t);
+        g.wait((0, 0, 0), 1, 10);
+        g.wait((0, 5, 0), 2, 10);
+        g.wait((3, 0, 0), 3, 10);
+        let gone: FxHashSet<(i32, i32)> = [(0, 0)].into_iter().collect();
+        let mut dropped = g.take_columns(&gone);
+        dropped.sort_unstable();
+        assert_eq!(dropped, vec![1, 2]);
+        assert_eq!((g.sections().count(), g.bytes()), (1, 10));
+        g.clear();
+        assert!(g.is_empty() && g.bytes() == 0 && !g.holds((3, 0, 0)));
+        // (cleared while held: spent until let go; with no hold, nothing to end)
+        assert_eq!(g.ask(&all(), t), Release::None);
+        assert!(!g.holds((3, 0, 0)));
+        let mut none = Hold::<u32>::default();
+        none.clear();
+        none.ask(&all(), t);
+        assert!(none.holds((3, 0, 0)));
+    }
+}
@@ -0,0 +1,485 @@
+//! HUD coverage beside its unchanged colour and alpha, only on the float HDR lane.
+
+pub(crate) const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::R8Unorm;
+
+pub(crate) fn supported(
+    lane: (bool, bool, bool),
+    hdr_offered: bool,
+    attachments: u32,
+    flags: wgpu::DownlevelFlags,
+    format: wgpu::TextureFormatFeatures,
+) -> bool {
+    !lane.0
+        && lane.1
+        && lane.2
+        && hdr_offered
+        && attachments >= 2
+        && flags.contains(wgpu::DownlevelFlags::INDEPENDENT_BLEND)
+        && format
+            .allowed_usages
+            .contains(wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING)
+        && format
+            .flags
+            .contains(wgpu::TextureFormatFeatureFlags::BLENDABLE)
+}
+
+pub(crate) fn attachment(view: &wgpu::TextureView) -> wgpu::RenderPassColorAttachment<'_> {
+    wgpu::RenderPassColorAttachment {
+        view,
+        resolve_target: None,
+        depth_slice: None,
+        ops: wgpu::Operations {
+            load: wgpu::LoadOp::Load,
+            store: wgpu::StoreOp::Store,
+        },
+    }
+}
+
+pub(crate) fn clear(encoder: &mut wgpu::CommandEncoder, view: &wgpu::TextureView) {
+    let mut color = attachment(view);
+    color.ops.load = wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT);
+    encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+        label: Some("HUD coverage reset"),
+        color_attachments: &[Some(color)],
+        ..Default::default()
+    });
+}
+
+pub(crate) struct Pipeline {
+    plain: wgpu::RenderPipeline,
+    coverage: Option<wgpu::RenderPipeline>,
+}
+
+impl Pipeline {
+    /// `None` when `enabled` and the shader can't be given a coverage output (a resource
+    /// pack's, which the caller then doesn't use).
+    pub(crate) fn new(
+        device: &wgpu::Device,
+        desc: &wgpu::RenderPipelineDescriptor<'_>,
+        source: wgpu::ShaderSource<'_>,
+        enabled: bool,
+    ) -> Option<Self> {
+        let coverage = if enabled {
+            Some(pipeline(device, desc, source)?)
+        } else {
+            None
+        };
+        Some(Self {
+            plain: device.create_render_pipeline(desc),
+            coverage,
+        })
+    }
+
+    pub(crate) fn get(&self, coverage: bool) -> &wgpu::RenderPipeline {
+        if coverage {
+            self.coverage.as_ref().expect("HUD coverage pipeline")
+        } else {
+            &self.plain
+        }
+    }
+}
+
+/// Keep the primary output and all its blend factors, including destination alpha. Wrap the
+/// final shader result, so pack text's alpha, early returns and discard all apply to coverage.
+/// `None` for a fragment shader without a colour output at location 0.
+pub(super) fn pipeline(
+    device: &wgpu::Device,
+    desc: &wgpu::RenderPipelineDescriptor<'_>,
+    source: wgpu::ShaderSource<'_>,
+) -> Option<wgpu::RenderPipeline> {
+    let mut desc = desc.clone();
+    let fragment = desc.fragment.as_mut()?;
+    let mut module = match source {
+        wgpu::ShaderSource::Wgsl(s) => naga::front::wgsl::parse_str(&s).ok()?,
+        wgpu::ShaderSource::Naga(m) => m.into_owned(),
+        _ => return None,
+    };
+    let primary = fragment.targets.first()?.clone()?;
+    let blend = primary.blend.unwrap_or(wgpu::BlendState::REPLACE).color;
+    let additive = matches!(
+        (blend.src_factor, blend.dst_factor),
+        (
+            wgpu::BlendFactor::One
+                | wgpu::BlendFactor::Src
+                | wgpu::BlendFactor::SrcAlpha
+                | wgpu::BlendFactor::Zero,
+            wgpu::BlendFactor::One
+        )
+    ) && blend.operation == wgpu::BlendOperation::Add;
+    wrap(&mut module, fragment.entry_point?, blend)?;
+    let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+        label: desc.label,
+        source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)),
+    });
+    let over = wgpu::BlendComponent {
+        src_factor: wgpu::BlendFactor::One,
+        dst_factor: wgpu::BlendFactor::OneMinusSrc,
+        operation: wgpu::BlendOperation::Add,
+    };
+    let targets = [
+        Some(primary),
+        Some(wgpu::ColorTargetState {
+            format: FORMAT,
+            blend: Some(wgpu::BlendState {
+                color: over,
+                alpha: over,
+            }),
+            write_mask: if additive {
+                wgpu::ColorWrites::empty()
+            } else {
+                wgpu::ColorWrites::RED
+            },
+        }),
+    ];
+    fragment.module = &shader;
+    fragment.targets = &targets;
+    Some(device.create_render_pipeline(&desc))
+}
+
+fn wrap(module: &mut naga::Module, name: &str, blend: wgpu::BlendComponent) -> Option<()> {
+    use naga::{Expression as E, Statement as S, TypeInner as T};
+    use wgpu::BlendFactor as B;
+    let span = naga::Span::UNDEFINED;
+    let entry = module.entry_points.iter_mut().find(|e| e.name == name)?;
+    // Checked before anything is taken apart: a resource pack's shader may have no colour.
+    let result = entry.function.result.clone()?;
+    if let T::Struct { members, .. } = &module.types[result.ty].inner {
+        members
+            .iter()
+            .find(|m| matches!(m.binding, Some(naga::Binding::Location { location: 0, .. })))?;
+    } else if !matches!(
+        result.binding,
+        Some(naga::Binding::Location { location: 0, .. })
+    ) {
+        return None;
+    }
+    let mut original = std::mem::take(&mut entry.function);
+    entry.function.arguments = original.arguments.clone();
+    for arg in &mut original.arguments {
+        arg.binding = None;
+    }
+    original.result.as_mut().unwrap().binding = None;
+    original.name = Some("hud_color".into());
+    let function = module.functions.append(original, span);
+    let f = &mut entry.function;
+    let args = (0..f.arguments.len())
+        .map(|i| f.expressions.append(E::FunctionArgument(i as u32), span))
+        .collect();
+    let call = f.expressions.append(E::CallResult(function), span);
+    f.body.push(
+        S::Call {
+            function,
+            arguments: args,
+            result: Some(call),
+        },
+        span,
+    );
+    let one = f
+        .expressions
+        .append(E::Literal(naga::Literal::F32(1.0)), span);
+    let start = f.expressions.len();
+    let (mut members, mut values, color, offset) = match &module.types[result.ty].inner {
+        T::Struct {
+            members,
+            span: size,
+        } => {
+            // HUD pipelines have one target, so a pack's other colour outputs went nowhere;
+            // left in, one at location 1 would collide with the coverage.
+            let (members, values): (Vec<_>, Vec<_>) = members
+                .iter()
+                .enumerate()
+                .filter(|(_, m)| {
+                    !matches!(m.binding, Some(naga::Binding::Location { location, .. }) if location != 0)
+                })
+                .map(|(i, m)| {
+                    let value = f.expressions.append(
+                        E::AccessIndex {
+                            base: call,
+                            index: i as u32,
+                        },
+                        span,
+                    );
+                    (m.clone(), value)
+                })
+                .unzip();
+            let color = members
+                .iter()
+                .position(|m| {
+                    matches!(m.binding, Some(naga::Binding::Location { location: 0, .. }))
+                })
+                .unwrap();
+            let color = values[color];
+            (members, values, color, *size)
+        }
+        _ => (
+            vec![naga::StructMember {
+                name: Some("color".into()),
+                ty: result.ty,
+                binding: result.binding,
+                offset: 0,
+            }],
+            vec![call],
+            call,
+            16,
+        ),
+    };
+    let mut component = |index| {
+        f.expressions
+            .append(E::AccessIndex { base: color, index }, span)
+    };
+    let [r, g, b, a] = [component(0), component(1), component(2), component(3)];
+    let mut math = |fun, arg, arg1| {
+        f.expressions.append(
+            E::Math {
+                fun,
+                arg,
+                arg1: Some(arg1),
+                arg2: None,
+                arg3: None,
+            },
+            span,
+        )
+    };
+    let low = math(naga::MathFunction::Min, r, g);
+    let low = math(naga::MathFunction::Min, low, b);
+    let high = math(naga::MathFunction::Max, r, g);
+    let high = math(naga::MathFunction::Max, high, b);
+    // A scalar cannot reproduce RGB-dependent replacement or inversion: surviving pixels
+    // cover fully, so the later composite cannot leak world light through them.
+    let c = if blend.operation != wgpu::BlendOperation::Add {
+        one
+    } else {
+        match (blend.src_factor, blend.dst_factor) {
+            (B::SrcAlpha | B::One, B::OneMinusSrcAlpha) => a,
+            (B::Zero, B::OneMinusSrc) => high,
+            // Multiplying retains src.rgb (or 1 - alpha + src.rgb) of the backdrop.
+            // Use the greatest channel darkening, as for the credits vignette above.
+            (B::Zero, B::Src)
+            | (B::Dst, B::Zero)
+            | (B::Dst, B::OneMinusSrcAlpha)
+            | (B::Dst, B::Src) => {
+                let top = if blend.dst_factor == B::OneMinusSrcAlpha {
+                    a
+                } else {
+                    one
+                };
+                let factor = if blend.dst_factor == B::Src && blend.src_factor == B::Dst {
+                    f.expressions.append(
+                        E::Binary {
+                            op: naga::BinaryOperator::Add,
+                            left: low,
+                            right: low,
+                        },
+                        span,
+                    )
+                } else {
+                    low
+                };
+                f.expressions.append(
+                    E::Binary {
+                        op: naga::BinaryOperator::Subtract,
+                        left: top,
+                        right: factor,
+                    },
+                    span,
+                )
+            }
+            _ => one,
+        }
+    };
+    let c = f.expressions.append(
+        E::Math {
+            fun: naga::MathFunction::Saturate,
+            arg: c,
+            arg1: None,
+            arg2: None,
+            arg3: None,
+        },
+        span,
+    );
+    let scalar = module.types.insert(
+        naga::Type {
+            name: None,
+            inner: T::Scalar(naga::Scalar::F32),
+        },
+        span,
+    );
+    members.push(naga::StructMember {
+        name: Some("coverage".into()),
+        ty: scalar,
+        binding: Some(naga::Binding::Location {
+            location: 1,
+            interpolation: None,
+            sampling: None,
+            blend_src: None,
+            per_primitive: false,
+        }),
+        offset,
+    });
+    let ty = module.types.insert(
+        naga::Type {
+            name: Some("HudCoverage".into()),
+            inner: T::Struct {
+                members,
+                span: (offset + 4).next_multiple_of(16),
+            },
+        },
+        span,
+    );
+    values.push(c);
+    let value = f.expressions.append(
+        E::Compose {
+            ty,
+            components: values,
+        },
+        span,
+    );
+    f.result = Some(naga::FunctionResult { ty, binding: None });
+    f.body.push(S::Emit(f.expressions.range_from(start)), span);
+    f.body.push(S::Return { value: Some(value) }, span);
+    Some(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn coverage_requires_the_no_pack_float_hdr_lane_and_independent_r8_blending() {
+        let flags = wgpu::DownlevelFlags::INDEPENDENT_BLEND;
+        let format = wgpu::TextureFormatFeatures {
+            allowed_usages: wgpu::TextureUsages::RENDER_ATTACHMENT
+                | wgpu::TextureUsages::TEXTURE_BINDING,
+            flags: wgpu::TextureFormatFeatureFlags::BLENDABLE,
+        };
+        let lane = (false, true, true);
+        assert!(supported(lane, true, 2, flags, format));
+        // Switch unset (including legacy 16-bit HDR and 0.1 packs), HDR off, a 0.2
+        // pack's float frame, and unsupported devices never allocate coverage.
+        for other in [
+            (false, false, true),
+            (true, false, true),
+            (true, true, true),
+            (false, true, false),
+        ] {
+            assert!(!supported(other, true, 2, flags, format));
+        }
+        assert!(!supported(lane, false, 2, flags, format));
+        assert!(!supported(lane, true, 1, flags, format));
+        assert!(!supported(
+            lane,
+            true,
+            2,
+            wgpu::DownlevelFlags::empty(),
+            format
+        ));
+        assert!(!supported(
+            lane,
+            true,
+            2,
+            flags,
+            wgpu::TextureFormatFeatures {
+                flags: wgpu::TextureFormatFeatureFlags::empty(),
+                ..format
+            }
+        ));
+        assert!(!supported(
+            lane,
+            true,
+            2,
+            flags,
+            wgpu::TextureFormatFeatures {
+                allowed_usages: wgpu::TextureUsages::TEXTURE_BINDING,
+                ..format
+            }
+        ));
+    }
+
+    #[test]
+    fn disabled_coverage_builds_only_the_original_pipeline() {
+        let instance = crate::gfx::test_gpu::instance();
+        let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
+            return;
+        };
+        let Ok((device, _)) = pollster::block_on(adapter.request_device(&Default::default()))
+        else {
+            return;
+        };
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Wgsl(
+                "@vertex fn vs() -> @builtin(position) vec4<f32> { return vec4(0.0); }".into(),
+            ),
+        });
+        let desc = wgpu::RenderPipelineDescriptor {
+            label: None,
+            layout: None,
+            vertex: wgpu::VertexState {
+                module: &shader,
+                entry_point: Some("vs"),
+                compilation_options: Default::default(),
+                buffers: &[],
+            },
+            primitive: Default::default(),
+            depth_stencil: Some(wgpu::DepthStencilState {
+                format: wgpu::TextureFormat::Depth32Float,
+                depth_write_enabled: Some(true),
+                depth_compare: Some(wgpu::CompareFunction::Always),
+                stencil: Default::default(),
+                bias: Default::default(),
+            }),
+            multisample: Default::default(),
+            fragment: None,
+            multiview_mask: None,
+            cache: None,
+        };
+        // The coverage source must not even be parsed outside the lane.
+        let pipeline = Pipeline::new(
+            &device,
+            &desc,
+            wgpu::ShaderSource::Wgsl("invalid".into()),
+            false,
+        )
+        .unwrap();
+        assert!(pipeline.coverage.is_none());
+    }
+
+    #[test]
+    fn coverage_wraps_the_debug_crosshair_without_changing_world_entry_points() {
+        let mut module = naga::front::wgsl::parse_str(include_str!("../terrain.wgsl")).unwrap();
+        wrap(
+            &mut module,
+            "fs_debug_line",
+            wgpu::BlendState::ALPHA_BLENDING.color,
+        )
+        .unwrap();
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::all(),
+        )
+        .validate(&module)
+        .unwrap();
+    }
+
+    #[test]
+    fn coverage_replaces_a_colour_output_the_hud_has_no_target_for() {
+        let mut module = naga::front::wgsl::parse_str(
+            "struct Out { @location(0) color: vec4<f32>, @location(1) unused: vec4<f32> }
+             @fragment fn fs() -> Out { return Out(vec4(0.5), vec4(1.0)); }",
+        )
+        .unwrap();
+        wrap(&mut module, "fs", wgpu::BlendState::ALPHA_BLENDING.color).unwrap();
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::all(),
+        )
+        .validate(&module)
+        .unwrap();
+        let result = module.entry_points[0].function.result.as_ref().unwrap();
+        let naga::TypeInner::Struct { members, .. } = &module.types[result.ty].inner else {
+            panic!("the wrapped entry returns a struct");
+        };
+        let names: Vec<_> = members.iter().map(|m| m.name.as_deref().unwrap()).collect();
+        assert_eq!(names, ["color", "coverage"]);
+    }
+}
@@ -49,9 +49,23 @@ struct HorizonMaterialOut {
    @location(14) @interpolate(flat) normal: vec3<f32>,
 }
 fn horizon_material_vertex(position: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f32>,
-    light: vec2<u32>, origin: vec3<f32>) -> HorizonMaterialOut {
-    let pos = horizon_material_displace(position + origin, uv, layer, color, light);
-    return horizon_material_out(pos, uv, layer, color, vec2<f32>(light));
+    light: vec2<u32>, origin: vec4<f32>) -> HorizonMaterialOut {
+    let pos = horizon_material_displace(position + origin.xyz, uv, layer, color, light);
+    var out = horizon_material_out(pos, uv, layer, color, vec2<f32>(light));
+    // The section's fade-in (`RenderSection.getVisibility`), as how far it is from whole, in the
+    // high 16 bits of `hdr_code`: no varying of its own, and 0 (whole) where nothing fades. It is
+    // the same for the whole section, so the flat varying loses nothing.
+    let instance = horizon_terrain_instance_visibility(origin.w);
+    out.hdr_code |= u32(round((1.0 - instance) * 65535.0)) << 16u;
+    return out;
+}
+// terrain.wgsl's fade-in (terrain.vsh's chunkVisibility): whole within 16 blocks, the section's
+// own visibility from 32 out, toward the fog colour, alpha kept. The distance blend runs here on
+// the interpolated distance, as vanilla's interpolated `visibility`, not once per triangle.
+fn horizon_material_faded(in: HorizonMaterialOut, color: vec4<f32>) -> vec4<f32> {
+    let instance = 1.0 - f32(in.hdr_code >> 16u) / 65535.0;
+    let visibility = mix(1.0, instance, clamp((in.spherical - 16.0) / 16.0, 0.0, 1.0));
+    return vec4(mix(horizon_terrain_globals.fog_color.rgb, color.rgb, visibility), color.a);
 }
 // `light`: sky, block, 16 per level.
 fn horizon_material_out(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f32>,
@@ -94,7 +108,7 @@ fn horizon_material_out(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f
    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec2<u32>,
    @location(5) origin: vec4<f32>) -> HorizonMaterialOut {
    return horizon_material_vertex(position, horizon_terrain_terrain_uv(uv, origin.w), layer,
-        color, light, origin.xyz);
+        color, light, origin);
 }
@vertex fn horizon_material_vs_flat(
    @builtin(vertex_index) vertex: u32,
@@ -103,7 +117,7 @@ fn horizon_material_out(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f
 ) -> HorizonMaterialOut {
    let origin = horizon_terrain_slot_origins[horizon_terrain_block_slots[vertex >> 8u]];
    return horizon_material_vertex(position, horizon_terrain_terrain_uv(uv, origin.w), layer,
-        color, light, origin.xyz);
+        color, light, origin);
 }
 // The prelude's `block_normal_map` and `block_specular_map`: the resource packs' LabPBR maps
 // in the pack's frame group (3), one array each, a blank 1x1 without them.
@@ -181,9 +195,10 @@ struct HorizonMaterialSolid {
 // What `fs_solid` leaves in the frame's alpha for HDR output, from the sprite before the pack's
 // material: the pack decides the colour, Horizon still knows which pixels are light sources.
 fn horizon_material_mark(in: HorizonMaterialOut, texel: vec4<f32>) -> f32 {
-    if in.hdr_code > 0u {
-        let whole = in.hdr_code > 4u;
-        let tier = select(in.hdr_code, in.hdr_code - 4u, whole);
+    let code = in.hdr_code & 15u;
+    if code > 0u {
+        let whole = code > 4u;
+        let tier = select(code, code - 4u, whole);
        let l = in.layer & 0x7fffu;
        let t = textureLoad(horizon_terrain_emission_thresholds,
            vec2(i32(l % horizon_terrain_SPRITE_SPLIT), i32(l / horizon_terrain_SPRITE_SPLIT)), 0);
@@ -202,7 +217,7 @@ fn horizon_material_mark(in: HorizonMaterialOut, texel: vec4<f32>) -> f32 {
    return horizon_material_solid(in);
 }
 fn horizon_material_solid(in: HorizonMaterialOut) -> HorizonMaterialSolid {
-    let color = horizon_material_color(in, false);
+    let color = horizon_material_faded(in, horizon_material_color(in, false));
    let texel = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu);
    // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout.
    if color.a < 0.5 && (in.layer & 0x8000u) == 0u { discard; }
@@ -216,7 +231,7 @@ fn horizon_material_solid(in: HorizonMaterialOut) -> HorizonMaterialSolid {
    return out;
 }
@fragment fn horizon_material_fs_translucent(in: HorizonMaterialOut) -> @location(0) vec4<f32> {
-    let color = horizon_material_color(in, true);
+    let color = horizon_material_faded(in, horizon_material_color(in, true));
    if color.a < 0.01 { discard; }
    return horizon_material_fogged(color, in.spherical, in.cylindrical);
 }
@@ -582,6 +597,25 @@ mod tests {
        report.stages.remove(0)
    }

+    /// The fade-in packed above the HDR code: a section a quarter visible (`section_instance`
+    /// with step 1: mantissa `1 - visibility` = 0.75) keeps its visibility through the code, and
+    /// a fragment 24 blocks away, half-way into the 16-block blend, is 1 - (1 - 0.25) / 2 = 0.625
+    /// visible; the code's low nibble survives.
+    #[test]
+    fn the_fade_in_rides_the_hdr_code() {
+        let w = f32::from_bits(1.0f32.to_bits() | (0.75 * 8_388_608.0) as u32);
+        // `horizon_material_vertex`.
+        let instance = 1.0 - (w.to_bits() & 0x7fffff) as f32 / 8_388_608.0;
+        let code = 7u32 | (((1.0 - instance) * 65535.0).round() as u32) << 16;
+        // `horizon_material_faded` and `horizon_material_mark`.
+        let unpacked = 1.0 - (code >> 16) as f32 / 65535.0;
+        assert!((unpacked - 0.25).abs() < 1.0 / 65535.0);
+        let blend = ((24.0f32 - 16.0) / 16.0).clamp(0.0, 1.0);
+        let visibility = 1.0 + (unpacked - 1.0) * blend;
+        assert!((visibility - 0.625).abs() < 1.0 / 65535.0);
+        assert_eq!(code & 15, 7);
+    }
+
    #[test]
    fn the_terrain_takes_a_prefix_and_validates_with_a_pack() {
        let terrain = vanilla_terrain();
@@ -90,6 +90,27 @@ impl NativePack {
        report: Report,
        constants: &[(String, f64)],
        lights: super::block_light::LightTable,
+    ) -> Result<(Self, Vec<String>), String> {
+        // A backend may refuse a layout or pipeline the pack asks for (a stage's bindings
+        // past its sampled-texture limit, say, as OpenGL's 16 was before #10095): the pack
+        // is refused with that error instead of a validation panic in the renderer.
+        let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
+        let built = Self::build(device, queue, terrain, report, constants, lights);
+        let refused = pollster::block_on(scope.pop());
+        match (built, refused) {
+            (Ok(built), None) => Ok(built),
+            (Ok(_), Some(e)) => Err(e.to_string()),
+            (Err(e), _) => Err(e),
+        }
+    }
+
+    fn build(
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        terrain: &TerrainShape<'_>,
+        report: Report,
+        constants: &[(String, f64)],
+        lights: super::block_light::LightTable,
    ) -> Result<(Self, Vec<String>), String> {
        let (globals, format) = (terrain.globals, terrain.format);
        let textures = super::native_post::pack_textures(device, queue, &report);
@@ -278,9 +299,90 @@ impl NativePack {

 #[cfg(test)]
 mod tests {
-    use super::chosen_shadow;
+    use super::{NativePack, TerrainShape, chosen_shadow};
    use horizon_shader_api::manifest::{OptionKind, PackOption, Shadow};

+    /// A device with OpenGL's minimum 16 sampled textures per stage refuses a pack whose
+    /// sky adds the terrain's 10 to the frame's 9: that is the pack's error to report, not
+    /// a validation panic (#10095).
+    #[test]
+    fn a_pack_the_backend_refuses_is_an_error_not_a_panic() {
+        use horizon_shader_api::{MANIFEST, Pack, check};
+        let instance = crate::gfx::test_gpu::instance();
+        let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
+            return;
+        };
+        let mut limits = adapter.limits();
+        limits.max_sampled_textures_per_shader_stage = 16;
+        let Ok((device, queue)) =
+            pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
+                required_limits: limits,
+                ..Default::default()
+            }))
+        else {
+            return;
+        };
+        // The terrain's group 0: its uniform and the 10 sampled textures (_terrain.wgsl_'s
+        // 8 sprite arrays, the lightmap and the emission thresholds).
+        let entry = |binding, ty| wgpu::BindGroupLayoutEntry {
+            binding,
+            visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
+            ty,
+            count: None,
+        };
+        let mut entries = vec![entry(
+            0,
+            wgpu::BindingType::Buffer {
+                ty: wgpu::BufferBindingType::Uniform,
+                has_dynamic_offset: false,
+                min_binding_size: None,
+            },
+        )];
+        entries.extend((1..=10).map(|binding| {
+            entry(
+                binding,
+                wgpu::BindingType::Texture {
+                    sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                    view_dimension: wgpu::TextureViewDimension::D2,
+                    multisampled: false,
+                },
+            )
+        }));
+        let globals = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: None,
+            entries: &entries,
+        });
+        let empty = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: None,
+            entries: &[],
+        });
+        let terrain = TerrainShape {
+            globals: &globals,
+            flat: None,
+            sprites: [1.0, 2048.0],
+            format: wgpu::TextureFormat::Rgba8Unorm,
+            sprite_tags: &[],
+            sprite_materials: &[],
+            entities: &empty,
+            weather_groups: [&empty, &empty],
+            pbr: None,
+        };
+        let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\
+            [sky]\nfile = \"sky.wgsl\"\n";
+        let files = [
+            (MANIFEST, manifest),
+            (
+                "sky.wgsl",
+                "fn sky(input: SkyInput) -> vec4<f32> { return input.color; }\n",
+            ),
+        ]
+        .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec()))
+        .into();
+        let report = check(&Pack::from_files(files).unwrap()).unwrap();
+        let built = NativePack::new(&device, &queue, &terrain, report, &[], Default::default());
+        assert!(built.is_err(), "the pack should be refused");
+    }
+
    fn option(id: &str, kind: OptionKind) -> PackOption {
        PackOption {
            id: id.into(),
@@ -73,10 +73,15 @@ pub struct WorldDrawn<'a> {
    pub entities: &'a [Vertex],
    pub spans: &'a [EntitySpan],
    /// Which entity each run of `entities` is, recorded every frame (`Frame::entity_motion`):
-    /// the run's first vertex and the entity, `(1 << 32) | id` for a mob or a player and
-    /// `(2 << 32) | id` for a dropped item (their entity ids), 0 for anything else. A run lasts
-    /// until the next. Unlike `spans`, whose ids name a type, these follow one entity from
-    /// frame to frame (API 371).
+    /// the run's first vertex and the entity, `(1 << 32) | id` for a mob or a player,
+    /// `(2 << 32) | id` for a dropped item, `(3 << 32) | id` for another entity (boat,
+    /// minecart, armor stand, item frame, painting, primed TNT, falling block) and
+    /// `(4 << 32) | id` for an item frame's held item (their entity ids), `(5 << 32) | p` for a
+    /// block entity (`p`: its position, x and z in 11 bits each, y in 10), `(6 << 32) | p`
+    /// for a block a piston moves (`p`: the cell it moves to), `7 << 32` for the player's own
+    /// model, 0 for anything else.
+    /// A run lasts until the next. Unlike `spans`, whose ids name a type, these follow one
+    /// entity from frame to frame (API 371).
    pub motion: &'a [(u32, u64)],
    /// The shared atlas entity UVs point into.
    pub atlas: Option<&'a wgpu::Texture>,
@@ -728,6 +728,13 @@ impl PackAtlas {
            ),
            ("mc_Entity", entity),
            ("at_midBlock", mid_block),
+            // Horizon's own: the face's HDR tier (`mesher::emitting`'s code in the colour's low
+            // alpha nibble): 0 for none, 1 to 4 for low to very bright, plus 4 when the whole
+            // face shines (`mesher::WHOLE`).
+            (
+                "horizonTier",
+                "float(15u - (uint(round(hz_v_color.a * 255.0)) & 15u))",
+            ),
            (
                "mc_midTexCoord",
                "vec4((hz_cell + hz_mid) * hz_scale, 0.0, 1.0)",
@@ -750,6 +757,7 @@ impl PackAtlas {
            alpha_test: None,
            item_id_declared: false,
            far_depth: false,
+            paged_maps: false,
        }
    }
 }
@@ -157,6 +157,7 @@ fn terrain_fade_reaches_pack_pixels_through_real_instances() {
                            flat,
                            geometry,
                            origin,
+                            0x80ffffff,
                        );
                        let fade = if requested { expected } else { 1.0 };
                        let expected = [
@@ -182,6 +183,96 @@ fn terrain_fade_reaches_pack_pixels_through_real_instances() {
    assert_eq!(count, 98);
 }

+/// `horizonTier`: the HDR tier the mesher marks a light source's faces with (`mesher::emitting`),
+/// read by a pack's terrain program, flat or instanced.
+#[test]
+fn terrain_tier_reaches_pack_pixels() {
+    let instance = crate::gfx::test_gpu::instance();
+    let adapter = match pollster::block_on(instance.request_adapter(&Default::default())) {
+        Ok(adapter) => adapter,
+        Err(error) => {
+            eprintln!("SKIP terrain tier GPU control: no adapter: {error}");
+            return;
+        }
+    };
+    let (device, queue) = pollster::block_on(adapter.request_device(&Default::default())).unwrap();
+    let array = device.create_texture(&wgpu::TextureDescriptor {
+        label: None,
+        size: wgpu::Extent3d {
+            width: 2,
+            height: 2,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba8Unorm,
+        usage: wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::TEXTURE_BINDING,
+        view_formats: &[],
+    });
+    let mut encoder = device.create_command_encoder(&Default::default());
+    let atlas = PackAtlas::new(&device, &mut encoder, &[array], 1, 1, 2).unwrap();
+    queue.submit([encoder.finish()]);
+    let folder = ProbePack(
+        std::env::temp_dir().join(format!("horizon-terrain-tier-{}", std::process::id())),
+    );
+    std::fs::create_dir_all(folder.0.join("shaders")).unwrap();
+    std::fs::write(
+        folder.0.join("shaders/gbuffers_terrain.vsh"),
+        "#version 330\nin float horizonTier;\nout vec4 observation;\n\
+         void main() {\nobservation = vec4(horizonTier, 0.0, 0.0, 0.0);\n\
+         gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n}",
+    )
+    .unwrap();
+    std::fs::write(
+        folder.0.join("shaders/gbuffers_terrain.fsh"),
+        "#version 330\nin vec4 observation;\nlayout(location = 0) out uvec4 pixel;\n\
+         void main() { pixel = floatBitsToUint(observation); }",
+    )
+    .unwrap();
+    let pack = horizon_shaders::Pack::open(&folder.0).unwrap();
+    let mut macros = horizon_shaders::Macros::standard();
+    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
+    use crate::mesher::{BRIGHT, LOW, VERY_BRIGHT, WHOLE, emitting};
+    // No light, low, very bright, and bright all over (4 more).
+    let cases = [
+        (0, 0.0),
+        (LOW, 1.0),
+        (VERY_BRIGHT, 4.0),
+        (BRIGHT | WHOLE, 7.0),
+    ];
+    for flat in [false, true] {
+        let post = horizon_shaders::load_post(
+            &pack,
+            "",
+            &properties,
+            &macros,
+            &horizon_shaders::GameInputs {
+                terrain: Some(atlas.terrain_inputs(flat)),
+                ..Default::default()
+            },
+        );
+        let program = post
+            .terrain
+            .as_ref()
+            .unwrap_or_else(|| panic!("{:?}", post.notes));
+        for (tier, expected) in cases {
+            let origin = section_instance([0.0; 3], 0, 1.0);
+            let pixel = sample(
+                &device,
+                &queue,
+                &atlas,
+                program.program.as_ref().unwrap(),
+                flat,
+                false,
+                origin,
+                emitting(0xffff_ffff, tier),
+            );
+            assert_eq!(pixel[0], expected, "tier {tier} flat={flat}");
+        }
+    }
+}
+
 fn sample(
    device: &wgpu::Device,
    queue: &wgpu::Queue,
@@ -190,6 +281,7 @@ fn sample(
    flat: bool,
    geometry: bool,
    origin: [f32; 4],
+    color: u32,
 ) -> [f32; 4] {
    let buffer = |bytes: &[u8], usage| {
        device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
@@ -209,7 +301,7 @@ fn sample(
    let slots = buffer(bytemuck::bytes_of(&0u32), wgpu::BufferUsages::STORAGE);
    let vertices: Vec<_> = [[0., 0., 0.], [1., 0., 0.], [1., 1., 0.], [0., 1., 0.]]
        .into_iter()
-        .map(|pos| TerrainVertex::new(pos, [0.25, 0.75], 0, 0x80ffffff, 0))
+        .map(|pos| TerrainVertex::new(pos, [0.25, 0.75], 0, color, 0))
        .collect();
    let data = buffer(
        bytemuck::cast_slice(&vertices),
@@ -30,7 +30,7 @@ pub fn buffers() -> [Option<wgpu::VertexBufferLayout<'static>>; 1] {
 /// What `gbuffers_entities` and `gbuffers_block` read from an entity vertex: camera-relative
 /// position, the shared atlas's UV, colour, light (block, sky in 16ths) and the world-oriented
 /// normal. The quad's corners, read from the same vertices at set 1, give the face normal where
-/// the vertex has none (block entities) and `at_tangent` along the texture's u, as for terrain.
+/// the vertex has none (custom geometry) and `at_tangent` along the texture's u, as for terrain.
 pub fn inputs() -> horizon_shaders::GbuffersInputs {
    let words = std::mem::size_of::<Vertex>() / 4;
    let mut declarations = "layout(location = 0) in vec3 hz_v_pos;\nlayout(location = 1) in vec2 hz_v_uv;\n\
@@ -107,6 +107,10 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
            "at_velocity",
            "hz_velocity(gbufferModelView, gbufferPreviousModelView)",
        ),
+        // Horizon's own, as for terrain: the HDR tier of a light-giving item, particle or glowing
+        // text (`mesher::hdr_tier`, the overlay's high bits), 0 for none, 1 to 4 for low to very
+        // bright.
+        ("horizonTier", "float((hz_v_overlay >> 16u) & 255u)"),
    ];
    horizon_shaders::GbuffersInputs {
        declarations,
@@ -123,6 +127,8 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
        }),
        item_id_declared: false,
        far_depth: false,
+        // Entities, items and block entities read the shared atlas: its own maps (paged_maps.rs).
+        paged_maps: true,
    }
 }

@@ -186,6 +192,7 @@ pub fn cloud_inputs() -> horizon_shaders::GbuffersInputs {
        alpha_test: None,
        item_id_declared: false,
        far_depth: false,
+        paged_maps: false,
    }
 }

@@ -1628,3 +1635,44 @@ mod velocity_translate_tests {
        let _ = std::fs::remove_dir_all(&dir);
    }
 }
+
+#[cfg(test)]
+mod tier_translate_tests {
+    /// A pack's entity and hand programs may read `horizonTier`, the overlay's HDR tier.
+    #[test]
+    fn a_pack_reading_horizon_tier_translates_for_entities_and_the_hand() {
+        let dir = std::env::temp_dir().join(format!("hz-entity-tier-{}", std::process::id()));
+        let shaders = dir.join("shaders");
+        std::fs::create_dir_all(&shaders).unwrap();
+        std::fs::write(
+            shaders.join("gbuffers_entities.vsh"),
+            "#version 120\nattribute float horizonTier;\nvarying float t;\n\
+             void main() {\n    gl_Position = ftransform();\n    t = horizonTier;\n}\n",
+        )
+        .unwrap();
+        std::fs::write(
+            shaders.join("gbuffers_entities.fsh"),
+            "#version 120\nvarying float t;\nvoid main() {\n    gl_FragData[0] = vec4(t);\n}\n",
+        )
+        .unwrap();
+        let pack = horizon_shaders::Pack::open(&dir).unwrap();
+        let m = horizon_shaders::Macros::standard();
+        let vsh = horizon_shaders::preprocess(&pack, "gbuffers_entities.vsh", &m);
+        let fsh = horizon_shaders::preprocess(&pack, "gbuffers_entities.fsh", &m);
+        for (who, inputs) in [
+            ("entities", super::inputs()),
+            ("hand", super::super::pack_hand::inputs()),
+        ] {
+            let attribute = inputs.attributes.iter().find(|(n, _)| n == "horizonTier");
+            assert!(attribute.is_some(), "{who}");
+            horizon_shaders::translate_gbuffers(
+                &vsh,
+                &fsh,
+                horizon_shaders::Target::Buffers,
+                &inputs,
+            )
+            .unwrap_or_else(|e| panic!("{who}: {e:?}"));
+        }
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}
@@ -82,6 +82,9 @@ pub(super) fn format(f: Format, packed_float: bool) -> wgpu::TextureFormat {
        _ => rgba,
    };
    match (f.kind, f.bits) {
+        (Kind::Unorm, 10) => T::Rgb10a2Unorm,
+        (Kind::Uint, 10) => T::Rgb10a2Uint,
+        (Kind::Snorm, 16) => pick(T::R16Snorm, T::Rg16Snorm, T::Rgba16Snorm),
        (Kind::Int, 8) => pick(T::R8Sint, T::Rg8Sint, T::Rgba8Sint),
        (Kind::Int, 16) => pick(T::R16Sint, T::Rg16Sint, T::Rgba16Sint),
        (Kind::Int, _) => pick(T::R32Sint, T::Rg32Sint, T::Rgba32Sint),
@@ -52,6 +52,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
        alpha_test: None,
        item_id_declared: false,
        far_depth: false,
+        paged_maps: false,
    }
 }

@@ -0,0 +1,207 @@
+//! Paged maps (`paged_maps.rs`) through the translator's `hz_pagedTexture` and the pass's
+//! binding: a pack reads the map's texels at the colour's coordinates.
+use super::*;
+use wgpu::util::DeviceExt;
+
+/// The atlas the fixture's coordinates are in, and the one mapped texture's place.
+const ATLAS: (u32, u32) = (64, 32);
+const SPRITE: [u32; 4] = [20, 4, 20, 20];
+
+/// The fixture's normal map texel at texel (x, y) of its texture.
+fn texel(x: u32, y: u32) -> [u8; 4] {
+    [x as u8 * 10, y as u8 * 10, 7, 255]
+}
+
+#[test]
+#[ignore = "requires a host GPU; missing adapter is a failure"]
+fn a_pack_reads_paged_maps_at_the_colours_coordinates() {
+    let instance = crate::gfx::test_gpu::instance();
+    let adapter = pollster::block_on(instance.request_adapter(&Default::default())).unwrap();
+    let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
+        required_limits: adapter.limits(),
+        ..Default::default()
+    }))
+    .unwrap();
+    let root = std::env::temp_dir().join(format!("horizon-paged-pack-{}", std::process::id()));
+    std::fs::create_dir_all(root.join("shaders")).unwrap();
+    std::fs::write(
+        root.join("shaders/gbuffers_terrain.vsh"),
+        "#version 120\nvoid main(){gl_Position=gl_Vertex;}",
+    )
+    .unwrap();
+    // Each pixel reads one atlas texel's centre: in the texture (on four pages), beside it,
+    // on a page without maps, and the specular map, which no texture has.
+    std::fs::write(
+        root.join("shaders/gbuffers_terrain.fsh"),
+        r#"#version 120
+uniform sampler2D normals;
+uniform sampler2D specular;
+vec2 at(float x, float y) { return (vec2(x, y) + 0.5) / vec2(64.0, 32.0); }
+void main() {
+    int x = int(floor(gl_FragCoord.x));
+    if (x == 0) gl_FragData[0] = texture2D(normals, at(20.0, 4.0));
+    else if (x == 1) gl_FragData[0] = texture2D(normals, at(39.0, 23.0));
+    else if (x == 2) gl_FragData[0] = texture2D(normals, at(31.0, 15.0), 2.0);
+    else if (x == 3) gl_FragData[0] = texture2DLod(normals, at(32.0, 16.0), 3.0);
+    else if (x == 4) gl_FragData[0] = texture2D(normals, at(19.0, 4.0));
+    else if (x == 5) gl_FragData[0] = texture2D(normals, at(50.0, 30.0));
+    else if (x == 6) gl_FragData[0] = texture2D(specular, at(25.0, 10.0));
+    else gl_FragData[0] = texture2D(normals, at(33.0, 5.0));
+}
+"#,
+    )
+    .unwrap();
+    let [x0, y0, w, h] = SPRITE;
+    let normal: Vec<u8> = (0..w * h).flat_map(|i| texel(i % w, i / w)).collect();
+    let [normals, specular] = crate::paged_maps::build(
+        ATLAS,
+        &[crate::paged_maps::SpriteMaps {
+            rect: SPRITE,
+            maps: [Some(normal), None],
+        }],
+        16384,
+    );
+    assert!(specular.is_none());
+    let normals = normals.unwrap();
+    let map = device
+        .create_texture_with_data(
+            &queue,
+            &wgpu::TextureDescriptor {
+                label: Some("Fixture paged normal map"),
+                size: wgpu::Extent3d {
+                    width: normals.width,
+                    height: normals.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,
+            &normals.pixels,
+        )
+        .create_view(&Default::default());
+    let pack = horizon_shaders::Pack::open(&root).unwrap();
+    let macros = horizon_shaders::Macros::standard();
+    let properties = horizon_shaders::Properties::parse("alphaTest.gbuffers_terrain=off", &macros);
+    let inputs = horizon_shaders::GameInputs {
+        terrain: Some(horizon_shaders::GbuffersInputs {
+            body: "vec2 p = vec2(float((gl_VertexIndex << 1) & 2), float(gl_VertexIndex & 2)); hz_Vertex=vec4(p*2.0-1.0,0.0,1.0);".into(),
+            paged_maps: true,
+            ..Default::default()
+        }),
+        ..Default::default()
+    };
+    let post = horizon_shaders::load_post(&pack, "", &properties, &macros, &inputs);
+    assert!(post.terrain.is_some(), "{:?}", post.notes);
+    let world = World {
+        sprite_rects: &[],
+        atlas: None,
+        material_maps: None,
+        lightmap: map.clone(),
+        terrain: Some(Geometry {
+            buffers: &[],
+            table: None,
+            depth_write: true,
+            atlas: None,
+            material_maps: false,
+            ids: None,
+            cull: false,
+        }),
+        block_ids: &[],
+        celestial: None,
+        gui_size: [1, 1],
+        clouds: None,
+        weather: false,
+        hand: false,
+    };
+    let mut post = PackPost::new(
+        &device,
+        &queue,
+        &adapter,
+        post,
+        wgpu::TextureFormat::Rgba8Unorm,
+        world,
+        &Default::default(),
+    )
+    .expect("the pack runs");
+    let mut pass = post
+        .terrain
+        .take()
+        .unwrap_or_else(|| panic!("terrain pipeline must compile: {:?}", post.notes));
+    // As the entity passes are (`paged`), with the maps the renderer hands over.
+    pass.paged = true;
+    post.set_paged_maps([Some(map), None]);
+    post.copied |= 1;
+    post.resize(&device, [8, 1]);
+    let read = device.create_buffer(&wgpu::BufferDescriptor {
+        label: None,
+        size: 256,
+        usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+        mapped_at_creation: false,
+    });
+    let mut encoder = device.create_command_encoder(&Default::default());
+    {
+        let _clear = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: Some("Initialize fixture depth"),
+            color_attachments: &[],
+            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                view: &post.targets.as_ref().unwrap().depth,
+                depth_ops: Some(wgpu::Operations {
+                    load: wgpu::LoadOp::Clear(1.0),
+                    store: wgpu::StoreOp::Store,
+                }),
+                stencil_ops: None,
+            }),
+            ..Default::default()
+        });
+    }
+    let group = post.bind(&device, &queue, &mut encoder, &mut pass, [8, 1]);
+    {
+        let mut render = post.begin(&mut encoder, &pass);
+        render.set_pipeline(pass.render());
+        render.set_bind_group(0, &group, &[]);
+        if pass.draw {
+            post.draws.bind(&mut render, "TERRAIN_SOLID");
+        }
+        render.draw(0..3, 0..1);
+    }
+    let output = post.targets.as_ref().unwrap().color[0].as_ref().unwrap()[0].texture();
+    encoder.copy_texture_to_buffer(
+        output.as_image_copy(),
+        wgpu::TexelCopyBufferInfo {
+            buffer: &read,
+            layout: wgpu::TexelCopyBufferLayout {
+                bytes_per_row: Some(256),
+                ..Default::default()
+            },
+        },
+        wgpu::Extent3d {
+            width: 8,
+            height: 1,
+            depth_or_array_layers: 1,
+        },
+    );
+    queue.submit([encoder.finish()]);
+    read.slice(..).map_async(wgpu::MapMode::Read, |_| {});
+    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+    let data = read.slice(..).get_mapped_range().unwrap();
+    let local = |x: u32, y: u32| texel(x - x0, y - y0);
+    let expected = [
+        local(20, 4),
+        local(39, 23),
+        local(31, 15),
+        local(32, 16),
+        crate::sprites::FLAT_NORMAL,
+        crate::sprites::FLAT_NORMAL,
+        crate::sprites::NO_SPECULAR,
+        local(33, 5),
+    ];
+    for (i, e) in expected.iter().enumerate() {
+        assert_eq!(&data[i * 4..i * 4 + 4], e, "pixel {i}");
+    }
+    std::fs::remove_dir_all(root).unwrap();
+}
@@ -61,6 +61,9 @@ mod shadow_faces_tests;
 #[cfg(test)]
 mod r11f_image_tests;

+#[cfg(test)]
+mod work_group_fold_tests;
+
 #[cfg(test)]
 mod forced_flip_tests;

@@ -430,6 +433,9 @@ struct Pass {
    /// What `texture` reads instead of the block atlas.
    atlas: Option<wgpu::TextureView>,
    material_maps: bool,
+    /// Draws the shared atlas's geometry: `normals` and `specular` are its paged maps
+    /// (`PackPost::set_paged_maps`), as its programs were translated to read them.
+    paged: bool,
    /// Reads `mc_Entity`'s table (`PackPost::block_ids`).
    ids: bool,
    /// Bind groups by the sides read (bits 0–15), the buffers whose mip chain is current (bits
@@ -674,6 +680,8 @@ pub struct PackPost {
    custom: horizon_shaders::Custom,
    atlas: Option<wgpu::TextureView>,
    material_maps: Option<[wgpu::TextureView; 2]>,
+    /// The shared atlas's normal and specular paged maps (`set_paged_maps`).
+    paged_maps: [Option<wgpu::TextureView>; 2],
    lightmap: wgpu::TextureView,
    deferred_pre: u16,
    composite_pre: u16,
@@ -2179,6 +2187,7 @@ fn build_pass(
        draw,
        atlas: geometry.and_then(|g| g.atlas.clone()),
        material_maps: geometry.is_some_and(|g| g.material_maps),
+        paged: false,
        ids: geometry.is_some_and(|g| g.ids.is_some()),
        groups: HashMap::new(),
        portal_groups: HashMap::new(),
@@ -2319,6 +2328,7 @@ fn build_compute(
        draw: false,
        atlas: None,
        material_maps: false,
+        paged: false,
        ids: false,
        groups: HashMap::new(),
        portal_groups: HashMap::new(),
@@ -2357,6 +2367,13 @@ impl Refused {
 }

 impl PackPost {
+    /// The shared atlas's normal and specular paged maps (`paged_maps.rs`), which the programs
+    /// drawing its geometry read as `normals` and `specular`; set before the first frame (a pass's
+    /// bind groups are kept once made). A missing one reads as the dummy (flat, no specular).
+    pub fn set_paged_maps(&mut self, maps: [Option<wgpu::TextureView>; 2]) {
+        self.paged_maps = maps;
+    }
+
    /// Builds the pipelines of `post` for a screen of `screen` format. An error when the pack
    /// can't show anything on the screen: the game turns it off, as a pack that fails to load.
    ///
@@ -2780,6 +2797,13 @@ impl PackPost {
            ids: None,
            cull: false,
        });
+        // Programs drawing the shared atlas's geometry read its paged maps (`pack_entities::inputs`).
+        let paged = |pass: Option<Pass>| {
+            pass.map(|mut pass| {
+                pass.paged = true;
+                pass
+            })
+        };
        let entity_passes = programs.map(|p| {
            p.zip(entity_geometry.as_ref()).and_then(|(p, g)| {
                if p.name == "gbuffers_damagedblock" {
@@ -2792,15 +2816,15 @@ impl PackPost {
                        ids: g.ids,
                        cull: false,
                    };
-                    build(p, Some(&decal))
+                    paged(build(p, Some(&decal)))
                } else {
-                    build(p, Some(g))
+                    paged(build(p, Some(g)))
                }
            })
        });
        let shadow_entities = shadow_programs.map(|p| {
            p.zip(entity_geometry.as_ref())
-                .and_then(|(p, g)| build(p, Some(g)))
+                .and_then(|(p, g)| paged(build(p, Some(g))))
        });
        let entities = entity_vertices
            .filter(|_| (entity_passes.iter().chain(&shadow_entities)).any(Option::is_some))
@@ -2843,7 +2867,7 @@ impl PackPost {
                ids: None,
                cull: false,
            };
-            build(p, Some(&g)).map(|pass| (pass, geometry))
+            paged(build(p, Some(&g))).map(|pass| (pass, geometry))
        });
        // Translucent held items, drawn from the hand's own buffer.
        let hand_water = post.hand_water.and_then(|p| {
@@ -2857,7 +2881,7 @@ impl PackPost {
                ids: None,
                cull: false,
            };
-            build(p, Some(&g))
+            paged(build(p, Some(&g)))
        });
        let weather = post
            .weather
@@ -3296,6 +3320,7 @@ impl PackPost {
            custom,
            atlas: world.atlas.as_ref().map(|a| a.0.clone()),
            material_maps: world.material_maps,
+            paged_maps: [None, None],
            lightmap: world.lightmap,
            deferred_pre: mask(&post.deferred_pre),
            composite_pre: mask(&post.composite_pre),
@@ -3656,6 +3681,12 @@ impl PackPost {
                    Source::Dummy if s.dimension == wgpu::TextureViewDimension::D1 => {
                        &self.dummy_1d
                    }
+                    Source::Normals if pass.paged => {
+                        self.paged_maps[0].as_ref().unwrap_or(&self.dummy_normal)
+                    }
+                    Source::Specular if pass.paged => {
+                        self.paged_maps[1].as_ref().unwrap_or(&self.dummy_black)
+                    }
                    Source::Normals => self
                        .material_maps
                        .as_ref()
@@ -3756,6 +3787,16 @@ impl PackPost {
            [n(0), n(1), 1]
        });
        let (pipeline, groups) = (pipeline.clone(), groups);
+        // wgpu panics on a dispatch over its limit. The translator reshapes a large
+        // `workGroups`; a `workGroupsRender` that large is not run.
+        let most = device.limits().max_compute_workgroups_per_dimension;
+        if groups.iter().any(|&n| n > most) {
+            log::warn!(
+                "shader pack: {}: {groups:?} work groups is over {most} per dimension; not run",
+                pass.name
+            );
+            return;
+        }
        for image in (0..self.images.len()).filter(|k| pass.snapshots & 1 << k != 0) {
            pack_images::snapshot(encoder, &self.images[image]);
        }
@@ -6256,6 +6297,34 @@ mod tests {
        );
    }

+    #[test]
+    fn an_image_is_made_in_its_layout_qualifiers_format() {
+        // `image.x = … RGB10_A2 …` read through `layout(rgb10_a2) image2D x`.
+        for q in [
+            "rgba32f",
+            "rgba16f",
+            "rg16f",
+            "r11f_g11f_b10f",
+            "r32f",
+            "rgba16",
+            "rgb10_a2",
+            "rgba8",
+            "rg8",
+            "r16",
+            "rgba16_snorm",
+            "rgba8_snorm",
+            "r8_snorm",
+            "rgba32i",
+            "r16i",
+            "rgb10_a2ui",
+            "rgba8ui",
+            "r32ui",
+        ] {
+            let def = Format::parse(q).unwrap();
+            assert_eq!(Some(pack_images::format(def, true)), image_format(q), "{q}");
+        }
+    }
+
    #[test]
    fn samplers_read_custom_textures_of_their_type() {
        use wgpu::TextureSampleType as T;
@@ -6301,6 +6370,10 @@ mod destination_tests;
 #[path = "pack_material_tests.rs"]
 mod material_tests;

+#[cfg(test)]
+#[path = "pack_paged_maps_tests.rs"]
+mod paged_maps_tests;
+
 #[cfg(test)]
 mod rgb_alpha_tests;

@@ -322,7 +322,7 @@ fn check(sampler: &str, stage: Stage, scene: Scene, expected: [u8; 4]) {
    let hand = matches!(scene, Scene::Terrain { hand: true, .. });
    let water = matches!(scene, Scene::Terrain { water: true, .. } | Scene::WaterOnly);
    let inputs=horizon_shaders::GameInputs {
-        terrain:terrain.then(|| horizon_shaders::GbuffersInputs { declarations:"layout(location=0)in vec3 fixture_position;\n".into(),body:"hz_Vertex=vec4(fixture_position,1.0);hz_Color=vec4(1.0);hz_MultiTexCoord0=vec4(0.0);hz_MultiTexCoord1=vec4(240.0);hz_MultiTexCoord2=vec4(240.0);hz_Normal=vec3(0.0,0.0,1.0);\n".into(),attributes:vec![],after:String::new(),alpha_test:None,item_id_declared:false,far_depth:false }),
+        terrain:terrain.then(|| horizon_shaders::GbuffersInputs { declarations:"layout(location=0)in vec3 fixture_position;\n".into(),body:"hz_Vertex=vec4(fixture_position,1.0);hz_Color=vec4(1.0);hz_MultiTexCoord0=vec4(0.0);hz_MultiTexCoord1=vec4(240.0);hz_MultiTexCoord2=vec4(240.0);hz_Normal=vec3(0.0,0.0,1.0);\n".into(),attributes:vec![],after:String::new(),alpha_test:None,item_id_declared:false,far_depth:false,paged_maps:false }),
        hand:hand.then(crate::gfx::pack_hand::inputs),..Default::default()
    };
    let mut post = gpu.load(
@@ -719,6 +719,7 @@ fn shadow_depth_map_reads(
            alpha_test: None,
            item_id_declared: false,
            far_depth: false,
+            paged_maps: false,
        }),
        ..Default::default()
    };
@@ -46,6 +46,7 @@ fn pack() -> Post {
        terrain: Some(horizon_shaders::GbuffersInputs {
            item_id_declared: false,
            far_depth: false,
+            paged_maps: false,
            declarations: "layout(location=0)in vec3 fixture_position;\n".into(),
            body: "hz_Vertex=vec4(fixture_position,1.0);hz_Color=vec4(1.0);\
                   hz_MultiTexCoord0=vec4(0.0);hz_MultiTexCoord1=vec4(240.0);\
@@ -0,0 +1,57 @@
+//! A `workGroups` over wgpu's 65535 per dimension runs, and its programs read the work group
+//! built-ins of the dispatch they declared. The programs are original.
+use super::destination_tests::Fixture;
+use super::*;
+use std::io::{Cursor, Write};
+
+fn pack() -> Post {
+    let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    let mut add = |name: &str, source: &str| {
+        zip.start_file(
+            format!("shaders/{name}"),
+            zip::write::SimpleFileOptions::default(),
+        )
+        .unwrap();
+        zip.write_all(source.as_bytes()).unwrap();
+    };
+    // 70000 x 1 x 2 groups; the last 64 of the second layer each paint one pixel, green when
+    // the built-ins agree with that dispatch.
+    add(
+        "composite.csh",
+        "#version 430\nlayout(local_size_x=1) in;\nconst ivec3 workGroups=ivec3(70000,1,2);\n\
+         layout(rgba8) writeonly uniform image2D colorimg0;\n\
+         void main() {\n    uint first = 70000u - 64u;\n\
+             if (gl_WorkGroupID.z != 1u || gl_WorkGroupID.x < first) return;\n\
+             uint k = gl_WorkGroupID.x - first;\n\
+             bool ok = gl_WorkGroupID.y == 0u && gl_NumWorkGroups == uvec3(70000u, 1u, 2u)\n\
+                 && gl_GlobalInvocationID == gl_WorkGroupID;\n\
+             imageStore(colorimg0, ivec2(k % 8u, k / 8u), ok ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1));\n}\n",
+    );
+    add(
+        "final.vsh",
+        "#version 120\nvarying vec2 uv;\nvoid main() { uv=gl_MultiTexCoord0.xy; gl_Position=ftransform(); }\n",
+    );
+    add(
+        "final.fsh",
+        "#version 330 compatibility\nuniform sampler2D colortex0;\nin vec2 uv;\n\
+         void main() { gl_FragColor = texelFetch(colortex0, ivec2(gl_FragCoord.xy), 0); }\n",
+    );
+    let pack =
+        horizon_shaders::Pack::from_zip_bytes("original-fold", zip.finish().unwrap().into_inner())
+            .unwrap();
+    let mut macros = horizon_shaders::Macros::standard();
+    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
+    horizon_shaders::load_post(&pack, "", &properties, &macros, &Default::default())
+}
+
+#[test]
+fn a_dispatch_over_the_limit_reads_its_declared_work_groups() {
+    let Some(gpu) = Fixture::new() else { return };
+    let post = pack();
+    assert!(post.notes.is_empty(), "{:?}", post.notes);
+    let mut post = gpu.build(post);
+    let pixels = gpu.render(&mut post, [8, 8]);
+    for (k, got) in pixels.iter().enumerate() {
+        assert_eq!(*got, [0, 255, 0, 255], "pixel {k}; notes {:?}", post.notes);
+    }
+}
@@ -104,6 +104,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
        alpha_test: None,
        item_id_declared: false,
        far_depth: true,
+        paged_maps: false,
    }
 }

@@ -131,6 +132,7 @@ pub fn celestial_inputs() -> horizon_shaders::GbuffersInputs {
        alpha_test: None,
        item_id_declared: false,
        far_depth: true,
+        paged_maps: false,
    }
 }

@@ -355,6 +355,25 @@ pub const NAMES: &[&str] = &[
    "hasSkylight",
    "hasCeiling",
    "cloudTime",
+    // Horizon's own: Horizon Extras' dynamic lights (`dynamic_light.rs`), nearest first: how
+    // many, and each one's camera-relative position and light level (zeros past the count).
+    "horizonDynamicLightCount",
+    "horizonDynamicLight0",
+    "horizonDynamicLight1",
+    "horizonDynamicLight2",
+    "horizonDynamicLight3",
+    "horizonDynamicLight4",
+    "horizonDynamicLight5",
+    "horizonDynamicLight6",
+    "horizonDynamicLight7",
+    "horizonDynamicLight8",
+    "horizonDynamicLight9",
+    "horizonDynamicLight10",
+    "horizonDynamicLight11",
+    "horizonDynamicLight12",
+    "horizonDynamicLight13",
+    "horizonDynamicLight14",
+    "horizonDynamicLight15",
    "isElytraFlying",
    "cloudHeight",
 ];
@@ -929,6 +948,12 @@ impl FrameUniforms {
                "gbufferProjectionInverse" => m4(projection_inverse),
                "gbufferPreviousModelView" => m4(previous_view),
                "gbufferPreviousProjection" => m4(previous_projection),
+                "horizonDynamicLightCount" => Value::i(&[frame.dynamic_lights.len() as i32]),
+                n if dynamic_light_index(n).is_some() => Value::f(
+                    &(dynamic_light_index(n).and_then(|k| frame.dynamic_lights.get(k)))
+                        .copied()
+                        .unwrap_or([0.0; 4]),
+                ),
                "heldItemId" => Value::i(&[inputs.held_items[0]]),
                "heldItemId2" => Value::i(&[inputs.held_items[1]]),
                "heldBlockLightValue" => Value::i(&[inputs.held_light[0]]),
@@ -1785,6 +1810,29 @@ pub(super) mod initial_history_tests {
        assert_eq!(crate::clouds::drift(256 * 400 + 3, 0.25, 256), 3.25);
    }

+    #[test]
+    fn the_dynamic_lights_reach_the_pack_nearest_first() {
+        let hud = HudBatch::new([800, 450]);
+        let mut f = frame(&hud);
+        let lights = [[1.0, 2.0, 3.0, 14.0], [-4.0, 0.5, 6.0, 7.0]];
+        f.dynamic_lights = &lights;
+        let mut u = FrameUniforms::default();
+        u.update(&f, &PackInputs::default(), [800, 450]);
+        let count = index("horizonDynamicLightCount").unwrap();
+        assert_eq!(int(&u, count), 2);
+        assert_eq!(float(&u, "horizonDynamicLight0")[..4], lights[0]);
+        assert_eq!(float(&u, "horizonDynamicLight1")[..4], lights[1]);
+        // Past the count, and the last of the sixteen: zeros.
+        assert_eq!(float(&u, "horizonDynamicLight2")[..4], [0.0; 4]);
+        assert_eq!(float(&u, "horizonDynamicLight15")[..4], [0.0; 4]);
+        assert_eq!(index("horizonDynamicLight16"), None);
+        // Off (no lights): none.
+        f.dynamic_lights = &[];
+        u.update(&f, &PackInputs::default(), [800, 450]);
+        assert_eq!(int(&u, count), 0);
+        assert_eq!(float(&u, "horizonDynamicLight0")[..4], [0.0; 4]);
+    }
+
    #[test]
    fn environmental_smoothing_starts_at_the_first_inputs_without_resetting_each_frame() {
        let hud = HudBatch::new([800, 450]);
@@ -2534,6 +2582,12 @@ pub(super) mod initial_history_tests {
    }
 }

+/// `horizonDynamicLight<k>`'s `k`, for the lights `Frame::dynamic_lights` holds.
+fn dynamic_light_index(name: &str) -> Option<usize> {
+    let k: usize = name.strip_prefix("horizonDynamicLight")?.parse().ok()?;
+    (k < crate::dynamic_light::MAX).then_some(k)
+}
+
 #[cfg(test)]
 #[path = "pack_uniforms/ftransform_test.rs"]
 mod ftransform_test;
@@ -46,6 +46,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
        }),
        item_id_declared: false,
        far_depth: false,
+        paged_maps: false,
    }
 }

@@ -55,6 +55,13 @@ pub struct Post {
    sampler: wgpu::Sampler,
    copy: wgpu::RenderPipeline,
    fxaa: wgpu::RenderPipeline,
+    /// Contrast-adaptive sharpening of TAA's upscaled picture: the jittered frames are
+    /// spread over more output pixels, and the blend softens edges.
+    sharpen: wgpu::RenderPipeline,
+    /// The strength `sharpen` was built with (`set_sharpness`), and what rebuilding it takes.
+    sharpness: f32,
+    shader: wgpu::ShaderModule,
+    pipeline_layout: wgpu::PipelineLayout,
    format: wgpu::TextureFormat,
    /// World resolution relative to the window (0.5..=2.0).
    pub scale: f32,
@@ -232,8 +239,12 @@ impl Post {
            ..Default::default()
        });
        Self {
+            shader: shader.clone(),
+            pipeline_layout: pipeline_layout.clone(),
            copy: pipeline("fs_copy", &pipeline_layout, format),
            fxaa: pipeline("fs_fxaa", &pipeline_layout, format),
+            sharpen: sharpen_pipeline(device, &shader, &pipeline_layout, format, 0.85),
+            sharpness: 0.85,
            layout,
            sampler,
            format,
@@ -474,6 +485,21 @@ impl Post {
        }
    }

+    /// The Upscaling Sharpness setting, 0..=1: rebuilds the sharpen pipeline when it changed.
+    pub fn set_sharpness(&mut self, device: &wgpu::Device, sharpness: f32) {
+        let sharpness = sharpness.clamp(0.0, 1.0);
+        if sharpness != self.sharpness {
+            self.sharpen = sharpen_pipeline(
+                device,
+                &self.shader,
+                &self.pipeline_layout,
+                self.format,
+                sharpness,
+            );
+            self.sharpness = sharpness;
+        }
+    }
+
    /// The size of the world's own target, when it has one.
    pub fn size(&self) -> Option<[u32; 2]> {
        self.target.as_ref().map(|t| t.size)
@@ -535,7 +561,12 @@ impl Post {
        pass.set_bind_group(0, &taa.resolve[i], &[]);
        pass.draw(0..3, 0..1);
        drop(pass);
-        self.finish_with(encoder, screen, &taa.show[i], timing);
+        let pipeline = if self.upscale > 1.0 {
+            &self.sharpen
+        } else {
+            &self.copy
+        };
+        self.draw_onto(encoder, screen, &taa.show[i], pipeline, timing);
    }

    /// Draw what `group` binds (`bind`) onto `screen`.
@@ -545,6 +576,23 @@ impl Post {
        screen: &wgpu::TextureView,
        group: &wgpu::BindGroup,
        timing: Option<&mut super::pack_timing::PassTiming>,
+    ) {
+        let pipeline = if self.antialias {
+            &self.fxaa
+        } else {
+            &self.copy
+        };
+        self.draw_onto(encoder, screen, group, pipeline, timing);
+    }
+
+    /// Draw what `group` binds onto `screen` through `pipeline`.
+    fn draw_onto(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        screen: &wgpu::TextureView,
+        group: &wgpu::BindGroup,
+        pipeline: &wgpu::RenderPipeline,
+        timing: Option<&mut super::pack_timing::PassTiming>,
    ) {
        let attachments = [Some(wgpu::RenderPassColorAttachment {
            view: screen,
@@ -561,16 +609,51 @@ impl Post {
            color_attachments: &attachments,
            ..Default::default()
        });
-        pass.set_pipeline(if self.antialias {
-            &self.fxaa
-        } else {
-            &self.copy
-        });
+        pass.set_pipeline(pipeline);
        pass.set_bind_group(0, group, &[]);
        pass.draw(0..3, 0..1);
    }
 }

+/// `fs_sharpen` at `sharpness` (its override), drawing onto `format`.
+fn sharpen_pipeline(
+    device: &wgpu::Device,
+    shader: &wgpu::ShaderModule,
+    layout: &wgpu::PipelineLayout,
+    format: wgpu::TextureFormat,
+    sharpness: f32,
+) -> wgpu::RenderPipeline {
+    let constants = [("sharpness", f64::from(sharpness))];
+    device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: Some("Horizon sharpen"),
+        layout: Some(layout),
+        vertex: wgpu::VertexState {
+            module: shader,
+            entry_point: Some("vs_post"),
+            compilation_options: Default::default(),
+            buffers: &[],
+        },
+        primitive: Default::default(),
+        depth_stencil: None,
+        multisample: Default::default(),
+        fragment: Some(wgpu::FragmentState {
+            module: shader,
+            entry_point: Some("fs_sharpen"),
+            compilation_options: wgpu::PipelineCompilationOptions {
+                constants: &constants,
+                ..Default::default()
+            },
+            targets: &[Some(wgpu::ColorTargetState {
+                format,
+                blend: None,
+                write_mask: wgpu::ColorWrites::ALL,
+            })],
+        }),
+        multiview_mask: None,
+        cache: None,
+    })
+}
+
 /// This frame's clip space to the previous frame's, for camera-relative projections:
 /// a point `camera - previous_camera` further from the previous camera than from this one.
 pub(super) fn reprojection(
@@ -725,6 +725,8 @@ pub struct Graphics {
    pub taa: bool,
    /// TAA upscaling; anything but `Native` comes with `taa` on.
    pub upscaling: Upscaling,
+    /// How much the upscaled picture is sharpened, 0..=100 (percent of the most).
+    pub upscaling_sharpness: u32,
    /// F2 screenshots at this many times the game's resolution: 1, 2, 4 or 8.
    pub screenshot_quality: u32,
    /// Frame generation (Horizon setting), off by default.
@@ -813,6 +815,7 @@ impl Default for Graphics {
            fxaa: false,
            taa: false,
            upscaling: Upscaling::Native,
+            upscaling_sharpness: 85,
            screenshot_quality: 1,
            frame_generation: FrameGeneration::Off,
            hdr: false,
@@ -935,6 +938,9 @@ impl Graphics {
                "fxaa" => g.fxaa = flag(g.fxaa),
                "taa" => g.taa = flag(g.taa),
                "upscaling" => g.upscaling = Upscaling::parse(value),
+                "upscalingSharpness" => {
+                    g.upscaling_sharpness = number(g.upscaling_sharpness).min(100)
+                }
                "screenshotQuality" => {
                    g.screenshot_quality = Some(number(0))
                        .filter(|q| SCREENSHOT_QUALITIES.contains(q))
@@ -980,7 +986,7 @@ impl Graphics {
    }
    pub fn serialize(&self) -> String {
        let mut text = format!(
-            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nentityCullingPrecheck:{}\nparticleCulling:{}\nleafCulling:{}\nblockEntityCacheShulkerBoxes:{}\nblockEntityCacheSigns:{}\nblockEntityCacheDecoratedPots:{}\nblockEntityCacheBells:{}\nblockEntityCacheChests:{}\nblockEntityCacheBanners:{}\nblockEntityCacheCopperGolemStatues:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\ntextureBudgetMiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\nditherCutoutMips:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nscreenshotQuality:{}\nframeGeneration:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrLighting:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\nbatchTranslucent:{}\nhdrSmoothGradients:{}\ngpuCulling:{}\n",
+            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nentityCullingPrecheck:{}\nparticleCulling:{}\nleafCulling:{}\nblockEntityCacheShulkerBoxes:{}\nblockEntityCacheSigns:{}\nblockEntityCacheDecoratedPots:{}\nblockEntityCacheBells:{}\nblockEntityCacheChests:{}\nblockEntityCacheBanners:{}\nblockEntityCacheCopperGolemStatues:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\ntextureBudgetMiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\nditherCutoutMips:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nupscalingSharpness:{}\nscreenshotQuality:{}\nframeGeneration:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrLighting:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\nbatchTranslucent:{}\nhdrSmoothGradients:{}\ngpuCulling:{}\n",
            self.preset.name(),
            self.lod_distance,
            self.far_detail.name(),
@@ -1019,6 +1025,7 @@ impl Graphics {
            bool_text(self.fxaa),
            bool_text(self.taa),
            self.upscaling.name(),
+            self.upscaling_sharpness,
            self.screenshot_quality,
            self.frame_generation.name(),
            bool_text(self.hdr),
@@ -1202,6 +1209,7 @@ mod tests {
            fxaa: true,
            taa: true,
            upscaling: Upscaling::Balanced,
+            upscaling_sharpness: 40,
            screenshot_quality: 4,
            frame_generation: FrameGeneration::Fsr31,
            hdr: true,
@@ -97,6 +97,7 @@ pub enum H {
    ResolutionScale,
    Antialiasing,
    Upscaling,
+    UpscalingSharpness,
    ScreenshotQuality,
    FrameGeneration,
    Hdr,
@@ -372,6 +373,11 @@ pub fn rows() -> Vec<(Page, Vec<(&'static str, Vec<Setting>)>)> {
                            High,
                            "Renders the world smaller and rebuilds it with TAA. Faster, softer.",
                        ),
+                        h(
+                            H::UpscalingSharpness,
+                            Low,
+                            "Sharpens the upscaled picture. Higher: crisper edges, more shimmer.",
+                        ),
                        h(
                            H::ScreenshotQuality,
                            None,
@@ -785,6 +791,7 @@ impl H {
            }
            H::Workers => Some(g.workers as f32 / max_workers() as f32),
            H::ResolutionScale => Some((g.resolution_scale as f32 - 50.0) / 150.0),
+            H::UpscalingSharpness => Some(g.upscaling_sharpness as f32 / 100.0),
            // Auto, then 10..480 by 10.
            H::HdrPaperWhite => Some(g.hdr_paper_white as f32 / 480.0),
            // Auto, then 200..2000 by 50.
@@ -804,6 +811,7 @@ impl H {
            H::UploadBudget => Some((UPLOAD_STEPS.len() - 1) as u32),
            H::Workers => Some(max_workers()),
            H::ResolutionScale => Some(30),
+            H::UpscalingSharpness => Some(20),
            H::HdrPaperWhite => Some(41),
            H::HdrPeak => Some(37),
            H::HdrBlackLevel => Some(100),
@@ -893,6 +901,9 @@ impl H {
                },
            ),
            H::Upscaling => labelled("Upscaling", g.upscaling.label()),
+            H::UpscalingSharpness => {
+                labelled("Upscaling Sharpness", format!("{}%", g.upscaling_sharpness))
+            }
            H::ScreenshotQuality => {
                labelled("Screenshot Quality", format!("{}x", g.screenshot_quality))
            }
@@ -965,6 +976,7 @@ impl H {
            }
            H::Workers => g.workers = (v * max_workers() as f32).round() as u32,
            H::ResolutionScale => g.resolution_scale = (50.0 + (v * 30.0).round() * 5.0) as u32,
+            H::UpscalingSharpness => g.upscaling_sharpness = (v * 20.0).round() as u32 * 5,
            H::HdrPaperWhite => g.hdr_paper_white = (v * 48.0).round() as u32 * 10,
            H::HdrPeak => {
                g.hdr_peak = match (v * 37.0).round() as u32 {
@@ -3222,6 +3234,7 @@ mod tests {
            H::UploadBudget,
            H::Workers,
            H::ResolutionScale,
+            H::UpscalingSharpness,
            H::HdrPaperWhite,
            H::HdrPeak,
            H::HdrBlackLevel,
@@ -33,6 +33,11 @@ struct Params {
@group(0) @binding(2) var<uniform> params: Params;
 // Horizon's logo, 1 inside, 0 outside, for calibration's test pictures.
@group(0) @binding(3) var logo: texture_2d<f32>;
+// The float frame with HUD coverage (Hdr::layered): the frame keeps the world as light
+// (fs_resolve), the HUD draws on a picture of its own (`hud`, fs_keep), and `coverage` says how
+// much of the world it hides there (gfx/hud_coverage.rs).
+@group(0) @binding(4) var coverage: texture_2d<f32>;
+@group(0) @binding(5) var hud: texture_2d<f32>;

 // Light sources are lifted evenly rather than by a highlight curve: vanilla's
 // textures were drawn for SDR, so a curve on their brightest pixels blows out
@@ -149,49 +154,29 @@ fn calibration_nits(p: vec2<f32>, size: vec2<f32>) -> f32 {
    return vec4(0.0);
 }

-@fragment fn fs_hdr(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
-    let at = vec2<i32>(pos.xy);
-    // Calibration: above its controls the test picture, straight in nits, past
-    // paper white, the lift and the black level.
-    let size = vec2<f32>(textureDimensions(frame));
-    if params.calibration.x > 0.5 && pos.y < size.y * params.calibration.z {
-        let nits = vec3(calibration_nits(pos.xy, size));
-        if params.pq > 0.5 {
-            return vec4(pq(nits), 1.0);
-        }
-        return vec4(nits / 80.0, 1.0);
-    }
-    let f = frame_texel(textureLoad(frame, at, 0));
-    // What covers the world here (Hdr::keep_world): nothing at 0, the hand at
-    // 1/255 (Hdr::mark_hand: drawn at the world's brightness), else the HUD or a
-    // menu, by how much.
-    let covered = f.a > 0.0;
-    let hand = covered && f.a < 1.5 / 255.0;
-    let ui = select(f.a, 0.0, hand);
-    let w = frame_texel(textureLoad(world, at, 0));
-    // The world's alpha is below 0.75 on light sources, the sun and the moon
-    // (terrain.wgsl, entity.wgsl): only those shine, and only where nothing was
-    // drawn over them since: grey text over the white sun still looks like the sun
-    // darkened, but it raised the frame's alpha. Its band of 0.175 is the tier, the
-    // lower the brighter, and where in the band how much (hdr_mark). The hand
-    // writes its own alpha there (Hdr::hand_light_view): 1, or a light source it holds.
+// The light of colour `f` under the world's mark `a` (the alpha the world left, hdr_mark) where
+// the world `shows`, else the colour clipped at white; and whether a light source lifted it.
+struct Lit {
+    light: vec3<f32>,
+    lifted: bool,
+};
+
+fn lit(f: vec3<f32>, a: f32, shows: bool) -> Lit {
    var lifted = false;
-    let shows = params.world > 0.5 && params.peak > 1.0
-        && (hand || (!covered && shows_world(f.rgb, w.rgb)));
    // Light over 1 (a float frame's) shows only where the world does and carries
    // no mark (alpha 1), up to the peak: light written as light. Marked pixels clip
    // at white before their lift, as on a unorm frame, so light sources, the sun and
    // HDR lighting look as they do there; so do the HUD, menus and HDR Lighting off.
-    let c = select(min(f.rgb, vec3(1.0)), f.rgb, shows && w.a == 1.0);
+    let c = select(min(f, vec3(1.0)), f, shows && a == 1.0);
    // Gamma 2.2, as SDR displays and the compositors' SDR paths decode it.
    var light = pow(c, vec3(2.2));
    // HDR lighting: alpha between 0.76 and 1 is how much of it the surface gets. Vanilla's
    // light is albedo times lightmap, so this is the lightmap going past 1. It eases into the
    // peak from 60% of it, so bright textures keep their detail. Unmarked light (alpha 1)
    // gets no gain and no knee: the clamp to the peak below is all it needs here.
-    if shows && w.a >= 0.75 && w.a < 1.0 {
+    if shows && a >= 0.75 && a < 1.0 {
        let top = max(light.r, max(light.g, light.b));
-        let gain = 1.0 + (params.scene - 1.0) * (1.0 - w.a) / 0.24;
+        let gain = 1.0 + (params.scene - 1.0) * (1.0 - a) / 0.24;
        let v = top * gain;
        let knee = max(0.6 * params.peak, 1.0);
        var out = v;
@@ -200,10 +185,13 @@ fn calibration_nits(p: vec2<f32>, size: vec2<f32>) -> f32 {
        }
        light *= select(gain, out / max(top, 1e-4), v > knee);
    }
-    if shows && w.a < 0.75 {
-        let band = u32(clamp(floor((w.a + 0.005) / 0.175), 0.0, 3.0));
+    // The world's alpha is below 0.75 on light sources, the sun and the moon
+    // (terrain.wgsl, entity.wgsl): its band of 0.175 is the tier, the lower the
+    // brighter, and where in the band how much (hdr_mark).
+    if shows && a < 0.75 {
+        let band = u32(clamp(floor((a + 0.005) / 0.175), 0.0, 3.0));
        let tier = 3u - band;
-        let lift = 1.0 - clamp((w.a - 0.175 * f32(band)) / 0.165, 0.0, 1.0);
+        let lift = 1.0 - clamp((a - 0.175 * f32(band)) / 0.165, 0.0, 1.0);
        if lift > 0.0 {
            let top = max(light.r, max(light.g, light.b));
            let gain = min(1.0 + (params.peak - 1.0) * params.share[tier] * lift, params.peak / max(top, 1e-4));
@@ -220,9 +208,27 @@ fn calibration_nits(p: vec2<f32>, size: vec2<f32>) -> f32 {
            light = vec3(dot(light, vec3(0.2126, 0.7152, 0.0722)));
        }
    }
-    light = min(light, vec3(params.peak));
-    // The HUD and menus at their own brightness, by how much they cover.
-    light *= mix(1.0, params.ui, ui);
+    return Lit(min(light, vec3(params.peak)), lifted);
+}
+
+// Calibration: above its controls the test picture, straight in nits, past
+// paper white, the lift and the black level.
+fn calibrating(pos: vec4<f32>) -> bool {
+    let size = vec2<f32>(textureDimensions(frame));
+    return params.calibration.x > 0.5 && pos.y < size.y * params.calibration.z;
+}
+
+fn calibration_picture(pos: vec4<f32>) -> vec4<f32> {
+    let nits = vec3(calibration_nits(pos.xy, vec2<f32>(textureDimensions(frame))));
+    if params.pq > 0.5 {
+        return vec4(pq(nits), 1.0);
+    }
+    return vec4(nits / 80.0, 1.0);
+}
+
+// Light in units of paper white, as the swapchain takes it: HDR10 or scRGB, the black level
+// lifted.
+fn display(light: vec3<f32>) -> vec4<f32> {
    let scrgb = light * params.paper;
    if params.pq > 0.5 {
        let e = pq(BT709_TO_BT2020 * scrgb * 80.0);
@@ -233,3 +239,67 @@ fn calibration_nits(p: vec2<f32>, size: vec2<f32>) -> f32 {
    }
    return vec4(scrgb, 1.0);
 }
+
+@fragment fn fs_hdr(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
+    if calibrating(pos) {
+        return calibration_picture(pos);
+    }
+    let at = vec2<i32>(pos.xy);
+    let f = frame_texel(textureLoad(frame, at, 0));
+    // What covers the world here (Hdr::keep_world): nothing at 0, the hand at
+    // 1/255 (Hdr::mark_hand: drawn at the world's brightness), else the HUD or a
+    // menu, by how much.
+    let covered = f.a > 0.0;
+    let hand = covered && f.a < 1.5 / 255.0;
+    let ui = select(f.a, 0.0, hand);
+    let w = frame_texel(textureLoad(world, at, 0));
+    // The world's marks lift only where nothing was drawn over them since: grey text over
+    // the white sun still looks like the sun darkened, but it raised the frame's alpha. The
+    // hand writes its own alpha there (Hdr::hand_light_view): 1, or a light source it holds.
+    let shows = params.world > 0.5 && params.peak > 1.0
+        && (hand || (!covered && shows_world(f.rgb, w.rgb)));
+    var light = lit(f.rgb, w.a, shows).light;
+    // The HUD and menus at their own brightness, by how much they cover.
+    light *= mix(1.0, params.ui, ui);
+    return display(light);
+}
+
+// Hdr::resolve, after the world and the hand: the marks they left (`world` holds the frame as
+// they drew it) become light in the frame, in gamma as the frame stores it, alpha 1. What draws
+// after it (camera overlays, the menu blur) draws on light, and nothing is lifted later.
+@fragment fn fs_resolve(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
+    let w = frame_texel(textureLoad(world, vec2<i32>(pos.xy), 0));
+    let shows = params.world > 0.5 && params.peak > 1.0;
+    return vec4(pow(lit(w.rgb, w.a, shows).light, vec3(1.0 / 2.2)), 1.0);
+}
+
+// Hdr::keep_world: the HUD's backdrop, the world clipped to white with alpha 0, the frame as
+// the HUD found it before.
+@fragment fn fs_keep(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
+    let w = textureLoad(frame, vec2<i32>(pos.xy), 0).rgb;
+    return vec4(clamp(w, vec3(0.0), vec3(1.0)), 0.0);
+}
+
+// The HUD over the world in gamma, the space the HUD blends in: its own part, what its backdrop
+// B doesn't explain (H = P - (1 - c) B, exact for the layering blends), at UI Brightness, over
+// (1 - c) of the world, light above white included. Where the world is at or below white, at
+// 100%, that is the HUD's picture as drawn.
+fn layered(at: vec2<i32>) -> vec3<f32> {
+    let w = max(textureLoad(frame, at, 0).rgb, vec3(0.0));
+    let p = clamp(textureLoad(hud, at, 0).rgb, vec3(0.0), vec3(1.0));
+    let c = textureLoad(coverage, at, 0).r;
+    let h = max(p - (1.0 - c) * min(w, vec3(1.0)), vec3(0.0));
+    return h * pow(params.ui, 1.0 / 2.2) + (1.0 - c) * w;
+}
+
+// Hdr::composite: the picture so far, stored as the frame stores light, for the menu blur.
+@fragment fn fs_composite(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
+    return vec4(layered(vec2<i32>(pos.xy)), 1.0);
+}
+
+@fragment fn fs_hdr_layered(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
+    if calibrating(pos) {
+        return calibration_picture(pos);
+    }
+    return display(min(pow(layered(vec2<i32>(pos.xy)), vec3(2.2)), vec3(params.peak)));
+}
@@ -100,12 +100,18 @@ pub struct HudAtlas {
    /// A resource pack's own `core/rendertype_lines` shader for the block outline, translated;
    /// none draws the outline natively.
    pub lines_shader: Option<std::sync::Arc<horizon_shaders::CoreProgram>>,
+    /// The packs' `core/sky` and `core/stars`, when a pack replaces them.
+    pub sky_shader: Option<std::sync::Arc<horizon_shaders::CoreProgram>>,
+    pub stars_shader: Option<std::sync::Arc<horizon_shaders::CoreProgram>>,
    /// The packs' OptiFine random entity textures, whose variants this atlas packs.
    pub random_textures: horizon_optifine::random_textures::RandomTextures,
    /// Their emissive overlays (`_e`), packed here too.
    pub emissive: std::sync::Arc<horizon_optifine::emissive::Emissive>,
    /// ETF's blinking frames (`_blink`), packed here too.
    pub blinks: horizon_optifine::blink::Blinks,
+    /// Of the shared atlas's textures, their LabPBR normal and specular maps as paged maps
+    /// (`paged_maps.rs`), read while loading for shader packs (`sprites::labpbr_maps`).
+    pub material_maps: std::sync::Arc<[Option<crate::paged_maps::PagedMap>; 2]>,
    white: Rect,
 }
 /// Atlas rows reserved for glyphs rasterized at run time.
@@ -531,6 +537,49 @@ fn cit_sprite(root: &Path, id: &str) -> Option<(PackedImage, Option<TextureFlags
    let flags = mcmeta.as_deref().and_then(TextureFlags::from_mcmeta);
    Some(((name.to_owned(), w, h, pixels), flags, animation.is_some()))
 }
+/// The texture of every `bitmap` font provider. A provider's `file` may name
+/// any texture, so a pack's glyph sheet need not live under `textures/font`.
+fn bitmap_font_textures(root: &Path) -> Vec<PathBuf> {
+    fn jsons(dir: &Path, out: &mut Vec<PathBuf>) {
+        for entry in fs::read_dir(dir).into_iter().flatten().flatten() {
+            let path = entry.path();
+            if path.is_dir() {
+                jsons(&path, out);
+            } else if path.extension().is_some_and(|e| e == "json") {
+                out.push(path);
+            }
+        }
+    }
+    let assets = root.join("assets");
+    let mut defs = Vec::new();
+    for ns in fs::read_dir(&assets).into_iter().flatten().flatten() {
+        jsons(&ns.path().join("font"), &mut defs);
+    }
+    let mut out = Vec::new();
+    let mut seen = HashSet::new();
+    for def in defs {
+        let Ok(bytes) = fs::read(&def) else { continue };
+        let bytes = bytes.strip_prefix(b"\xEF\xBB\xBF").unwrap_or(&bytes);
+        let Ok(json) = serde_json::from_slice::<serde_json::Value>(bytes) else {
+            continue;
+        };
+        for p in json["providers"].as_array().into_iter().flatten() {
+            if p["type"] != "bitmap" {
+                continue;
+            }
+            let Some(file) = p["file"].as_str() else {
+                continue;
+            };
+            let (ns, path) = file.split_once(':').unwrap_or(("minecraft", file));
+            let path = assets.join(ns).join("textures").join(path);
+            if path.is_file() && seen.insert(path.clone()) {
+                out.push(path);
+            }
+        }
+    }
+    out
+}
+
 /// Folders of `assets/minecraft/textures/` that [`HudAtlas::pack`] walks for
 /// the full atlas. A pack may add others through `atlases/blocks.json`.
 const WALKED_TEXTURE_FOLDERS: &[&str] = &[
@@ -845,6 +894,10 @@ impl HudAtlas {
            &[],
            &crate::gfx::core_lines::GLUE,
        );
+        let sky =
+            |name| pack_text::load_core(root, defaults, name, &[], &crate::gfx::core_sky::GLUE);
+        atlas.sky_shader = sky("sky");
+        atlas.stars_shader = sky("stars");
        Ok(atlas)
    }
    /// Empty slots written at run time: map textures (game/maps.rs), the
@@ -924,6 +977,7 @@ impl HudAtlas {
            revision: Self::next_revision(),
            pixels: Vec::new(),
            packed: None,
+            material_maps: Default::default(),
            galactic_widths: [0; 128],
            width: 1,
            height: 1,
@@ -938,6 +992,8 @@ impl HudAtlas {
            glint_armor: (Vec::new(), 1, 1),
            text_shader: None,
            lines_shader: None,
+            sky_shader: None,
+            stars_shader: None,
            random_textures: Default::default(),
            emissive: Arc::default(),
            blinks: Default::default(),
@@ -986,6 +1042,7 @@ impl HudAtlas {
                (glyph_top, height - glyph_top),
                white,
            ),
+            material_maps: Default::default(),
            galactic_widths: galactic_widths(&sprites, &pixels, width, height),
            pixels,
            packed: None,
@@ -1002,6 +1059,8 @@ impl HudAtlas {
            white,
            text_shader: None,
            lines_shader: None,
+            sky_shader: None,
+            stars_shader: None,
            random_textures: Default::default(),
            emissive: Default::default(),
            blinks: Default::default(),
@@ -1102,6 +1161,18 @@ impl HudAtlas {
        for folder in folders {
            walk(&textures.join(folder), &mut files);
        }
+        // A bitmap provider's `file` may be outside the walked folders (HUD
+        // packs keep their glyph sheets under their own namespace or path).
+        // Pack those sheets too, so Font reads them from the atlas instead of
+        // copying every glyph into the small run-time region.
+        if folders.contains(&"font") {
+            let mut seen: HashSet<PathBuf> = files.iter().cloned().collect();
+            files.extend(
+                bitmap_font_textures(root)
+                    .into_iter()
+                    .filter(|p| seen.insert(p.clone())),
+            );
+        }
        // Content mods' entity textures: their equipment assets name them as
        // `<ns>:<path>`, and native mods draw their block entities with them
        // (`native_draw_quad`: `<ns>:entity/...`); and their mob effects'
@@ -1214,7 +1285,16 @@ impl HudAtlas {
            extra.sort();
            files.extend(extra);
        }
-        type Decoded = (PackedImage, Option<TextureFlags>, Option<(u32, u32)>, bool);
+        // A texture's LabPBR maps, as decoded (width, height, RGBA8), for shader packs.
+        type Maps = [Option<(u32, u32, Vec<u8>)>; 2];
+        let read_maps = full && crate::sprites::labpbr_maps();
+        type Decoded = (
+            PackedImage,
+            Option<TextureFlags>,
+            Option<(u32, u32)>,
+            bool,
+            Option<Box<Maps>>,
+        );
        let decode_one = |path: &PathBuf| -> Option<Decoded> {
            let name = if let Some(name) = named.get(path) {
                name.clone()
@@ -1262,11 +1342,21 @@ impl HudAtlas {
            let flags = mcmeta.as_deref().and_then(TextureFlags::from_mcmeta);
            let animated = frames && animation.is_some();
            let (gw, gh) = gui_size.unwrap_or((w, h));
+            let maps = read_maps
+                .then(|| {
+                    let stem = path.file_stem()?.to_str()?;
+                    let maps: Maps = ["_n", "_s"].map(|suffix| {
+                        decode(&path.with_file_name(format!("{stem}{suffix}.png"))).ok()
+                    });
+                    maps.iter().any(Option::is_some).then(|| Box::new(maps))
+                })
+                .flatten();
            (gw <= 1024 && (gh <= 512 || name.starts_with("font/"))).then_some((
                (name, w, h, pixels),
                flags,
                gui_size,
                animated,
+                maps,
            ))
        };
        let threads = std::thread::available_parallelism().map_or(2, |n| n.get());
@@ -1287,7 +1377,11 @@ impl HudAtlas {
        let mut gui_sizes = HashMap::new();
        let mut animated: Vec<String> = Vec::new();
        let mut images: Vec<PackedImage> = Vec::with_capacity(decoded.len());
-        for (image, image_flags, gui_size, is_animated) in decoded {
+        let mut maps: HashMap<String, Box<Maps>> = HashMap::new();
+        for (image, image_flags, gui_size, is_animated, image_maps) in decoded {
+            if let Some(m) = image_maps {
+                maps.insert(image.0.clone(), m);
+            }
            if let Some(f) = image_flags {
                flags.insert(image.0.clone(), f);
            }
@@ -1462,11 +1556,34 @@ impl HudAtlas {
            }
            sprite_animations.push((rect, animation));
        }
+        // Each mapped texture's maps at its size in the atlas, paged.
+        let material_maps = if maps.is_empty() {
+            Default::default()
+        } else {
+            let mapped: Vec<crate::paged_maps::SpriteMaps> = maps
+                .iter()
+                .filter_map(|(name, m)| {
+                    let rect = sprites.get(name)?;
+                    let (tw, th) = rect.texels((width, height));
+                    let x = (rect.u0 * width as f32).round() as u32;
+                    let y = (rect.v0 * height as f32).round() as u32;
+                    Some(crate::paged_maps::SpriteMaps {
+                        rect: [x, y, tw, th],
+                        maps: m.each_ref().map(|map| {
+                            let (mw, mh, pixels) = map.as_ref()?;
+                            crate::paged_maps::fit(pixels, (*mw, *mh), (tw, th))
+                        }),
+                    })
+                })
+                .collect();
+            crate::paged_maps::build((width, height), &mapped, MAX_ATLAS_SIZE)
+        };
        let white = sprites["horizon/white"];
        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(
+        let font = crate::font::Font::load_over(
            root,
+            defaults,
            &sprites,
            &pixels,
            (width, height),
@@ -1475,6 +1592,7 @@ impl HudAtlas {
        );
        Ok(Self {
            revision: Self::next_revision(),
+            material_maps: std::sync::Arc::new(material_maps),
            galactic_widths: galactic_widths(&sprites, &pixels, width, height),
            pixels,
            packed: None,
@@ -1490,6 +1608,8 @@ impl HudAtlas {
            glint_armor,
            text_shader: None,
            lines_shader: None,
+            sky_shader: None,
+            stars_shader: None,
            random_textures,
            emissive,
            blinks,
@@ -2379,17 +2499,19 @@ impl HudUniform {
        }
    }
 }
+use crate::gfx::hud_coverage::{self, Pipeline};
+
 pub struct HudRenderer {
    pub sprite_animations: Vec<(Rect, crate::sprites::SpriteAnimation, (usize, usize, u32))>,
    /// The shared atlas texture, for run-time glyph uploads.
    pub atlas_texture: Option<wgpu::Texture>,
-    pipeline: wgpu::RenderPipeline,
+    pipeline: Pipeline,
    /// `RenderPipelines.CROSSHAIR`.
-    invert_pipeline: wgpu::RenderPipeline,
-    additive_pipeline: wgpu::RenderPipeline,
-    depth_pipeline: wgpu::RenderPipeline,
-    vignette_pipeline: wgpu::RenderPipeline,
-    end_portal_pipeline: wgpu::RenderPipeline,
+    invert_pipeline: Pipeline,
+    additive_pipeline: Pipeline,
+    depth_pipeline: Pipeline,
+    vignette_pipeline: Pipeline,
+    end_portal_pipeline: Pipeline,
    /// The layout of `group`, which the CIT glint pipelines share.
    layout: wgpu::BindGroupLayout,
    group: wgpu::BindGroup,
@@ -2399,6 +2521,7 @@ pub struct HudRenderer {
    buffer: wgpu::Buffer,
    capacity: u64,
    format: wgpu::TextureFormat,
+    coverage: bool,
    atlas_view: wgpu::TextureView,
    /// The resource pack's text shader, when it has one that works.
    pack_text: Option<pack_text::PackText>,
@@ -2413,6 +2536,7 @@ impl HudRenderer {
        view: &wgpu::TextureView,
        glint_view: &wgpu::TextureView,
        glint_sampler: &wgpu::Sampler,
+        coverage: bool,
    ) -> Result<Self> {
        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("Horizon HUD"),
@@ -2525,7 +2649,7 @@ impl HudRenderer {
        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 {
+            let desc = wgpu::RenderPipelineDescriptor {
                label: Some(label),
                layout: Some(&pipeline_layout),
                vertex: wgpu::VertexState {
@@ -2559,7 +2683,9 @@ impl HudRenderer {
                }),
                multiview_mask: None,
                cache: None,
-            })
+            };
+            let source = wgpu::ShaderSource::Wgsl(include_str!("hud.wgsl").into());
+            Pipeline::new(device, &desc, source, coverage).expect("the HUD's coverage")
        };
        let pipeline = create("HUD", wgpu::BlendState::ALPHA_BLENDING, "fs_main", false);
        let depth_pipeline = create(
@@ -2650,6 +2776,7 @@ impl HudRenderer {
            buffer,
            capacity,
            format,
+            coverage,
            atlas_view: view.clone(),
            pack_text: None,
            zoom: 1.0,
@@ -2664,7 +2791,7 @@ impl HudRenderer {
        textures: Option<&cit_glint::GlintTextures>,
    ) {
        self.cit_glint = textures.and_then(|t| {
-            cit_glint::CitGlintPass::new(device, queue, self.format, &self.layout, t)
+            cit_glint::CitGlintPass::new(device, queue, self.format, &self.layout, t, self.coverage)
        });
    }
    /// Draw the GUI's text with `shader` (`HudAtlas::text_shader`), or natively.
@@ -2674,7 +2801,7 @@ impl HudRenderer {
        shader: Option<&horizon_shaders::CoreProgram>,
    ) {
        self.pack_text = shader.and_then(|shader| {
-            pack_text::PackText::new(device, self.format, &self.atlas_view, shader)
+            pack_text::PackText::new(device, self.format, &self.atlas_view, shader, self.coverage)
        });
    }
    pub fn animate_sprites(
@@ -2823,6 +2950,7 @@ impl HudRenderer {
        self.draw_range(
            encoder,
            target,
+            None,
            depth,
            batch,
            size,
@@ -2836,6 +2964,7 @@ impl HudRenderer {
        &self,
        encoder: &mut wgpu::CommandEncoder,
        target: &wgpu::TextureView,
+        coverage: Option<&wgpu::TextureView>,
        depth: &wgpu::TextureView,
        batch: &HudBatch,
        size: [u32; 2],
@@ -2845,7 +2974,7 @@ impl HudRenderer {
        if vertices.is_empty() || size.contains(&0) {
            return;
        }
-        let attachments = [Some(wgpu::RenderPassColorAttachment {
+        let mut attachments = vec![Some(wgpu::RenderPassColorAttachment {
            view: target,
            resolve_target: None,
            depth_slice: None,
@@ -2854,6 +2983,9 @@ impl HudRenderer {
                store: wgpu::StoreOp::Store,
            },
        })];
+        if let Some(view) = coverage {
+            attachments.push(Some(hud_coverage::attachment(view)));
+        }
        let runs = batch.runs_in(vertices);
        let mut at = 0;
        while at < runs.len() {
@@ -2905,16 +3037,17 @@ impl HudRenderer {
                    Blend::EndPortal => &self.end_portal_pipeline,
                    Blend::CitGlint(blend) => {
                        if let Some(cit) = &self.cit_glint {
-                            cit.draw(&mut pass, *blend, range.clone());
+                            cit.draw(&mut pass, *blend, range.clone(), coverage.is_some());
                        }
                        continue;
                    }
                };
+                let pipeline = pipeline.get(coverage.is_some());
                match &self.pack_text {
                    Some(pack_text) if *blend == Blend::Alpha => {
                        for (part, text) in pack_text::text_runs(&batch.vertices, range.clone()) {
                            if text {
-                                pack_text.draw(&mut pass, part);
+                                pack_text.draw(&mut pass, part, coverage.is_some());
                                pass.set_bind_group(0, &self.group, &[]);
                            } else {
                                pass.set_pipeline(pipeline);
@@ -2933,6 +3066,10 @@ impl HudRenderer {
    }
 }

+#[cfg(test)]
+#[path = "hud/coverage_tests.rs"]
+mod coverage_tests;
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -3891,6 +4028,30 @@ texture=wide",
            assert_eq!(((r.w, r.h), r.texels(size)), (gui, texels), "{name}");
        }
    }
+    /// A bitmap font's `file` may be any texture, not only one under
+    /// `textures/font`; the atlas packs it so the font can read its glyphs
+    /// from there instead of copying them into the run-time region.
+    #[test]
+    fn a_bitmap_font_sheet_outside_font_is_packed() {
+        let root = std::env::temp_dir().join(format!("horizon-font-pack-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&root);
+        write_png(&root, "hud/sheet", 16, 8);
+        let def = root.join("assets/minecraft/font/default.json");
+        fs::create_dir_all(def.parent().unwrap()).unwrap();
+        fs::write(
+            &def,
+            r#"{"providers":[{"type":"bitmap","file":"minecraft:hud/sheet.png","ascent":7,"chars":["ab"]}]}"#,
+        )
+        .unwrap();
+        let atlas = HudAtlas::build(&root).unwrap();
+        let _ = fs::remove_dir_all(&root);
+        let rect = atlas
+            .sprites
+            .get("hud/sheet")
+            .expect("the font sheet is packed");
+        assert_eq!(rect.texels((atlas.width, atlas.height)), (16, 8));
+    }
+
    /// A content mod's GUI textures join the atlas under its namespace;
    /// its other textures and vanilla's names stay as they were.
    #[test]
@@ -4010,6 +4171,52 @@ texture=wide",
            .unwrap();
        root
    }
+    /// A pack layer that adds a font provider over the game's own resources:
+    /// its `font/default.json` names `minecraft:font/test.png`, which only the
+    /// game's root holds (`HudAtlas::build_over`'s `defaults`).
+    fn pack_font_over_defaults(name: &str) -> (PathBuf, PathBuf) {
+        let base = std::env::temp_dir().join(format!(
+            "horizon-font-fallback-{name}-{}",
+            std::process::id()
+        ));
+        let pack = base.join("pack");
+        let vanilla = base.join("vanilla");
+        fs::create_dir_all(pack.join("assets/minecraft/font")).unwrap();
+        fs::create_dir_all(vanilla.join("assets/minecraft/textures/font")).unwrap();
+        fs::write(
+            pack.join("assets/minecraft/font/default.json"),
+            r#"{"providers":[{"type":"bitmap","file":"minecraft:font/test.png","ascent":7,"chars":["ab"]}]}"#,
+        )
+        .unwrap();
+        let mut pixels = vec![0u8; 16 * 8 * 4];
+        for y in 0..8 {
+            for x in (0..3).chain(8..13) {
+                pixels[(y * 16 + x) * 4 + 3] = 255;
+            }
+        }
+        let mut encoder = png::Encoder::new(
+            fs::File::create(vanilla.join("assets/minecraft/textures/font/test.png")).unwrap(),
+            16,
+            8,
+        );
+        encoder.set_color(png::ColorType::Rgba);
+        encoder.set_depth(png::BitDepth::Eight);
+        encoder
+            .write_header()
+            .unwrap()
+            .write_image_data(&pixels)
+            .unwrap();
+        (pack, vanilla)
+    }
+    #[test]
+    fn a_pack_overlay_reads_font_sheets_from_the_game_below_it() {
+        let (pack, vanilla) = pack_font_over_defaults("sheets");
+        let atlas = HudAtlas::build_over(&pack, &vanilla).unwrap();
+        let glyph = atlas.font.glyph('a');
+        let _ = fs::remove_dir_all(pack.parent().unwrap());
+        assert!(glyph.rect.is_some(), "text draws, not the missing glyph");
+        assert!(glyph.advance > 0.0);
+    }
    #[test]
    fn the_fonts_only_atlas_measures_text_like_the_full_one() {
        let root = two_glyph_font("atlas");
@@ -5,6 +5,7 @@
 //! vanilla's glint's is. Without enchantment rules nothing here is made.

 use super::HudVertex;
+use crate::gfx::hud_coverage::Pipeline;
 use horizon_optifine::cit::{Blend, Factor, Kind, Rule};
 use std::path::Path;

@@ -230,7 +231,7 @@ pub fn blend_state(blend: Option<Blend>) -> wgpu::BlendState {
 /// pipeline per blend.
 pub(super) struct CitGlintPass {
    group: wgpu::BindGroup,
-    pipelines: Vec<wgpu::RenderPipeline>,
+    pipelines: Vec<Pipeline>,
 }

 impl CitGlintPass {
@@ -241,6 +242,7 @@ impl CitGlintPass {
        format: wgpu::TextureFormat,
        hud: &wgpu::BindGroupLayout,
        textures: &GlintTextures,
+        coverage: bool,
    ) -> Option<Self> {
        use wgpu::util::DeviceExt;
        if textures.is_empty() {
@@ -381,7 +383,7 @@ impl CitGlintPass {
            .blends
            .iter()
            .map(|&blend| {
-                device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                let desc = wgpu::RenderPipelineDescriptor {
                    label: Some("CIT glint"),
                    layout: Some(&pipeline_layout),
                    vertex: wgpu::VertexState {
@@ -409,7 +411,9 @@ impl CitGlintPass {
                    }),
                    multiview_mask: None,
                    cache: None,
-                })
+                };
+                let source = wgpu::ShaderSource::Wgsl(include_str!("../hud.wgsl").into());
+                Pipeline::new(device, &desc, source, coverage).expect("the CIT glint's coverage")
            })
            .collect();
        Some(Self { group, pipelines })
@@ -421,9 +425,10 @@ impl CitGlintPass {
        pass: &mut wgpu::RenderPass<'_>,
        blend: u8,
        vertices: std::ops::Range<u32>,
+        coverage: bool,
    ) {
        if let Some(pipeline) = self.pipelines.get(usize::from(blend)) {
-            pass.set_pipeline(pipeline);
+            pass.set_pipeline(pipeline.get(coverage));
            pass.set_bind_group(1, &self.group, &[]);
            pass.draw(vertices, 0..1);
        }
@@ -0,0 +1,311 @@
+use super::*;
+use crate::gfx::hud_coverage;
+
+struct Gpu {
+    device: wgpu::Device,
+    queue: wgpu::Queue,
+    hud: HudRenderer,
+}
+
+impl Gpu {
+    fn new() -> Option<Self> {
+        let instance = crate::gfx::test_gpu::instance();
+        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
+        if !hud_coverage::supported(
+            (false, true, true),
+            true,
+            adapter.limits().max_color_attachments,
+            adapter.get_downlevel_capabilities().flags,
+            adapter.get_texture_format_features(hud_coverage::FORMAT),
+        ) {
+            eprintln!("skipping HUD coverage: adapter lacks independent blending or R8 rendering");
+            return None;
+        }
+        let (device, queue) =
+            pollster::block_on(adapter.request_device(&Default::default())).ok()?;
+        let atlas = device.create_texture_with_data(
+            &queue,
+            &wgpu::TextureDescriptor {
+                label: None,
+                size: wgpu::Extent3d {
+                    width: 2,
+                    height: 1,
+                    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,
+            &[255, 255, 255, 255, 255, 255, 255, 0],
+        );
+        let view = atlas.create_view(&Default::default());
+        let hud = HudRenderer::new(
+            &device,
+            wgpu::TextureFormat::Rgba16Float,
+            &view,
+            &view,
+            &device.create_sampler(&Default::default()),
+            true,
+        )
+        .unwrap();
+        Some(Self { device, queue, hud })
+    }
+
+    fn texture(&self, format: wgpu::TextureFormat) -> wgpu::Texture {
+        self.device.create_texture(&wgpu::TextureDescriptor {
+            label: None,
+            size: wgpu::Extent3d {
+                width: 4,
+                height: 2,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+            view_formats: &[],
+        })
+    }
+
+    fn draw(&self, batch: &HudBatch, initial: f64, coverage: bool) -> (Vec<u8>, Vec<u8>) {
+        let frame = self.texture(wgpu::TextureFormat::Rgba16Float);
+        let mask = self.texture(hud_coverage::FORMAT);
+        let depth = self.texture(wgpu::TextureFormat::Depth32Float);
+        let [frame_view, mask_view, depth_view] =
+            [&frame, &mask, &depth].map(|t| t.create_view(&Default::default()));
+        self.queue
+            .write_buffer(&self.hud.buffer, 0, bytemuck::cast_slice(&batch.vertices));
+        self.queue.write_buffer(
+            &self.hud.uniform,
+            0,
+            bytemuck::bytes_of(&HudUniform::new([4.0, 2.0, 1.0, 0.75], batch.end_portal, 0)),
+        );
+        let mut encoder = self.device.create_command_encoder(&Default::default());
+        for (view, value) in [(&frame_view, 0.3), (&mask_view, initial)] {
+            let mut attachment = hud_coverage::attachment(view);
+            attachment.ops.load = wgpu::LoadOp::Clear(wgpu::Color {
+                r: value,
+                g: value,
+                b: value,
+                a: value,
+            });
+            encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                color_attachments: &[Some(attachment)],
+                ..Default::default()
+            });
+        }
+        self.hud.draw_range(
+            &mut encoder,
+            &frame_view,
+            coverage.then_some(&mask_view),
+            &depth_view,
+            batch,
+            [4, 2],
+            0..batch.vertices.len() as u32,
+            None,
+        );
+        let buffers = [&frame, &mask].map(|t| {
+            let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
+                label: None,
+                size: 512,
+                usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+                mapped_at_creation: false,
+            });
+            encoder.copy_texture_to_buffer(
+                t.as_image_copy(),
+                wgpu::TexelCopyBufferInfo {
+                    buffer: &buffer,
+                    layout: wgpu::TexelCopyBufferLayout {
+                        offset: 0,
+                        bytes_per_row: Some(256),
+                        rows_per_image: None,
+                    },
+                },
+                t.size(),
+            );
+            buffer
+        });
+        self.queue.submit([encoder.finish()]);
+        let [color, mask] = buffers.map(|buffer| {
+            buffer.map_async(wgpu::MapMode::Read, .., |r| r.unwrap());
+            self.device
+                .poll(wgpu::PollType::wait_indefinitely())
+                .unwrap();
+            buffer.get_mapped_range(..).unwrap().to_vec()
+        });
+        (
+            color
+                .chunks(256)
+                .flat_map(|r| r[..32].iter().copied())
+                .collect(),
+            mask.chunks(256)
+                .flat_map(|r| r[..4].iter().copied())
+                .collect(),
+        )
+    }
+
+    fn check(&self, batch: &HudBatch, initial: f64, expected: [u8; 4]) {
+        let (plain, _) = self.draw(batch, initial, false);
+        let (color, mask) = self.draw(batch, initial, true);
+        assert_eq!(color, plain, "coverage changed the primary colour or alpha");
+        for (got, want) in mask.iter().zip(expected.repeat(2)) {
+            assert!(
+                got.abs_diff(want) <= 1,
+                "coverage {mask:?}, expected {expected:?}"
+            );
+        }
+    }
+}
+
+fn quad(batch: &mut HudBatch, blend: Blend, color: u32, x: f32, uv: f32) {
+    let start = batch.vertices.len();
+    batch.quad(
+        [[x, 0.0], [x + 2.0, 0.0], [x + 2.0, 2.0], [x, 2.0]],
+        [[uv, 0.5]; 4],
+        color,
+    );
+    batch.blend_since(start, blend);
+}
+
+#[test]
+fn coverage_follows_hud_blends_discard_scissor_and_depth_without_changing_colour() {
+    let Some(gpu) = Gpu::new() else {
+        return;
+    };
+    for (blend, color, initial, count, expected) in [
+        (Blend::Alpha, rgba(255, 255, 255, 128), 0.0, 2, 192),
+        (Blend::Additive, rgba(255, 255, 255, 128), 0.3, 1, 77),
+        (Blend::Invert, rgba(255, 255, 255, 32), 0.0, 1, 255),
+        (Blend::EndPortal, rgba(255, 255, 255, 255), 0.0, 1, 255),
+        (Blend::Vignette, rgba(102, 102, 102, 255), 0.0, 1, 102),
+    ] {
+        let mut batch = HudBatch::new([4, 2]);
+        for _ in 0..count {
+            quad(&mut batch, blend, color, 0.0, 0.25);
+        }
+        // Crosshair fragments with zero texture alpha discard; EndPortal has no discard.
+        if blend == Blend::Invert {
+            quad(&mut batch, blend, color, 2.0, 0.75);
+        }
+        gpu.check(
+            &batch,
+            initial,
+            [
+                expected,
+                expected,
+                (initial * 255.0).round() as u8,
+                (initial * 255.0).round() as u8,
+            ],
+        );
+    }
+    let mut batch = HudBatch::new([4, 2]);
+    for depth in [0.25, 0.75] {
+        quad(
+            &mut batch,
+            Blend::Alpha,
+            rgba(255, 255, 255, 128),
+            0.0,
+            0.25,
+        );
+        let start = batch.vertices.len() - 6;
+        for vertex in &mut batch.vertices[start..] {
+            vertex.depth = depth;
+        }
+    }
+    batch.blends.push((0..12, Blend::Depth([1, 0, 2, 2])));
+    gpu.check(&batch, 0.0, [0, 128, 0, 0]);
+}
+
+#[test]
+fn coverage_preserves_each_cit_blend_and_its_destination_alpha() {
+    let Some(mut gpu) = Gpu::new() else {
+        return;
+    };
+    use horizon_optifine::cit::parse_blend;
+    for (name, expected) in [
+        ("alpha", 128),
+        ("add", 0),
+        ("dodge", 0),
+        ("glint", 0),
+        ("burn", 102),
+        ("multiply", 26),
+        ("overlay", 51),
+        ("screen", 255),
+        ("subtract", 255),
+        ("replace", 255),
+        ("0 768", 153),
+        ("774 0", 153),
+        ("770 771 772 773", 128),
+    ] {
+        let textures = cit_glint::GlintTextures {
+            width: 1,
+            height: 1,
+            pixels: vec![102, 102, 102, 128],
+            slots: vec![cit_glint::Slot {
+                rgba: [1.0; 4],
+                blur: false,
+                blend: 0,
+            }],
+            blends: vec![parse_blend(name).unwrap()],
+            ..Default::default()
+        };
+        gpu.hud
+            .set_cit_glints(&gpu.device, &gpu.queue, Some(&textures));
+        let mut batch = HudBatch::new([4, 2]);
+        quad(
+            &mut batch,
+            Blend::CitGlint(0),
+            rgba(0, 0, 0, 255),
+            0.0,
+            0.25,
+        );
+        quad(
+            &mut batch,
+            Blend::CitGlint(0),
+            rgba(0, 0, 0, 255),
+            2.0,
+            0.75,
+        );
+        gpu.check(&batch, 0.0, [expected, expected, 0, 0]);
+    }
+}
+
+#[test]
+fn coverage_uses_pack_texts_final_alpha_and_discard() {
+    let Some(mut gpu) = Gpu::new() else {
+        return;
+    };
+    // A translated-style struct result and early return; no dependency on game resources.
+    let program = horizon_shaders::CoreProgram {
+        vertex: naga::front::wgsl::parse_str("@vertex fn main(@location(0) p: vec2<f32>) -> @builtin(position) vec4<f32> { return vec4(p.x / 2.0 - 1.0, 1.0 - p.y, 0.0, 1.0); }").unwrap(),
+        fragment: naga::front::wgsl::parse_str("struct Result { @location(0) color: vec4<f32> } @fragment fn main(@builtin(position) p: vec4<f32>) -> Result { if p.x > 2.0 { discard; } return Result(vec4(0.4, 0.2, 0.1, 0.5)); }").unwrap(),
+    };
+    gpu.hud.set_text_shader(&gpu.device, Some(&program));
+    assert!(gpu.hud.pack_text.is_some());
+    let mut batch = HudBatch::new([4, 2]);
+    for x in [0.0, 2.0, 0.0, 2.0] {
+        quad(&mut batch, Blend::Alpha, rgba(255, 255, 255, 255), x, 0.25);
+    }
+    for v in &mut batch.vertices {
+        v.text = 1;
+    }
+    gpu.check(&batch, 0.0, [191, 191, 0, 0]);
+}
+
+#[test]
+fn a_pack_text_shader_without_a_colour_output_is_dropped_not_wrapped() {
+    let Some(mut gpu) = Gpu::new() else {
+        return;
+    };
+    let program = horizon_shaders::CoreProgram {
+        vertex: naga::front::wgsl::parse_str("@vertex fn main(@location(0) p: vec2<f32>) -> @builtin(position) vec4<f32> { return vec4(p, 0.0, 1.0); }").unwrap(),
+        fragment: naga::front::wgsl::parse_str("@fragment fn main() -> @location(1) vec4<f32> { return vec4(1.0); }").unwrap(),
+    };
+    gpu.hud.set_text_shader(&gpu.device, Some(&program));
+    assert!(gpu.hud.pack_text.is_none());
+}
@@ -8,6 +8,7 @@ use std::sync::Arc;
 use horizon_shaders::{CoreProgram, Glue};

 use super::{HudBatch, HudVertex};
+use crate::gfx::hud_coverage::Pipeline;

 /// GUI text's vertex format (`POSITION_TEX_COLOR`) from the HUD's vertices. A glyph is two
 /// triangles here, its corners top left, top right, bottom right, top left, bottom right, bottom
@@ -81,7 +82,7 @@ const BLOCK_SIZES: [u64; 4] = [48, 64, 160, 48];

 /// The pipeline and its resources.
 pub(super) struct PackText {
-    pipeline: wgpu::RenderPipeline,
+    pipeline: Pipeline,
    group: wgpu::BindGroup,
    uniform: wgpu::Buffer,
 }
@@ -92,6 +93,7 @@ impl PackText {
        format: wgpu::TextureFormat,
        atlas: &wgpu::TextureView,
        program: &CoreProgram,
+        coverage: bool,
    ) -> Option<Self> {
        let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
        let module = |label, module: &naga::Module| {
@@ -179,7 +181,7 @@ impl PackText {
            ..Default::default()
        });
        let attributes = wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4];
-        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        let desc = wgpu::RenderPipelineDescriptor {
            label: Some("Resource pack text"),
            layout: Some(&pipeline_layout),
            vertex: wgpu::VertexState {
@@ -208,11 +210,17 @@ impl PackText {
            }),
            multiview_mask: None,
            cache: None,
-        });
+        };
+        let source = wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(program.fragment.clone()));
+        let pipeline = Pipeline::new(device, &desc, source, coverage);
        if let Some(e) = pollster::block_on(scope.pop()) {
            log::warn!("the resource pack's text shader is not used: {e}");
            return None;
        }
+        let Some(pipeline) = pipeline else {
+            log::warn!("the resource pack's text shader is not used: it has no colour output");
+            return None;
+        };
        Some(Self {
            pipeline,
            group,
@@ -234,8 +242,13 @@ impl PackText {

    /// Draw `range` (whole glyph quads) with the pack's shader; the caller sets its own
    /// pipeline and bind group again after.
-    pub(super) fn draw(&self, pass: &mut wgpu::RenderPass<'_>, range: std::ops::Range<u32>) {
-        pass.set_pipeline(&self.pipeline);
+    pub(super) fn draw(
+        &self,
+        pass: &mut wgpu::RenderPass<'_>,
+        range: std::ops::Range<u32>,
+        coverage: bool,
+    ) {
+        pass.set_pipeline(self.pipeline.get(coverage));
        pass.set_bind_group(0, &self.group, &[]);
        pass.draw(range.clone(), range.start..range.start + 1);
    }
@@ -84,6 +84,7 @@ pub mod pack_screen;
 pub mod packs;
 pub mod pad_cursor;
 pub mod pad_glyph;
+pub mod paged_maps;
 pub mod par;
 pub mod particles;
 pub mod poi_sections;
@@ -94,6 +95,7 @@ pub mod preedit;
 pub mod providers;
 pub mod pvp;
 pub mod pvp_hud;
+pub mod random_source;
 pub mod screen_draw;
 pub mod screen_effects;
 pub mod sculk;
@@ -559,7 +559,8 @@ pub(crate) fn state_kinds(facts: &BlockFacts) -> Vec<u8> {
 }
 /// Blocks that fill their cell but neither draw solid nor collide as a full
 /// block: far terrain draws them as blocks, or patches of powder snow leave
-/// holes in mountains (and paths and fields dips).
+/// holes in mountains (and paths and fields dips). Slabs use the same
+/// full-cell approximation as stairs, so distant slab builds remain visible.
 fn nearly_full(name: &str) -> bool {
    matches!(
        name,
@@ -568,6 +569,7 @@ fn nearly_full(name: &str) -> bool {
            | "minecraft:farmland"
            | "minecraft:honey_block"
    ) || name.ends_with("_stairs")
+        || name.ends_with("_slab")
        || name.contains("fence")
        || name.contains("_wall")
        || name.contains("bars")
@@ -3977,6 +3979,73 @@ mod tests {
    }
    #[test]
    #[ignore = "requires prepared models/textures in HORIZON_TEST_RESOURCES"]
+    fn slab_materials_survive_chunk_summaries_and_draw_far_faces() -> crate::Result<()> {
+        use crate::{assets::Assets, biome::Biomes, light::LightTables, mesher::MeshTables};
+        let root = std::path::PathBuf::from(
+            std::env::var_os("HORIZON_TEST_RESOURCES").expect("HORIZON_TEST_RESOURCES"),
+        );
+        let assets = Arc::new(Assets::load(&root)?);
+        let render = Arc::new(assets.reload(&root)?);
+        let facts = BlockFacts::load(&root, assets.registry)?;
+        let context = WorkerContext {
+            light: Arc::new(LightTables::load(&root, assets.registry, &facts)?),
+            tables: Arc::new(MeshTables::new(
+                &assets,
+                &render,
+                &facts,
+                crate::models::load_visibility(&root, assets.registry)?,
+            )?),
+            assets: assets.clone(),
+            render,
+            biomes: Arc::new(Biomes::load(&root)?),
+        };
+        let kinds = state_kinds(&facts);
+        let mut chunk = Chunk::empty(0, 0);
+        let mut mesher = mesh::Mesher::default();
+        let mut materials = FxHashSet::default();
+        // Real top, bottom, double and waterlogged states: a waterlogged slab
+        // must keep its material rather than become a column of plain water.
+        for (i, f) in facts.states.iter().enumerate() {
+            if !f.name.ends_with("_slab") {
+                continue;
+            }
+            materials.insert(f.name.as_ref());
+            let state = BlockStateId(i as u32);
+            chunk.set(3, 90, 3, state.0);
+            let columns = summarize(&chunk, &kinds);
+            let column = &columns[3 * 16 + 3];
+            assert_eq!(column.spans.len(), 1, "{} state {i}", f.name);
+            assert_eq!(column.spans[0].state, state, "{} state {i}", f.name);
+            assert_eq!((column.spans[0].min, column.spans[0].max), (90, 91));
+            assert_eq!(Column::reduced(&columns, 0, 0, 4).spans, column.spans);
+            let mesh = mesher.mesh(
+                TileKey {
+                    x: 0,
+                    z: 0,
+                    level: 0,
+                },
+                &columns.iter().collect::<Vec<_>>(),
+                &FxHashSet::default(),
+                None,
+                &context,
+                &std::array::from_fn(|_| Vec::new()),
+                &[],
+            );
+            // Like stairs, far slabs use the existing full-cell approximation.
+            assert_eq!(mesh.solid.len(), 6 * 4, "{} state {i}", f.name);
+            assert!(mesh.translucent.is_empty(), "{} state {i}", f.name);
+        }
+        for name in [
+            "minecraft:smooth_stone_slab",
+            "minecraft:oak_slab",
+            "minecraft:cut_copper_slab",
+        ] {
+            assert!(materials.contains(name), "missing fixture {name}");
+        }
+        Ok(())
+    }
+    #[test]
+    #[ignore = "requires prepared models/textures in HORIZON_TEST_RESOURCES"]
    fn real_mesh_clips_near_chunks_and_preserves_water_and_edited_surfaces() -> crate::Result<()> {
        use crate::{
            assets::Assets, biome::Biomes, light::LightTables, mesher::MeshTables,
@@ -202,20 +202,44 @@ impl MenuBlur {
        target: &wgpu::TextureView,
        size: [u32; 2],
        radius: f32,
-        mut timing: Option<&mut crate::gfx::pack_timing::PassTiming>,
+        timing: Option<&mut crate::gfx::pack_timing::PassTiming>,
    ) {
-        self.ensure(device, size);
-        let work = self.work_size(size);
-        let copy = if self.half { 2 } else { 0 };
+        let copy = self.source(device, size).0;
        encoder.copy_texture_to_texture(
            frame.as_image_copy(),
-            self.targets[copy].0.as_image_copy(),
+            copy.as_image_copy(),
            wgpu::Extent3d {
                width: size[0],
                height: size[1],
                depth_or_array_layers: 1,
            },
        );
+        self.blur(device, queue, encoder, target, size, radius, timing);
+    }
+    /// The blur's copy of a frame of `size`, for a picture drawn into it rather than copied
+    /// (HDR output's composite, `Hdr::composite`), then `blur`.
+    pub fn source(
+        &mut self,
+        device: &wgpu::Device,
+        size: [u32; 2],
+    ) -> (wgpu::Texture, wgpu::TextureView) {
+        self.ensure(device, size);
+        self.targets[if self.half { 2 } else { 0 }].clone()
+    }
+    /// Blur what `source` holds into `target`, as `apply` blurs its copy of the frame.
+    #[allow(clippy::too_many_arguments)]
+    pub fn blur(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        encoder: &mut wgpu::CommandEncoder,
+        target: &wgpu::TextureView,
+        size: [u32; 2],
+        radius: f32,
+        mut timing: Option<&mut crate::gfx::pack_timing::PassTiming>,
+    ) {
+        self.ensure(device, size);
+        let work = self.work_size(size);
        let radius = if self.half { radius / 2.0 } else { radius };
        if self.half {
            // A radius of 0 samples each half-size pixel's 2x2 block at its shared
@@ -9,19 +9,22 @@ fn oit_terrain_color(in: TerrainOut) -> vec4<f32> {
 }
 // Stage 1: (-nearest, furthest, nearest device depth, nearest opaque device
 // depth), combined by max blending.
-@fragment fn fs_oit_bounds(in: TerrainOut) -> @location(0) vec4<f32> {
+@fragment fn fs_oit_bounds(wire: TerrainWire) -> @location(0) vec4<f32> {
+    let in = from_wire(wire);
    let color = oit_terrain_color(in);
    let linear = oit_linear_depth(in.clip.z);
    let opaque = select(0.0, in.clip.z, color.a > OIT_FULLY_OPAQUE_ALPHA);
    return vec4(-linear, linear, in.clip.z, opaque);
 }
 // Stage 2.
-@fragment fn fs_oit_transmittance(in: TerrainOut) -> OitCoefficients {
+@fragment fn fs_oit_transmittance(wire: TerrainWire) -> OitCoefficients {
+    let in = from_wire(wire);
    let color = oit_terrain_color(in);
    return oit_add_transmittance(1.0 - color.a, in.clip.z, in.clip.xy);
 }
 // Stage 3: premultiplied colour, weighted by the transmittance in front.
-@fragment fn fs_oit_accumulate(in: TerrainOut) -> @location(0) vec4<f32> {
+@fragment fn fs_oit_accumulate(wire: TerrainWire) -> @location(0) vec4<f32> {
+    let in = from_wire(wire);
    let color = oit_terrain_color(in);
    let seen = oit_sample_transmittance(vec2<i32>(in.clip.xy),
        oit_normalize_depth(in.clip.z, in.clip.xy), 1.0 - color.a);
@@ -42,7 +45,12 @@ struct OitFragment {
@fragment fn fs_oit_cull(@builtin(position) pos: vec4<f32>) -> OitFragment {
    let b = textureLoad(oit_bounds, vec2<i32>(pos.xy), 0);
    let opaque = oit_linear_depth(b.a);
-    return OitFragment(vec4(b.r, min(b.g, opaque), b.b, b.a), b.a);
+    // The later stages test GreaterEqual against this depth, so the opaque fragment itself must still
+    // pass: Metal's `position.z` can differ from the rasterizer's depth by an ulp, which dropped
+    // random pixels of an opaque body. A few ulps farther (a positive float's bits minus one is
+    // the next smaller value) keeps it, and culls anything behind it by a visible distance.
+    let culled_depth = select(0.0, bitcast<f32>(bitcast<u32>(b.a) - 4u), b.a > 0.0);
+    return OitFragment(vec4(b.r, min(b.g, opaque), b.b, b.a), culled_depth);
 }
 // The sum over the world, renormalized to the coverage the transform gives.
@fragment fn fs_oit_composite(@builtin(position) pos: vec4<f32>) -> OitFragment {
@@ -20,6 +20,14 @@ use crate::{
 fn tr(key: &str) -> Text {
    Text::translate(key, &[])
 }
+
+/// False only in a game built without the `horizon-extras` feature (docs/forking.md), which says
+/// so once at startup: the Options screen then has vanilla's Telemetry Data slot instead of
+/// Horizon Settings and Mods, and Credits & Attribution names the official build.
+pub static HORIZON_EXTRAS: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(true);
+fn horizon_extras() -> bool {
+    HORIZON_EXTRAS.load(std::sync::atomic::Ordering::Relaxed)
+}
 fn generic(caption: &str, value: Text) -> Text {
    Text::translate("options.generic_value", &[tr(caption), value])
 }
@@ -304,11 +312,13 @@ impl Opt {
            Opt::PadRepeatInterval => "horizon.options.repeat_interval",
            Opt::PadInvertX => "horizon.options.invert_x",
            Opt::PadInvertY => "horizon.options.invert_y",
+            Opt::PadCraftOnServers => "horizon.options.craft_on_servers",
            Opt::PadToggleSneak => "horizon.options.sneak_button",
            Opt::PadMoveDeadzone => "horizon.options.move_deadzone",
            Opt::PadLookDeadzone => "horizon.options.look_deadzone",
            Opt::PadTriggerThreshold => "horizon.options.trigger_threshold",
            Opt::PadGlyphs => "horizon.options.button_glyphs",
+            Opt::PadNintendoButtons => "horizon.options.nintendo_buttons",
            Opt::PadKeyboard => "horizon.options.on_screen_keyboard",
            Opt::PadGameplayGuide => "horizon.options.gameplay_guide",
            Opt::ModelPart(i) => [
@@ -840,6 +850,7 @@ impl Opt {
            }),
            Opt::PadInvertX => on_off(s.controller.invert_x),
            Opt::PadInvertY => on_off(s.controller.invert_y),
+            Opt::PadCraftOnServers => on_off(s.controller.craft_on_servers),
            Opt::PadToggleSneak => tr(if s.controller.toggle_sneak {
                "options.key.toggle"
            } else {
@@ -856,6 +867,11 @@ impl Opt {
                GlyphStyle::PlayStation => "horizon.options.glyphs.playstation",
                GlyphStyle::Nintendo => "horizon.options.glyphs.nintendo",
            }),
+            Opt::PadNintendoButtons => tr(if s.controller.nintendo_letters {
+                "horizon.options.nintendo_buttons.letter"
+            } else {
+                "horizon.options.nintendo_buttons.position"
+            }),
            Opt::PadKeyboard => tr(match s.controller.keyboard {
                gamepad::TextKeyboard::Auto => "horizon.options.keyboard.auto",
                gamepad::TextKeyboard::Horizon => "horizon.options.keyboard.horizon",
@@ -1142,7 +1158,13 @@ impl Opt {
            }
            Opt::PadInvertX => s.controller.invert_x = !s.controller.invert_x,
            Opt::PadInvertY => s.controller.invert_y = !s.controller.invert_y,
+            Opt::PadCraftOnServers => {
+                s.controller.craft_on_servers = !s.controller.craft_on_servers
+            }
            Opt::PadToggleSneak => s.controller.toggle_sneak = !s.controller.toggle_sneak,
+            Opt::PadNintendoButtons => {
+                s.controller.nintendo_letters = !s.controller.nintendo_letters
+            }
            Opt::PadLightbar => {
                let all = gamepad::Lightbar::ALL;
                let i = all
@@ -2230,6 +2252,11 @@ impl OptionsUi {
            _ => None,
        }
    }
+    /// A controller's or the keyboard's focus landed on `rect`: a row of a shell screen's list
+    /// that is partly hidden scrolls all into view. How far it moved down, when it moved.
+    pub fn reveal(&mut self, s: &Settings, size: (f32, f32), rect: [f32; 4]) -> Option<f32> {
+        self.shell_mut()?.reveal(s, size, rect)
+    }
    /// What a shell screen's outputs do to these options.
    fn shell_events(&mut self, s: &mut Settings, outputs: Vec<shell::Output>) -> Vec<Event> {
        let mut events = Vec::new();
@@ -3113,6 +3140,22 @@ impl OptionsUi {
                    ("horizon.pages.open.mods", Some(Page::Mods)),
                    ("options.credits_and_attribution", Some(Page::Credits)),
                ];
+                // horizon-extras: without it, vanilla's last row instead of Horizon Settings and
+                // Mods: Telemetry Data (greyed: nothing is sent) and Credits & Attribution.
+                let plain;
+                let entries: &[_] = if horizon_extras() {
+                    &entries
+                } else {
+                    plain = [
+                        &entries[..entries.len() - 3],
+                        &[
+                            ("options.telemetry", None),
+                            ("options.credits_and_attribution", Some(Page::Credits)),
+                        ],
+                    ]
+                    .concat();
+                    &plain
+                };
                let rows = entries.len().div_ceil(2) as f32;
                let gy = (61.0 + 30.0f32).min(h - 33.0 - rows * 24.0);
                for (i, (key, page)) in entries.iter().enumerate() {
@@ -3162,6 +3205,22 @@ impl OptionsUi {
                    let y = y + 28.0 * (i + 1) as f32;
                    out.push(inactive(button(x, y, 210.0, tr(key), Act::None)));
                }
+                // horizon-extras: a build without them says where the official one is.
+                if !horizon_extras() {
+                    out.push(Widget {
+                        x: 0.0,
+                        y: (y + 92.0).min(h - 42.0),
+                        w,
+                        h: 9.0,
+                        kind: WKind::Text {
+                            text: tr("horizon.plain.official"),
+                            color: 0xFFA0A0A0,
+                            centered: true,
+                        },
+                        list: false,
+                        row: 0,
+                    });
+                }
                out.push(done(h - 27.0));
                top = 0.0;
                bottom = 0.0;
@@ -3668,6 +3727,8 @@ impl OptionsUi {
        let in_world = self.in_world;
        if let Some(shell) = self.shell_mut() {
            shell.draw(s, batch, atlas, cursor, in_world, waiting);
+            // The keys lay the screen out at the size it was drawn at.
+            self.size = (batch.width, batch.height);
            return;
        }
        if self.page() == Page::SplitSetup {
@@ -4883,10 +4944,12 @@ impl OptionsUi {
            }
            return events;
        }
-        let gui = (
-            self.size.0.max(MIN_KEY_GUI.0),
-            self.size.1.max(MIN_KEY_GUI.1),
-        );
+        // The size it was drawn at; before the first draw, one its keys can lay out at.
+        let gui = if self.size.0 > 0.0 && self.size.1 > 0.0 {
+            self.size
+        } else {
+            MIN_KEY_GUI
+        };
        if let Some(shell) = self.shell_mut() {
            let outputs = shell.key(s, key, text, shift, gui);
            return self.shell_events(s, outputs);
@@ -462,7 +462,7 @@ fn read_meta(source: &Source) -> Option<serde_json::Value> {
 /// The first JSON value of a `pack.mcmeta`: what follows it is ignored, as some packs sign the
 /// file with a comment after the closing brace. Gson reads past a UTF-8 byte order mark;
 /// serde_json rejects it.
-fn parse_meta(bytes: &[u8]) -> Option<serde_json::Value> {
+pub(crate) fn parse_meta(bytes: &[u8]) -> Option<serde_json::Value> {
    serde_json::Deserializer::from_slice(bytes.strip_prefix(b"\xEF\xBB\xBF").unwrap_or(bytes))
        .into_iter()
        .next()?
@@ -837,24 +837,55 @@ fn build_overlay_uncached(
        dependencies,
        &mut extract,
    )?;
+    // What the zips may unpack to, all threads together: a server's pack is a download the
+    // player only accepts, and a gigabyte of zeros deflates to a megabyte, so without it a pack
+    // at the download limit wrote hundreds of gigabytes here. Vanilla never unpacks a pack.
+    let budget = std::sync::atomic::AtomicU64::new(unpack_budget(packs));
    // Inflating and writing a big pack's files one by one was most of a cold build; its
    // folders all exist by now.
-    crate::par::par_map(&extract, |(owner, inner, target)| {
+    let extracted: io::Result<()> = crate::par::par_map(&extract, |(owner, inner, target)| {
        let Some(Some(z)) = zips.get(*owner) else {
            return Ok(());
        };
-        // One unreadable entry costs that file, not the pack: an error here
-        // failed the build and the reload dropped every server pack in the stack.
-        match z.read(inner) {
-            Ok(bytes) => fs::write(target, bytes),
+        let copied = fs::File::create(target).and_then(|file| {
+            let mut file = io::BufWriter::new(file);
+            z.copy_to(inner, &mut file, &budget)?;
+            io::Write::flush(&mut file)
+        });
+        match copied {
+            Ok(()) => Ok(()),
+            // Past the budget the build fails, and the reload drops the server packs.
+            Err(e) if e.kind() == io::ErrorKind::FileTooLarge => Err(e),
+            // One unreadable entry costs that file, not the pack: an error here
+            // failed the build and the reload dropped every server pack in the stack.
            Err(e) => {
                log::warn!("Horizon: skipping unreadable pack entry {inner}: {e}");
+                let _ = fs::remove_file(target);
                Ok(())
            }
        }
    })
    .into_iter()
-    .collect()
+    .collect();
+    if extracted.is_err() {
+        // What was unpacked before the budget ran out goes too, not only the marker.
+        let _ = fs::remove_dir_all(out);
+    }
+    extracted
+}
+/// The most the zip packs in `packs` may unpack to in one overlay: 16 times their size on disk
+/// (real packs are mostly PNGs and JSON, a few times smaller zipped at most), at least 64 MiB
+/// for a small pack of text, and never past 8 GiB.
+fn unpack_budget(packs: &[Pack]) -> u64 {
+    packs
+        .iter()
+        .filter_map(|p| match &p.source {
+            Source::Zip(z) => fs::metadata(z).ok().map(|m| m.len()),
+            Source::Dir(_) => None,
+        })
+        .sum::<u64>()
+        .saturating_mul(16)
+        .clamp(64 << 20, 8 << 30)
 }
 /// Files vanilla loads from every pack in turn (`getResourceStack`) rather
 /// than from the top pack only.
@@ -1000,7 +1031,10 @@ pub fn resource_root(vanilla: &Path, packs: &[Pack], cache: &Path) -> io::Result
        (h ^ u64::from(b)).wrapping_mul(0x100_0000_01b3)
    });
    let out = cache.join(format!("{hash:016x}"));
+    cache::hold(&out)?;
    build_overlay(vanilla, packs, &out)?;
+    // Old selections' overlays would otherwise stay for good, each a whole unpacked copy.
+    cache::prune(cache);
    Ok(out)
 }

@@ -1736,6 +1770,77 @@ mod tests {
        let _ = fs::remove_dir_all(base);
    }
    #[test]
+    fn a_pack_that_unpacks_past_its_budget_fails_and_leaves_nothing() {
+        use std::io::Write as _;
+        let base = std::env::temp_dir().join(format!("horizon-pack-bomb-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&base);
+        let vanilla = base.join("vanilla");
+        fs::create_dir_all(vanilla.join("assets/minecraft/textures/block")).unwrap();
+        fs::write(
+            vanilla.join("assets/minecraft/textures/block/stone.png"),
+            b"vanilla",
+        )
+        .unwrap();
+        fs::create_dir_all(base.join("packs")).unwrap();
+        let pack = |name: &str, files: &[(&str, usize)]| {
+            let path = base.join("packs").join(name);
+            let mut zip = zip::ZipWriter::new(fs::File::create(&path).unwrap());
+            let deflated = zip::write::SimpleFileOptions::default()
+                .compression_method(zip::CompressionMethod::Deflated);
+            zip.start_file("pack.mcmeta", deflated).unwrap();
+            zip.write_all(br#"{"pack":{"description":"d","pack_format":97}}"#)
+                .unwrap();
+            let zeros = vec![0u8; 1 << 20];
+            for (file, mib) in files {
+                zip.start_file(*file, deflated).unwrap();
+                for _ in 0..*mib {
+                    zip.write_all(&zeros).unwrap();
+                }
+            }
+            zip.finish().unwrap();
+            fs::metadata(&path).unwrap().len()
+        };
+        // Four 24 MiB files of zeros: well under the per-file limit, 96 MiB in all from a zip of
+        // a few hundred KiB, past the 64 MiB a small pack may unpack to.
+        let size = pack(
+            "bomb.zip",
+            &[
+                ("assets/minecraft/textures/block/a.png", 24),
+                ("assets/minecraft/textures/block/b.png", 24),
+                ("assets/minecraft/textures/block/c.png", 24),
+                ("assets/minecraft/textures/block/d.png", 24),
+            ],
+        );
+        assert!(size < 1 << 20, "the bomb is small: {size} bytes");
+        let packs = discover(&vanilla, &base.join("packs"));
+        assert_eq!(packs.len(), 1);
+        let out = base.join("overlay");
+        let error = build_overlay(&vanilla, &packs, &out).unwrap_err();
+        assert_eq!(error.kind(), io::ErrorKind::FileTooLarge, "{error}");
+        assert!(
+            !out.exists(),
+            "what was unpacked before the budget ran out stays"
+        );
+        // The same files within the budget unpack whole.
+        fs::remove_file(base.join("packs/bomb.zip")).unwrap();
+        pack(
+            "fine.zip",
+            &[
+                ("assets/minecraft/textures/block/a.png", 24),
+                ("assets/minecraft/textures/block/b.png", 24),
+            ],
+        );
+        let packs = discover(&vanilla, &base.join("packs"));
+        build_overlay(&vanilla, &packs, &out).unwrap();
+        assert_eq!(
+            fs::metadata(out.join("assets/minecraft/textures/block/b.png"))
+                .unwrap()
+                .len(),
+            24 << 20
+        );
+        let _ = fs::remove_dir_all(&base);
+    }
+    #[test]
    fn zip_entries_never_leave_the_overlay() {
        use std::io::Write as _;
        let base = std::env::temp_dir().join(format!("horizon-pack-escape-{}", std::process::id()));
@@ -297,6 +297,107 @@ fn lock_path(out: &Path) -> PathBuf {
    marker_path(out).with_extension("lock")
 }

+/// The overlays [`prune`] keeps in a cache folder, newest use first. Each holds a whole unpacked
+/// copy of its zip packs, and every server pack, and every new version of one, makes another.
+pub(super) const KEEP: usize = 8;
+
+/// The file whose shared lock says a process uses `out`, and whose time is its last use.
+fn use_path(out: &Path) -> PathBuf {
+    marker_path(out).with_extension("use")
+}
+
+/// Marks `out` as used by this process until it exits ([`prune`] never deletes it), and as used
+/// now. The lock is taken before the overlay is built or read, so a prune in another process
+/// that took the folder first finishes deleting it before this one rebuilds it.
+pub(super) fn hold(out: &Path) -> io::Result<()> {
+    use std::sync::{Mutex, PoisonError};
+    static HELD: Mutex<Vec<(PathBuf, fs::File)>> = Mutex::new(Vec::new());
+    if let Some(parent) = out.parent().filter(|p| !p.as_os_str().is_empty()) {
+        fs::create_dir_all(parent)?;
+    }
+    let mut held = HELD.lock().unwrap_or_else(PoisonError::into_inner);
+    let at = match held.iter().position(|(path, _)| path == out) {
+        Some(at) => at,
+        None => {
+            let file = fs::OpenOptions::new()
+                .read(true)
+                .write(true)
+                .create(true)
+                .truncate(false)
+                .open(use_path(out))?;
+            file.lock_shared()?;
+            held.push((out.into(), file));
+            held.len() - 1
+        }
+    };
+    // Only the order of the prune depends on it: a filesystem without the time loses nothing.
+    let _ = held[at].1.set_modified(std::time::SystemTime::now());
+    Ok(())
+}
+
+/// Deletes the overlays in `cache` past the [`KEEP`] most recently used, skipping any that a
+/// process holds ([`hold`]) or builds. Only `<16 hex digits>` folders are overlays.
+pub(super) fn prune(cache: &Path) {
+    let Ok(entries) = fs::read_dir(cache) else {
+        return;
+    };
+    let mut overlays: Vec<(std::time::SystemTime, PathBuf)> = entries
+        .flatten()
+        .map(|e| e.path())
+        .filter(|p| {
+            p.file_name()
+                .and_then(|n| n.to_str())
+                .is_some_and(|n| n.len() == 16 && n.bytes().all(|b| b.is_ascii_hexdigit()))
+                && p.is_dir()
+        })
+        .map(|p| {
+            // An overlay built before use files existed goes by its marker or its folder.
+            let used = [use_path(&p), marker_path(&p), p.clone()]
+                .iter()
+                .find_map(|f| fs::metadata(f).and_then(|m| m.modified()).ok())
+                .unwrap_or(std::time::UNIX_EPOCH);
+            (used, p)
+        })
+        .collect();
+    overlays.sort_by_key(|(used, _)| std::cmp::Reverse(*used));
+    for (_, old) in overlays.into_iter().skip(KEEP) {
+        if let Err(e) = remove_unused(&old) {
+            log::warn!(
+                "Horizon: couldn't remove the old pack overlay {}: {e}",
+                old.display()
+            );
+        }
+    }
+}
+
+/// Deletes the overlay `out` unless a process builds or uses it. The lock files stay: deleting
+/// them would let two processes lock different files of the same name.
+fn remove_unused(out: &Path) -> io::Result<()> {
+    let open = |path: PathBuf| {
+        fs::OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .truncate(false)
+            .open(path)
+    };
+    let building = open(lock_path(out))?;
+    let using = open(use_path(out))?;
+    for lock in [&building, &using] {
+        match lock.try_lock() {
+            Ok(()) => {}
+            Err(fs::TryLockError::WouldBlock) => return Ok(()),
+            Err(fs::TryLockError::Error(e)) => return Err(e),
+        }
+    }
+    // The marker first: a folder half deleted is never taken for a built one.
+    match fs::remove_file(marker_path(out)) {
+        Err(e) if e.kind() != io::ErrorKind::NotFound => return Err(e),
+        _ => {}
+    }
+    fs::remove_dir_all(out)
+}
+
 pub(super) fn build(vanilla: &Path, packs: &[Pack], out: &Path) -> io::Result<()> {
    if let Some(parent) = out.parent().filter(|p| !p.as_os_str().is_empty()) {
        fs::create_dir_all(parent)?;
@@ -368,6 +469,77 @@ mod tests {
    use crate::{packs, text::Text};
    use std::sync::atomic::{AtomicUsize, Ordering};

+    #[test]
+    fn prune_keeps_the_most_recently_used_overlays_and_those_in_use() {
+        let f = Fixture::new();
+        let cache = f.0.join("cache");
+        let now = std::time::SystemTime::now();
+        // KEEP + 4 overlays, overlay 0 used last; one more not an overlay.
+        let overlays: Vec<PathBuf> = (0..KEEP + 4)
+            .map(|i| {
+                let out = cache.join(format!("{i:016x}"));
+                f.write(&format!("cache/{i:016x}/assets/a.png"), b"x");
+                f.write(&format!("cache/{i:016x}.overlay-cache.json"), b"{}");
+                let used = fs::File::create(use_path(&out)).unwrap();
+                used.set_modified(now - std::time::Duration::from_secs(60 * i as u64))
+                    .unwrap();
+                out
+            })
+            .collect();
+        f.write("cache/notes/keep.txt", b"x");
+        // Another process uses the oldest, and builds the second oldest.
+        let using = fs::File::open(use_path(&overlays[KEEP + 3])).unwrap();
+        using.lock_shared().unwrap();
+        let building = fs::OpenOptions::new()
+            .write(true)
+            .create(true)
+            .truncate(false)
+            .open(lock_path(&overlays[KEEP + 2]))
+            .unwrap();
+        building.lock().unwrap();
+        prune(&cache);
+        let kept: Vec<bool> = overlays.iter().map(|o| o.is_dir()).collect();
+        let mut expected = vec![true; KEEP];
+        expected.extend([false, false, true, true]);
+        assert_eq!(kept, expected);
+        assert!(
+            !marker_path(&overlays[KEEP]).exists(),
+            "never reused half deleted"
+        );
+        assert!(cache.join("notes/keep.txt").exists());
+        // Released, they go at the next prune.
+        drop((using, building));
+        prune(&cache);
+        assert_eq!(
+            overlays.iter().filter(|o| o.is_dir()).count(),
+            KEEP,
+            "only the most recent stay"
+        );
+        assert!(overlays[..KEEP].iter().all(|o| o.is_dir()));
+    }
+
+    #[test]
+    fn an_overlay_held_by_this_process_is_never_pruned() {
+        let f = Fixture::new();
+        let cache = f.0.join("cache");
+        let held = cache.join("00000000000000ff");
+        f.write("cache/00000000000000ff/assets/a.png", b"x");
+        hold(&held).unwrap();
+        // Older than KEEP others, and still in use.
+        let old = std::time::SystemTime::now() - std::time::Duration::from_secs(3600);
+        fs::File::options()
+            .write(true)
+            .open(use_path(&held))
+            .unwrap()
+            .set_modified(old)
+            .unwrap();
+        for i in 0..KEEP {
+            f.write(&format!("cache/{i:016x}/assets/a.png"), b"x");
+        }
+        prune(&cache);
+        assert!(held.is_dir());
+    }
+
    struct Fixture(PathBuf);
    impl Fixture {
        fn new() -> Self {
@@ -0,0 +1,237 @@
+//! The shared atlas's LabPBR maps (`_n`, `_s` beside an item's, entity's or block's texture),
+//! for shader packs: a map the size of the atlas would be mostly empty (only some textures have
+//! maps) and as large as the atlas itself, so each is a paged map instead. The atlas is cut into
+//! 16x16 pages; only pages holding a mapped texture get one in the map's pool, found through a
+//! page table at the map's start. Packs read the maps with the colour's coordinates, as for
+//! terrain: the translator turns their reads into `hz_pagedTexture` (horizon-shaders,
+//! `PAGED_READ`, which documents the layout this writes).
+
+/// A page's side, in texels.
+pub const PAGE: u32 = 16;
+/// Texels before the page table: the atlas's size, and the map's value where it has none.
+const HEADER: u32 = 2;
+
+/// One paged map, RGBA8.
+#[derive(Clone, Debug, PartialEq)]
+pub struct PagedMap {
+    pub width: u32,
+    pub height: u32,
+    pub pixels: Vec<u8>,
+}
+
+/// A texture's maps: its place in the atlas (x, y, width, height, in texels) and its normal and
+/// specular images at that size (RGBA8), each where it has one.
+pub struct SpriteMaps {
+    pub rect: [u32; 4],
+    pub maps: [Option<Vec<u8>>; 2],
+}
+
+/// The normal and specular paged maps of an atlas of `size` texels, each `None` where no texture
+/// has that map; `max_side` is the GPU's largest texture side.
+pub fn build(size: (u32, u32), sprites: &[SpriteMaps], max_side: u32) -> [Option<PagedMap>; 2] {
+    [
+        (0, crate::sprites::FLAT_NORMAL),
+        (1, crate::sprites::NO_SPECULAR),
+    ]
+    .map(|(kind, default)| {
+        let mapped = sprites
+            .iter()
+            .filter_map(|s| s.maps[kind].as_deref().map(|m| (s.rect, m)));
+        build_one(size, mapped, default, max_side)
+    })
+}
+
+fn build_one<'a>(
+    (width, height): (u32, u32),
+    sprites: impl Iterator<Item = ([u32; 4], &'a [u8])>,
+    default: [u8; 4],
+    max_side: u32,
+) -> Option<PagedMap> {
+    let (pages_x, pages_y) = (width.div_ceil(PAGE), height.div_ceil(PAGE));
+    // Each atlas page's place in the pool, plus one (0: none).
+    let mut table = vec![0u32; (pages_x * pages_y) as usize];
+    let mut pool: Vec<Vec<u8>> = Vec::new();
+    let blank: Vec<u8> = default.repeat((PAGE * PAGE) as usize);
+    for ([x, y, w, h], map) in sprites {
+        if w == 0 || h == 0 || map.len() < (w * h * 4) as usize || x + w > width || y + h > height {
+            continue;
+        }
+        for py in y / PAGE..=(y + h - 1) / PAGE {
+            for px in x / PAGE..=(x + w - 1) / PAGE {
+                let entry = &mut table[(py * pages_x + px) as usize];
+                if *entry == 0 {
+                    pool.push(blank.clone());
+                    *entry = pool.len() as u32;
+                }
+                let page = &mut pool[*entry as usize - 1];
+                // The sprite's texels on this page.
+                let (x0, x1) = (x.max(px * PAGE), (x + w).min((px + 1) * PAGE));
+                let (y0, y1) = (y.max(py * PAGE), (y + h).min((py + 1) * PAGE));
+                for ty in y0..y1 {
+                    let src = (((ty - y) * w + (x0 - x)) * 4) as usize;
+                    let dst = (((ty - py * PAGE) * PAGE + (x0 - px * PAGE)) * 4) as usize;
+                    let len = ((x1 - x0) * 4) as usize;
+                    page[dst..dst + len].copy_from_slice(&map[src..src + len]);
+                }
+            }
+        }
+    }
+    if pool.is_empty() || pool.len() >= 1 << 24 {
+        return None;
+    }
+    let entries = HEADER + pages_x * pages_y;
+    // The narrowest map width (whole pages) that keeps it within the GPU's side.
+    let (side, rows, map_height) = [1024, 2048, 4096, 8192, 16384]
+        .into_iter()
+        .filter(|&s| s <= max_side)
+        .map(|s| {
+            let rows = entries.div_ceil(s).next_multiple_of(PAGE);
+            let per_row = s / PAGE;
+            (s, rows, rows + (pool.len() as u32).div_ceil(per_row) * PAGE)
+        })
+        .find(|&(_, _, h)| h <= max_side)?;
+    let mut pixels = vec![0u8; (side * map_height * 4) as usize];
+    let header = [
+        width as u8,
+        (width >> 8) as u8,
+        height as u8,
+        (height >> 8) as u8,
+    ];
+    pixels[..4].copy_from_slice(&header);
+    pixels[4..8].copy_from_slice(&default);
+    for (i, &k) in table.iter().enumerate() {
+        let at = (HEADER as usize + i) * 4;
+        pixels[at..at + 4].copy_from_slice(&[k as u8, (k >> 8) as u8, (k >> 16) as u8, 255]);
+    }
+    let per_row = side / PAGE;
+    for (k, page) in pool.iter().enumerate() {
+        let k = k as u32;
+        let (ox, oy) = (k % per_row * PAGE, rows + k / per_row * PAGE);
+        for row in 0..PAGE {
+            let dst = (((oy + row) * side + ox) * 4) as usize;
+            let src = (row * PAGE * 4) as usize;
+            pixels[dst..dst + (PAGE * 4) as usize]
+                .copy_from_slice(&page[src..src + (PAGE * 4) as usize]);
+        }
+    }
+    Some(PagedMap {
+        width: side,
+        height: map_height,
+        pixels,
+    })
+}
+
+/// `map` (RGBA8, `mw` by `mh`) at `w` by `h`, nearest: a map drawn for a strip of animation
+/// frames keeps its first, the colour's shape from its top.
+pub fn fit(map: &[u8], (mw, mh): (u32, u32), (w, h): (u32, u32)) -> Option<Vec<u8>> {
+    if mw == 0 || mh == 0 || w == 0 || h == 0 || map.len() < (mw * mh * 4) as usize {
+        return None;
+    }
+    // The first frame of a strip as tall as the colour's frame is wide, scaled.
+    let frame_h = (u64::from(mw) * u64::from(h) / u64::from(w)).clamp(1, u64::from(mh)) as u32;
+    let mut out = Vec::with_capacity((w * h * 4) as usize);
+    for y in 0..h {
+        let sy = (u64::from(y) * u64::from(frame_h) / u64::from(h)) as u32;
+        for x in 0..w {
+            let sx = (u64::from(x) * u64::from(mw) / u64::from(w)) as u32;
+            let at = ((sy * mw + sx) * 4) as usize;
+            out.extend_from_slice(&map[at..at + 4]);
+        }
+    }
+    Some(out)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// What `PAGED_READ` returns at texel (x, y) of the atlas.
+    fn read(map: &PagedMap, (width, height): (u32, u32), (x, y): (u32, u32)) -> [u8; 4] {
+        let texel = |at: u32| {
+            let at = (at * 4) as usize;
+            [0, 1, 2, 3].map(|c| map.pixels[at + c])
+        };
+        let at = |x: u32, y: u32| texel(y * map.width + x);
+        let h = texel(0);
+        assert_eq!(
+            (
+                u32::from(h[0]) | u32::from(h[1]) << 8,
+                u32::from(h[2]) | u32::from(h[3]) << 8
+            ),
+            (width, height)
+        );
+        let pages = (width.div_ceil(PAGE), height.div_ceil(PAGE));
+        let e = texel(2 + (y / PAGE) * pages.0 + x / PAGE);
+        let k = u32::from(e[0]) | u32::from(e[1]) << 8 | u32::from(e[2]) << 16;
+        if k == 0 {
+            return texel(1);
+        }
+        let rows = (2 + pages.0 * pages.1)
+            .div_ceil(map.width)
+            .next_multiple_of(16);
+        let per_row = map.width / 16;
+        at(
+            (k - 1) % per_row * 16 + x % 16,
+            rows + (k - 1) / per_row * 16 + y % 16,
+        )
+    }
+
+    #[test]
+    fn mapped_textures_read_back_and_the_rest_reads_the_default() {
+        let size = (4096, 2048);
+        // A 20x20 texture across four pages, and one without a specular map.
+        let normal: Vec<u8> = (0..20 * 20)
+            .flat_map(|i: u32| [i as u8, (i >> 8) as u8, 7, 255])
+            .collect();
+        let sprites = [
+            SpriteMaps {
+                rect: [30, 40, 20, 20],
+                maps: [Some(normal.clone()), Some(vec![9; 20 * 20 * 4])],
+            },
+            SpriteMaps {
+                rect: [1000, 1000, 16, 16],
+                maps: [Some(vec![3; 16 * 16 * 4]), None],
+            },
+        ];
+        let [normals, specular] = build(size, &sprites, 16384);
+        let (normals, specular) = (normals.unwrap(), specular.unwrap());
+        for y in 0..20 {
+            for x in 0..20 {
+                let i = ((y * 20 + x) * 4) as usize;
+                assert_eq!(read(&normals, size, (30 + x, 40 + y)), normal[i..i + 4]);
+                assert_eq!(read(&specular, size, (30 + x, 40 + y)), [9; 4]);
+            }
+        }
+        // The texels beside it on its pages, and pages without a map.
+        assert_eq!(read(&normals, size, (29, 40)), crate::sprites::FLAT_NORMAL);
+        assert_eq!(read(&normals, size, (2000, 5)), crate::sprites::FLAT_NORMAL);
+        assert_eq!(
+            read(&specular, size, (1005, 1005)),
+            crate::sprites::NO_SPECULAR
+        );
+        assert_eq!(read(&normals, size, (1005, 1005)), [3; 4]);
+        // Five pages: a table of 2 + 256 x 128 entries, 33 rows at 1024 wide (48, whole pages),
+        // then a row of pages.
+        assert_eq!((normals.width, normals.height), (1024, 64));
+    }
+
+    #[test]
+    fn nothing_mapped_makes_no_map() {
+        let sprites = [SpriteMaps {
+            rect: [0, 0, 16, 16],
+            maps: [None, None],
+        }];
+        assert_eq!(build((1024, 1024), &sprites, 16384), [None, None]);
+    }
+
+    #[test]
+    fn a_map_fits_its_texture() {
+        // A 2x map is sampled down; a strip of frames keeps its first.
+        let map: Vec<u8> = (0..4 * 8).flat_map(|i: u8| [i, 0, 0, 255]).collect();
+        let fitted = fit(&map, (4, 8), (2, 2)).unwrap();
+        assert_eq!(
+            fitted.chunks(4).map(|p| p[0]).collect::<Vec<_>>(),
+            [0, 2, 8, 10]
+        );
+    }
+}
@@ -58,6 +58,12 @@ pub struct ParticleOptions {
    /// A native mod's own particle type, by its namespaced name (`mymod:spark`):
    /// `SimpleParticleType` plus the provider `particles/<name>.json` names.
    pub mod_particle: Option<String>,
+    /// Pre-1.20.5 entity-effect providers use spawn velocity as RGB; true is the ambient provider.
+    pub legacy_entity_effect: Option<bool>,
+    /// A pre-1.21.4 server's trail, which had no duration: TrailParticle.Provider chose
+    /// `nextInt(40) + 10` after constructing the particle. Set by the client for an older
+    /// server only, never read from the wire.
+    pub legacy_trail_lifetime: bool,
 }
 impl ParticleOptions {
    pub fn simple(ty: ParticleType) -> Self {
@@ -72,6 +78,8 @@ impl ParticleOptions {
            geyser: None,
            vibration: None,
            mod_particle: None,
+            legacy_entity_effect: None,
+            legacy_trail_lifetime: false,
        }
    }
    /// A native mod's `SimpleParticleType`: the sprite set of
@@ -3167,8 +3175,16 @@ impl ParticleEngine {
                        q.set_color(b, 0.0, b);
                    }
                    T::EntityEffect => {
-                        q.set_color(o.color[0], o.color[1], o.color[2]);
-                        q.rgba[3] = o.color[3];
+                        if let Some(ambient) = o.legacy_entity_effect {
+                            q.set_color(v[0] as f32, v[1] as f32, v[2] as f32);
+                            // AmbientMobProvider overrides constructor alpha; MobProvider only sets RGB.
+                            if ambient {
+                                q.rgba[3] = 0.15;
+                            }
+                        } else {
+                            q.set_color(o.color[0], o.color[1], o.color[2]);
+                            q.rgba[3] = o.color[3];
+                        }
                    }
                    T::Effect | T::InstantEffect => {
                        q.set_color(o.color[0], o.color[1], o.color[2]);
@@ -3177,7 +3193,12 @@ impl ParticleEngine {
                    _ => {}
                }
                q.behaviour = Behaviour::Spell {
-                    original_alpha: q.rgba[3],
+                    // The old SpellParticle.tick always eased back to 1, including ambient effects.
+                    original_alpha: if o.legacy_entity_effect.is_some() {
+                        1.0
+                    } else {
+                        q.rgba[3]
+                    },
                };
                q.set = set;
                q
@@ -3469,7 +3490,11 @@ impl ParticleEngine {
                    scaled(o.color[2], jb),
                );
                q.size = 0.26;
-                q.lifetime = duration;
+                q.lifetime = if o.legacy_trail_lifetime {
+                    self.level_random.next_int_bound(40).unwrap_or(0) + 10
+                } else {
+                    duration
+                };
                q.has_physics = false;
                q.free_move = true;
                q.light = Light::FullBright;
@@ -4941,6 +4966,45 @@ const CREEPER: [[f64; 2]; 12] = [
 mod tests {
    use super::*;

+    #[test]
+    fn legacy_spell_providers_use_velocity_rgb_and_their_original_alpha_rules() {
+        let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
+        let velocity = [0.25, 0.5, 0.75];
+        for scoped in [false, true] {
+            engine.set_scope_eye(scoped.then_some([0.0; 3]));
+            for ambient in [false, true] {
+                let mut options =
+                    ParticleOptions::colored(ParticleType::EntityEffect, [1.0, 0.0, 0.0, 0.8]);
+                options.legacy_entity_effect = Some(ambient);
+                let particle = engine.make(&options, [0.0; 3], velocity, 7).unwrap();
+                let alpha = if ambient {
+                    0.15
+                } else if scoped {
+                    0.0
+                } else {
+                    1.0
+                };
+                assert_eq!(particle.rgba, [0.25, 0.5, 0.75, alpha]);
+                assert_eq!(
+                    particle.behaviour,
+                    Behaviour::Spell {
+                        original_alpha: 1.0
+                    }
+                );
+            }
+            let options =
+                ParticleOptions::colored(ParticleType::EntityEffect, [1.0, 0.0, 0.0, 0.8]);
+            let current = engine.make(&options, [0.0; 3], velocity, 7).unwrap();
+            assert_eq!(current.rgba, options.color);
+            assert_eq!(
+                current.behaviour,
+                Behaviour::Spell {
+                    original_alpha: 0.8
+                }
+            );
+        }
+    }
+
    #[test]
    fn particle_light_cache_reuses_exact_blocks_and_fails_open_on_collisions() {
        let reads = std::cell::Cell::new(0);
@@ -5700,6 +5764,40 @@ mod tests {
        assert!((0.15 * 0.4 - 1e-6..=0.45 * 0.4 + 1e-6).contains(&s));
    }
    #[test]
+    fn legacy_trails_choose_a_lifetime_for_each_particle_from_the_level_random() {
+        let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
+        engine.seed_randoms(1, 42, 2);
+        let legacy = ParticleOptions {
+            legacy_trail_lifetime: true,
+            ..ParticleOptions::trail([1.0, 2.0, 3.0], 0x7f3f1f, -1)
+        };
+        for _ in 0..5 {
+            engine.create(&legacy, [0.0; 3], [0.0; 3]);
+        }
+        // java.util.Random(42).nextInt(40) + 10, as vanilla 1.21.3 TrailParticle.Provider does.
+        assert_eq!(
+            engine
+                .pending
+                .iter()
+                .map(|p| p.lifetime)
+                .collect::<Vec<_>>(),
+            [20, 13, 18, 14, 20]
+        );
+        engine.create(
+            &ParticleOptions::trail([1.0, 2.0, 3.0], 0x7f3f1f, 37),
+            [0.0; 3],
+            [0.0; 3],
+        );
+        assert_eq!(engine.pending.last().unwrap().lifetime, 37);
+        // A current server's -1 is a lifetime like any other, not the old marker.
+        engine.create(
+            &ParticleOptions::trail([1.0, 2.0, 3.0], 0x7f3f1f, -1),
+            [0.0; 3],
+            [0.0; 3],
+        );
+        assert_eq!(engine.pending.last().unwrap().lifetime, -1);
+    }
+    #[test]
    fn sizes_follow_vanilla_curves() {
        let mut r = LegacyRandom::new(2);
        let mut p = Particle::at(&mut r, ParticleType::Flame, [0.0; 3]);
@@ -0,0 +1,63 @@
+//! The randoms vanilla creates unseeded: `RandomSource.create()` (sounds,
+//! screens, the torch flicker, a raid's random) and an entity's own random
+//! (`Entity.random`). Each is seeded from one shared counter and the clock, as
+//! `RandomSupport.generateUniqueSeed` does. Kept out of `horizon_core::random`,
+//! whose streams are only ever seeded explicitly.
+use horizon_core::random::LegacyRandom;
+
+/// `RandomSource.create()`.
+pub fn create() -> LegacyRandom {
+    LegacyRandom::new(unique_seed())
+}
+
+/// An entity's own random (`Entity.random`). Vanilla's is
+/// `RandomSource.createThreadLocalInstance`, seeded from Java's
+/// `ThreadLocalRandom`; Horizon seeds it as `create` does. Draws from an
+/// entity's own random never touch the level's.
+pub fn entity() -> LegacyRandom {
+    create()
+}
+
+/// `RandomSupport.generateUniqueSeed`. Under `HORIZON_STILL` (screenshots that
+/// come out the same every run) the clock is left out, so the seeds repeat run
+/// to run, in the order they are taken.
+pub fn unique_seed() -> i64 {
+    use std::sync::atomic::{AtomicI64, Ordering};
+    static UNIQUIFIER: AtomicI64 = AtomicI64::new(8_682_522_807_148_012);
+    let mut current = UNIQUIFIER.load(Ordering::Relaxed);
+    let next = loop {
+        let next = current.wrapping_mul(1_181_783_497_276_652_981);
+        match UNIQUIFIER.compare_exchange(current, next, Ordering::Relaxed, Ordering::Relaxed) {
+            Ok(_) => break next,
+            Err(v) => current = v,
+        }
+    };
+    if still() {
+        return next;
+    }
+    let nanos = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_or(0, |d| d.as_nanos() as i64);
+    next ^ nanos
+}
+
+/// `HORIZON_STILL=1`, read once, as the clock's `still_requested` reads it.
+fn still() -> bool {
+    static STILL: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *STILL.get_or_init(|| std::env::var("HORIZON_STILL").is_ok_and(|v| v == "1"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_core::random::RandomSource;
+
+    /// One shared counter: seeds taken back to back never repeat, even when
+    /// the clock hasn't moved between them.
+    #[test]
+    fn each_seed_and_each_random_is_new() {
+        let seeds: std::collections::HashSet<i64> = (0..1000).map(|_| unique_seed()).collect();
+        assert_eq!(seeds.len(), 1000);
+        assert_ne!(create().next_long(), create().next_long());
+    }
+}
@@ -840,11 +840,14 @@ pub enum Opt {
    PadRepeatInterval,
    PadInvertX,
    PadInvertY,
+    PadCraftOnServers,
    PadToggleSneak,
    PadMoveDeadzone,
    PadLookDeadzone,
    PadTriggerThreshold,
    PadGlyphs,
+    /// A Nintendo pad's face buttons by place or by letter (`PadSettings::nintendo_letters`).
+    PadNintendoButtons,
    PadKeyboard,
    PadGameplayGuide,
    /// `options.modelPart.*`: one skin layer (index into `options_file::MODEL_PARTS`).
@@ -14,6 +14,7 @@ use crate::{
    text::Text,
    ui,
 };
+use std::rc::Rc;

 /// The screen's parts in GUI pixels. Down the left: the mark, the search
 /// field, the page list, and Undo and Done at the foot. On the right: the
@@ -865,6 +866,11 @@ pub(crate) trait Screen {
        NOTE_LINES
    }
    fn sheets(&self, s: &Settings) -> Vec<Sheet<Self::Page, Self::Row>>;
+    /// A fingerprint ([`stamp_of`]) of what `sheets` reads that can change while the screen is
+    /// open, besides through `press`, `slide` and `wheel_step` (the shell builds again after
+    /// those): the rows are built again only when it changes, or the search, the page, the size or
+    /// the language does.
+    fn stamp(&self, s: &Settings) -> u64;
    /// A row was pressed (`back`: Shift held); the shell has played the click.
    fn press(&mut self, s: &mut Settings, row: Self::Row, back: bool) -> Vec<Output>;
    /// A slider row moved to `position`.
@@ -881,6 +887,23 @@ pub(crate) trait Screen {
    }
 }

+/// A fingerprint of `parts` for [`Screen::stamp`]: their `Debug` text, hashed as it is written,
+/// without keeping it.
+pub(crate) fn stamp_of(parts: &impl std::fmt::Debug) -> u64 {
+    use std::{fmt::Write, hash::Hasher};
+    struct Hashing(std::collections::hash_map::DefaultHasher);
+    impl Write for Hashing {
+        fn write_str(&mut self, text: &str) -> std::fmt::Result {
+            self.0.write(text.as_bytes());
+            Ok(())
+        }
+    }
+    let mut hashing = Hashing(Default::default());
+    // Writing into a hasher can't fail.
+    let _ = write!(hashing, "{parts:?}");
+    hashing.0.finish()
+}
+
 /// A [`Shell`] of any screen, as `OptionsUi` drives it.
 pub(crate) trait Hosted {
    /// The screen opens, afresh.
@@ -907,6 +930,10 @@ pub(crate) trait Hosted {
    ) -> Vec<Output>;
    /// Lets go of a slider (true: it plays its click) or the scrollbar.
    fn release(&mut self) -> bool;
+    /// A controller's or the keyboard's focus is on the row at `rect`: if the list hides part of
+    /// it, it scrolls all into view (`AbstractSelectionList.setSelected`). How far the row moved
+    /// down, when it moved.
+    fn reveal(&mut self, s: &Settings, size: (f32, f32), rect: [f32; 4]) -> Option<f32>;
    /// The mouse wheel at `at`: it scrolls, unless the row under it takes the step (`wheel_step`).
    fn wheel(
        &mut self,
@@ -961,6 +988,19 @@ struct View<P, R> {
    content: f32,
 }

+/// What a [`View`] was built for: when any of it changes, the rows are built again.
+#[derive(PartialEq)]
+struct Built<P, R> {
+    stamp: u64,
+    /// Which language the rows' text is in (`lang::generation`).
+    language: u64,
+    size: (f32, f32),
+    query: String,
+    page: Option<P>,
+    /// While searching, the rows the focus and a drag keep in the list.
+    kept: (Option<R>, Option<R>),
+}
+
 /// A screen on the shell, with all that isn't the screen's: where the list is, what has the focus,
 /// what is held and what is searched.
 pub(crate) struct Shell<S: Screen> {
@@ -980,6 +1020,8 @@ pub(crate) struct Shell<S: Screen> {
    /// While searching, the page last picked in the page list: current until the list scrolls.
    picked: Option<S::Page>,
    waiting: Option<&'static str>,
+    /// The rows as last built, and what for.
+    built: Option<(Built<S::Page, S::Row>, Rc<View<S::Page, S::Row>>)>,
 }
 impl<S: Screen + Default> Default for Shell<S> {
    fn default() -> Self {
@@ -998,6 +1040,7 @@ impl<S: Screen + Default> Default for Shell<S> {
            page: None,
            picked: None,
            waiting: None,
+            built: None,
        }
    }
 }
@@ -1008,10 +1051,43 @@ impl<S: Screen> Shell<S> {
    fn shows_focus(&self, target: Target<S::Page, S::Row>) -> bool {
        self.keyed && self.focus == Some(target)
    }
-    /// The screen's rows now: the open page's or, while searching, every page's whose name or
+    /// The screen's rows now, built again only when what they were built for changed
+    /// ([`Built`]). The scroll is kept within them.
+    fn view(&mut self, s: &Settings, size: (f32, f32)) -> Rc<View<S::Page, S::Row>> {
+        let query = self.query();
+        let searching = !query.is_empty();
+        let focused = match self.focus {
+            Some(Target::Row(row)) if searching => Some(row),
+            _ => None,
+        };
+        let key = Built {
+            stamp: self.screen.stamp(s),
+            language: lang::generation(),
+            size,
+            query,
+            page: self.page,
+            kept: (focused, self.dragging.filter(|_| searching)),
+        };
+        let view = match &self.built {
+            Some((built, view)) if *built == key => view.clone(),
+            _ => {
+                let view = Rc::new(self.build(s, size));
+                self.built = Some((key, view.clone()));
+                view
+            }
+        };
+        self.scroll
+            .clamp(view.cols.top, view.cols.bottom, view.content);
+        view
+    }
+    /// A row may read otherwise now: the screen changed something.
+    fn rebuild(&mut self) {
+        self.built = None;
+    }
+    /// The screen's rows: the open page's or, while searching, every page's whose name or
    /// description has the search in it, under their pages' names. The row being changed stays
-    /// whatever it reads now. The scroll is kept within it.
-    fn view(&mut self, s: &Settings, (w, h): (f32, f32)) -> View<S::Page, S::Row> {
+    /// whatever it reads now.
+    fn build(&self, s: &Settings, (w, h): (f32, f32)) -> View<S::Page, S::Row> {
        let cols = Columns::of(w, h).with_note_lines(self.screen.note_lines());
        let query = self.query();
        let sheets = self.screen.sheets(s);
@@ -1048,7 +1124,6 @@ impl<S: Screen> Shell<S> {
            }
        }
        let (lines, content) = lines.finish();
-        self.scroll.clamp(cols.top, cols.bottom, content);
        View {
            cols,
            pages,
@@ -1136,12 +1211,14 @@ impl<S: Screen> Shell<S> {
                };
                self.dragging = Some(row.id);
                self.screen.slide(s, row.id, position);
+                self.rebuild();
                vec![DRAGGED]
            }
            _ => {
                self.can_change_value = false;
                let mut outputs = vec![CLICK];
                outputs.extend(self.screen.press(s, row.id, back));
+                self.rebuild();
                outputs
            }
        }
@@ -1171,6 +1248,22 @@ impl<S: Screen> Shell<S> {
        out.push((Target::Done, cols.button(0)));
        out
    }
+    /// Where Down from the search field goes on a screen with no page list, whose foot is under the
+    /// field instead: the first row to use that is all in view.
+    fn first_row(
+        &self,
+        view: &View<S::Page, S::Row>,
+    ) -> Option<(Target<S::Page, S::Row>, [f32; 4])> {
+        if !self.tabs(view).is_empty() {
+            return None;
+        }
+        let cols = &view.cols;
+        let mut placed = self.placed(view);
+        let first = placed.find(|&(row, y)| {
+            row.live && row.value != Value::Note && y >= cols.top && y + style::ROW <= cols.bottom
+        });
+        first.map(|(row, y)| (Target::Row(row.id), cols.row(y)))
+    }
    /// Focus `target`, scrolling its row into the list's view.
    fn focus_on(
        &mut self,
@@ -1325,6 +1418,9 @@ impl<S: Screen + Default> Hosted for Shell<S> {
            },
        );
        scroller(batch, atlas, &cols, view.content, self.scroll.amount);
+        if let Some((_, row)) = self.first_row(&view) {
+            crate::widgets::focus_link(cols.search(), true, row);
+        }
        self.draw_dock(batch, atlas, &view, described, current);
        let done = cols.button(0);
        let label = Text::literal(lang::get("Done"));
@@ -1358,6 +1454,7 @@ impl<S: Screen + Default> Hosted for Shell<S> {
            }
            if let Some(row) = self.dragging {
                self.screen.slide(s, row, cols.slider_at(x));
+                self.rebuild();
                return vec![DRAGGED];
            }
            return Vec::new();
@@ -1409,6 +1506,22 @@ impl<S: Screen + Default> Hosted for Shell<S> {
        self.scroll.release();
        self.dragging.take().is_some()
    }
+    fn reveal(&mut self, s: &Settings, size: (f32, f32), [x, y, w, h]: [f32; 4]) -> Option<f32> {
+        let view = self.view(s, size);
+        let cols = &view.cols;
+        let middle = (x + w / 2.0, y + h / 2.0);
+        let (_, row_y) = self.placed(&view).find(|&(_, ry)| {
+            let [rx, ry, rw, rh] = cols.row(ry);
+            ui::hovered(middle, rx, ry, rw, rh)
+        })?;
+        let before = self.scroll.amount;
+        scroll_into_view(&mut self.scroll, cols.row(row_y), cols, view.content);
+        let moved = before - self.scroll.amount;
+        (moved != 0.0).then(|| {
+            self.picked = None;
+            moved
+        })
+    }
    fn wheel(
        &mut self,
        s: &mut Settings,
@@ -1421,6 +1534,7 @@ impl<S: Screen + Default> Hosted for Shell<S> {
            if let Some(row) = self.row_at(&view, at).filter(|row| row.live)
                && let Some(outputs) = self.screen.wheel_step(s, row.id, amount > 0.0)
            {
+                self.rebuild();
                return outputs;
            }
        }
@@ -1471,6 +1585,14 @@ impl<S: Screen + Default> Hosted for Shell<S> {
            self.focus_on(focusables[next], &view);
            return Vec::new();
        }
+        if key == K::ArrowDown
+            && self.focus == Some(Target::Search)
+            && let Some(first) = self.first_row(&view)
+        {
+            self.keyed = true;
+            self.focus_on(first, &view);
+            return Vec::new();
+        }
        let focused = view
            .rows
            .iter()
@@ -1486,6 +1608,7 @@ impl<S: Screen + Default> Hosted for Shell<S> {
            let width = view.cols.track().1 + 8.0;
            let next = slider_step(position, steps, width, key == K::ArrowRight);
            self.screen.slide(s, row.id, next);
+            self.rebuild();
            return vec![DRAGGED];
        }
        if matches!(
@@ -1576,6 +1699,13 @@ impl<S: Screen> Shell<S> {
    pub(crate) fn scroll_amount(&self) -> f32 {
        self.scroll.amount
    }
+    /// The row the shell's own focus is on.
+    pub(crate) fn focused_row(&self) -> Option<S::Row> {
+        match self.focus {
+            Some(Target::Row(row)) => Some(row),
+            _ => None,
+        }
+    }
    /// The captions of the rows the list has now, as the widget tree reads them.
    pub(crate) fn row_labels(&mut self, s: &Settings) -> Vec<String> {
        let view = self.view(s, (854.0, 480.0));
@@ -1601,6 +1731,8 @@ mod tests {
        slider: f32,
        choice: usize,
        pressed: Vec<(u32, bool)>,
+        /// How many times its rows were built.
+        built: std::cell::Cell<usize>,
    }
    const CHOICES: [(&str, &str); 2] = [("Red", "Paints it red."), ("Blue", "Paints it blue.")];
    const SLIDER: u32 = 0;
@@ -1614,7 +1746,12 @@ mod tests {
        fn title(&self) -> &'static str {
            "Probe"
        }
-        fn sheets(&self, _: &Settings) -> Vec<Sheet<u8, u32>> {
+        /// Its rows read the field of view, besides its own state.
+        fn stamp(&self, s: &Settings) -> u64 {
+            stamp_of(&s.fov)
+        }
+        fn sheets(&self, s: &Settings) -> Vec<Sheet<u8, u32>> {
+            self.built.set(self.built.get() + 1);
            let (value, chosen) = CHOICES[self.choice];
            let mut rows = vec![
                Row::new(
@@ -1623,7 +1760,7 @@ mod tests {
                    Value::Slider {
                        position: self.slider,
                        steps: Some(10),
-                        text: "x".to_owned(),
+                        text: s.fov.to_string(),
                    },
                ),
                Row {
@@ -1677,6 +1814,90 @@ mod tests {
        shell.point_at(&Settings::default(), size, row)
    }

+    fn atlas() -> HudAtlas {
+        HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")).unwrap()
+    }
+
+    /// What one frame asks of a screen: a draw, then the stick's scroll, an arrow key and the wheel
+    /// away from any row, at the size it was drawn at.
+    fn frame(shell: &mut Shell<Probe>, s: &mut Settings, atlas: &HudAtlas) -> (f32, f32) {
+        let mut batch = HudBatch::new([1708, 960]);
+        shell.draw(s, &mut batch, atlas, (0.0, 0.0), false, None);
+        let size = (batch.width, batch.height);
+        shell.scroll(s, size, -1.0);
+        shell.key(s, K::ArrowDown, None, false, size);
+        shell.wheel(s, size, (0.0, 0.0), 1.0);
+        size
+    }
+
+    #[test]
+    fn rows_are_built_once_and_again_only_when_what_they_read_changes() {
+        let atlas = atlas();
+        let mut s = Settings::default();
+        let mut shell = Shell::<Probe>::default();
+        let built = |shell: &Shell<Probe>| shell.screen.built.get();
+        let reads = |shell: &mut Shell<Probe>, s: &Settings, size, end: &str| {
+            let view = shell.view(s, size);
+            let mut labels = view.rows.iter().map(|r| r.label(r.value_text().as_deref()));
+            labels.any(|label| label.ends_with(end))
+        };
+        // Each of the four built them before: now the first frame builds them once, the next none.
+        let size = frame(&mut shell, &mut s, &atlas);
+        assert_eq!(built(&shell), 1);
+        frame(&mut shell, &mut s, &atlas);
+        assert_eq!(built(&shell), 1);
+        // A press changes the screen's own state: its row reads the new value.
+        let at = middle_of(&mut shell, CHOICE, size);
+        shell.click(&mut s, at, size, false, false, false);
+        assert!(reads(&mut shell, &s, size, "Blue"));
+        // A setting changed elsewhere (a key bound, a command) shows on the next frame.
+        s.fov = 90.0;
+        frame(&mut shell, &mut s, &atlas);
+        assert!(reads(&mut shell, &s, size, "90"));
+        let before = built(&shell);
+        frame(&mut shell, &mut s, &atlas);
+        assert_eq!(built(&shell), before);
+        // Searching, and another size, build them again.
+        shell.type_text("filler");
+        shell.view(&s, size);
+        assert_eq!(built(&shell), before + 1);
+        shell.view(&s, SHORT);
+        assert_eq!(built(&shell), before + 2);
+        // So does another language, and coming back from it.
+        lang::scoped(lang::Language::load(&[], "de_de"), || shell.view(&s, SHORT));
+        assert_eq!(built(&shell), before + 3);
+        shell.view(&s, SHORT);
+        assert_eq!(built(&shell), before + 4);
+    }
+
+    #[test]
+    fn a_row_the_list_hides_part_of_scrolls_into_view_when_focused_and_then_takes_a_press() {
+        let mut s = Settings::default();
+        let mut shell = Shell::<Probe>::default();
+        let cols = Columns::of(SHORT.0, SHORT.1);
+        // A filler far down, scrolled to just over the bottom: its middle is under the list's edge.
+        let cut = FIRST_FILLER + 20;
+        let view = shell.view(&s, SHORT);
+        let (_, y) = shell.placed(&view).find(|(r, _)| r.id == cut).unwrap();
+        shell.scroll.amount = y - cols.bottom + style::ROW / 2.0 - 1.0;
+        let rect = cols.row(y - shell.scroll.amount);
+        assert!(
+            rect[1] + rect[3] / 2.0 >= cols.bottom,
+            "the row's middle is hidden"
+        );
+        let moved = Hosted::reveal(&mut shell, &s, SHORT, rect).unwrap();
+        let shown = [rect[0], rect[1] + moved, rect[2], rect[3]];
+        assert!(moved < 0.0 && shown[1] + shown[3] <= cols.bottom);
+        // All in view, it stays put.
+        assert_eq!(Hosted::reveal(&mut shell, &s, SHORT, shown), None);
+        let middle = (shown[0] + 4.0, shown[1] + shown[3] / 2.0);
+        assert_eq!(
+            shell.click(&mut s, middle, SHORT, false, false, false),
+            vec![CLICK, CHANGED]
+        );
+        assert_eq!(shell.screen.pressed, [(cut, false)]);
+    }
+
    #[test]
    fn one_scroll_path_moves_the_list_for_wheel_and_stick_alike() {
        let mut s = Settings::default();
@@ -861,6 +861,9 @@ pub trait Backend {
    fn unpause(&mut self, channel: ChannelId);
    /// `Channel.stopped`.
    fn stopped(&mut self, channel: ChannelId) -> bool;
+    /// Whether the channel plays clearly through a mod's muffle (`Audio::muffle`): its sound
+    /// event is one the mod exempted. A backend without a muffle ignores it.
+    fn set_unmuffled(&mut self, _channel: ChannelId, _unmuffled: bool) {}
 }
 /// A `SoundEventListener.onPlaySound` call.
 #[derive(Clone, Debug, PartialEq)]
@@ -937,6 +940,9 @@ pub struct SoundEngine {
    /// listener: 0 as vanilla, `HEARD_RESERVE` with the `uiSoundReserve` extra.
    pub listener_reserve: usize,
    pub notifications: Vec<Notification>,
+    /// The sound events a mod's muffle leaves clear (`Audio::muffle`), normalized: their channels
+    /// are marked as they start, and those playing when the list changes are marked again.
+    unmuffled: Vec<String>,
 }
 fn handle_channel(h: &Handle) -> Option<ChannelId> {
    h.channel
@@ -966,6 +972,21 @@ impl SoundEngine {
            listening: false,
            listener_reserve: 0,
            notifications: Vec::new(),
+            unmuffled: Vec::new(),
+        }
+    }
+    /// The sound events that play clearly through a mod's muffle from now on, normalized
+    /// (`minecraft:ui.button.click`); the channels playing now follow the new list too.
+    pub fn set_unmuffled(&mut self, events: Vec<String>, backend: &mut impl Backend) {
+        self.unmuffled = events;
+        for (id, handle) in &self.instance_to_channel {
+            let (Some(instance), Some(channel)) = (
+                self.instances.get(id),
+                self.handles.get(handle).and_then(handle_channel),
+            ) else {
+                continue;
+            };
+            backend.set_unmuffled(channel, self.unmuffled.contains(&instance.identifier));
        }
    }
    /// Isolate a fixture's dispatch from process-wide native installation.
@@ -1315,6 +1336,7 @@ impl SoundEngine {
        }
        let position = instance.position;
        let looping = instance.looping && instance.delay <= 0;
+        let unmuffled = self.unmuffled.contains(&instance.identifier);
        let streaming = sound.stream;
        let pool = usize::from(streaming);
        // With the `uiSoundReserve` extra, sounds out in the world leave a few static channels free, so a flood of
@@ -1367,6 +1389,7 @@ impl SoundEngine {
        backend.set_looping(channel, looping && !streaming);
        backend.set_position(channel, position);
        backend.set_relative(channel, relative);
+        backend.set_unmuffled(channel, unmuffled);
        backend.start(channel, &sound, looping);
        if tickable {
            self.ticking.push(id);
@@ -1580,27 +1603,6 @@ impl SoundEngine {
    pub fn active_instances(&self) -> Vec<InstanceId> {
        self.instance_to_channel.iter().map(|(i, _)| *i).collect()
    }
-    /// A fresh unseeded random (`RandomSource.create()`).
-    pub fn unseeded() -> LegacyRandom {
-        LegacyRandom::new(unique_seed())
-    }
-}
-/// `RandomSupport.generateUniqueSeed`.
-pub fn unique_seed() -> i64 {
-    use std::sync::atomic::{AtomicI64, Ordering};
-    static UNIQUIFIER: AtomicI64 = AtomicI64::new(8_682_522_807_148_012);
-    let mut current = UNIQUIFIER.load(Ordering::Relaxed);
-    let next = loop {
-        let next = current.wrapping_mul(1_181_783_497_276_652_981);
-        match UNIQUIFIER.compare_exchange(current, next, Ordering::Relaxed, Ordering::Relaxed) {
-            Ok(_) => break next,
-            Err(v) => current = v,
-        }
-    };
-    let nanos = std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .map_or(0, |d| d.as_nanos() as i64);
-    next ^ nanos
 }
 /// The `SoundManager` calls game code makes.
 pub trait Sounds {
@@ -1774,7 +1776,7 @@ mod tests {
            silent: false,
            underwater: false,
        };
-        let mut s = SoundInstance::riding_happy_ghast(&ghast, SoundEngine::unseeded());
+        let mut s = SoundInstance::riding_happy_ghast(&ghast, crate::random_source::create());
        assert_eq!(s.volume, 0.0);
        let mut ctx = TickContext {
            ridden: Some(ghast),
@@ -1821,7 +1823,7 @@ mod tests {
            attack_scale: 0.0,
            sniffer_digging: true,
        };
-        let mut s = SoundInstance::sniffer(3, SoundEngine::unseeded());
+        let mut s = SoundInstance::sniffer(3, crate::random_source::create());
        assert_eq!(s.position, [0.0; 3]);
        assert!(!s.looping);
        let mut ctx = TickContext {
@@ -1836,7 +1838,7 @@ mod tests {
        s.tick(&ctx);
        assert!(s.stopped);
        // Removed (missing): stop.
-        let mut s = SoundInstance::sniffer(3, SoundEngine::unseeded());
+        let mut s = SoundInstance::sniffer(3, crate::random_source::create());
        ctx.mobs.clear();
        s.tick(&ctx);
        assert!(s.stopped);
@@ -1850,7 +1852,7 @@ mod tests {
            silent: false,
            underwater: true,
        };
-        let mut s = SoundInstance::riding_nautilus(&nautilus, SoundEngine::unseeded());
+        let mut s = SoundInstance::riding_nautilus(&nautilus, crate::random_source::create());
        let mut ctx = TickContext {
            ridden: Some(nautilus),
            ..TickContext::default()
@@ -1953,7 +1955,7 @@ mod tests {
            position: [10.0, 64.0, 5.0],
            speed: 0.0,
        };
-        let mut s = SoundInstance::minecart(&cart, SoundEngine::unseeded());
+        let mut s = SoundInstance::minecart(&cart, crate::random_source::create());
        assert!(s.can_start_silent);
        assert_eq!(s.volume, 0.0);

@@ -1993,8 +1995,10 @@ mod tests {
            position: [0.0, 60.0, 0.0],
            speed: 0.4,
        };
-        let mut surface = SoundInstance::riding_minecart(&cart, false, SoundEngine::unseeded());
-        let mut underwater = SoundInstance::riding_minecart(&cart, true, SoundEngine::unseeded());
+        let mut surface =
+            SoundInstance::riding_minecart(&cart, false, crate::random_source::create());
+        let mut underwater =
+            SoundInstance::riding_minecart(&cart, true, crate::random_source::create());

        let mut ctx = TickContext {
            vehicle: Some(99),
@@ -1,8 +1,9 @@
 //! `SoundPreviewHandler`: the sound a category volume slider plays while it
 //! moves on the title screen's options (`Options.createSoundSliderOptionInstance`
 //! calls `preview` when there is no level).
+use crate::random_source;
 use crate::settings::SOUND_SOURCES;
-use crate::sound_engine::{InstanceId, SoundEngine, SoundInstance, Sounds};
+use crate::sound_engine::{InstanceId, SoundInstance, Sounds};

 /// The sound `SoundPreviewHandler.preview` plays for a `SoundSource` index,
 /// or `None` (`SoundEvents.EMPTY`) for master, music and voice.
@@ -44,7 +45,7 @@ impl SoundPreview {
        if let Some(old) = self.active.take() {
            sounds.release(old);
        }
-        let instance = SoundInstance::for_ui(event, 1.0, volume, SoundEngine::unseeded());
+        let instance = SoundInstance::for_ui(event, 1.0, volume, random_source::create());
        self.active = Some(sounds.play_instance(instance, true).0);
    }

@@ -72,7 +73,7 @@ impl SoundPreview {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::sound_engine::{Bound, TickContext, UI, test_backend::Null};
+    use crate::sound_engine::{Bound, SoundEngine, TickContext, UI, test_backend::Null};
    use crate::sound_events::SoundRegistry;

    fn engine() -> SoundEngine {
@@ -70,6 +70,12 @@ pub type Proto = Box<dyn std::any::Any + Send>;
 pub trait ChunkGenerator: Send + Sync + 'static {
    type Worker: Send + 'static;
    fn worker(&self) -> Self::Worker;
+    /// The persistent wrapper supplies starts from their owning chunk, in every dimension.
+    fn set_saved_starts(
+        &self,
+        _source: Arc<horizon_world::worldgen::generator::SavedStructureStarts>,
+    ) {
+    }
    fn lod_sampler(self: Arc<Self>) -> Box<dyn LodSampler>
    where
        Self: Sized,
@@ -199,26 +199,73 @@ fn sprite_at(tiled: vec2<f32>, layer: u32, du: vec2<f32>, dv: vec2<f32>) -> vec4
    return sample_nearest(uv, layer, pixel, du, dv, texel_screen, tiled_face);
 }

+// The terrain stages' values, as the code reads them. What crosses from the vertex stage to the
+// fragment stage is `TerrainWire`: the same values in fewer interpolant locations.
 struct TerrainOut {
-    @builtin(position) clip: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-    @location(1) @interpolate(flat) layer: u32,
-    @location(2) color: vec4<f32>,
-    @location(3) spherical: f32,
-    @location(4) cylindrical: f32,
+    clip: vec4<f32>,
+    uv: vec2<f32>,
+    layer: u32,
+    color: vec4<f32>,
+    spherical: f32,
+    cylindrical: f32,
    // How the face shines in HDR output (mesher.rs's `EMISSION_BITS`): 0 not
    // at all, 1 to 4 the tier with its bright parts, 5 to 8 the tier all over.
-    @location(5) @interpolate(flat) emission: u32,
+    emission: u32,
    // HDR lighting: block and sky light, as levels 0 to 15.
-    @location(11) scene: vec2<f32>,
-    @location(6) @interpolate(flat) fade: u32,
+    scene: vec2<f32>,
+    fade: u32,
    // A distant tile's tile-relative position, for its fade (`faded`).
-    @location(7) local: vec3<f32>,
+    local: vec3<f32>,
    // terrain.vsh's chunkVisibility: the section's fade-in, from 16 blocks out.
-    @location(8) visibility: f32,
+    visibility: f32,
    // The camera-relative height, for the water mirror's cut at the plane.
-    @location(9) height: f32,
-    @location(10) @interpolate(flat) emissive_layer: u32,
+    height: f32,
+    emissive_layer: u32,
+}
+// `TerrainOut` in 5 interpolant locations instead of 12. A GPU's vertex stage pays for each
+// location it exports (AMD's parameter cache gives one a whole slot, however few of its four
+// components are used): on an RX 580 the 12 cost 3.2 ns per quad and these 5 cost 1.6. Every
+// component is still interpolated on its own (and the integers stay flat), so each pixel gets
+// the very values the separate locations gave it.
+struct TerrainWire {
+    @builtin(position) clip: vec4<f32>,
+    // The colour.
+    @location(0) a: vec4<f32>,
+    // `local` and `visibility`.
+    @location(1) b: vec4<f32>,
+    // `uv` and `scene`.
+    @location(2) c: vec4<f32>,
+    // `spherical`, `cylindrical` and `height`.
+    @location(3) d: vec4<f32>,
+    // `layer`, `emission`, `fade` and `emissive_layer`.
+    @location(4) @interpolate(flat) e: vec4<u32>,
+}
+fn to_wire(o: TerrainOut) -> TerrainWire {
+    var w: TerrainWire;
+    w.clip = o.clip;
+    w.a = o.color;
+    w.b = vec4(o.local, o.visibility);
+    w.c = vec4(o.uv, o.scene);
+    w.d = vec4(o.spherical, o.cylindrical, o.height, 0.0);
+    w.e = vec4(o.layer, o.emission, o.fade, o.emissive_layer);
+    return w;
+}
+fn from_wire(w: TerrainWire) -> TerrainOut {
+    var o: TerrainOut;
+    o.clip = w.clip;
+    o.color = w.a;
+    o.local = w.b.xyz;
+    o.visibility = w.b.w;
+    o.uv = w.c.xy;
+    o.scene = w.c.zw;
+    o.spherical = w.d.x;
+    o.cylindrical = w.d.y;
+    o.height = w.d.z;
+    o.layer = w.e.x;
+    o.emission = w.e.y;
+    o.fade = w.e.z;
+    o.emissive_layer = w.e.w;
+    return o;
 }
 // Whether a fading tile or section leaves this pixel out (gfx/lod.rs's
 // `fade_code`, `fade_out_code`). It fades in, or out, chunk by chunk: each
@@ -333,9 +380,9 @@ fn fade_code(w: f32) -> u32 {
@vertex fn vs_terrain(
    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>,
    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec2<u32>,
-    @location(5) origin: vec4<f32>) -> TerrainOut {
-    return terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
-        origin.w);
+    @location(5) origin: vec4<f32>) -> TerrainWire {
+    return to_wire(terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
+        origin.w));
 }
 // Flat section draws (gfx/flat.rs): one draw per arena page over the frame's
 // index list. A section's vertices fill whole 256-vertex blocks of its page:
@@ -346,10 +393,10 @@ fn fade_code(w: f32) -> u32 {
    @builtin(vertex_index) vertex: u32,
    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>,
    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec2<u32>
-) -> TerrainOut {
+) -> TerrainWire {
    let origin = slot_origins[block_slots[vertex >> 8u]];
-    return terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
-        origin.w);
+    return to_wire(terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
+        origin.w));
 }
 // Solid terrain draws in two passes, each over its own part of every mesh's quads
 // (`mesher::Part`): first the quads with no cutout that are not fading, through
@@ -370,38 +417,38 @@ fn left_out() -> TerrainOut {
@vertex fn vs_terrain_opaque(
    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>,
    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec2<u32>,
-    @location(5) origin: vec4<f32>) -> TerrainOut {
-    if !opaque_quad(layer, origin.w) { return left_out(); }
-    return terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
-        origin.w);
+    @location(5) origin: vec4<f32>) -> TerrainWire {
+    if !opaque_quad(layer, origin.w) { return to_wire(left_out()); }
+    return to_wire(terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
+        origin.w));
 }
@vertex fn vs_terrain_cutout(
    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>,
    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec2<u32>,
-    @location(5) origin: vec4<f32>) -> TerrainOut {
-    if opaque_quad(layer, origin.w) { return left_out(); }
-    return terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
-        origin.w);
+    @location(5) origin: vec4<f32>) -> TerrainWire {
+    if opaque_quad(layer, origin.w) { return to_wire(left_out()); }
+    return to_wire(terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
+        origin.w));
 }
@vertex fn vs_terrain_flat_opaque(
    @builtin(vertex_index) vertex: u32,
    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>,
    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec2<u32>
-) -> TerrainOut {
+) -> TerrainWire {
    let origin = slot_origins[block_slots[vertex >> 8u]];
-    if !opaque_quad(layer, origin.w) { return left_out(); }
-    return terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
-        origin.w);
+    if !opaque_quad(layer, origin.w) { return to_wire(left_out()); }
+    return to_wire(terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
+        origin.w));
 }
@vertex fn vs_terrain_flat_cutout(
    @builtin(vertex_index) vertex: u32,
    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>,
    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec2<u32>
-) -> TerrainOut {
+) -> TerrainWire {
    let origin = slot_origins[block_slots[vertex >> 8u]];
-    if opaque_quad(layer, origin.w) { return left_out(); }
-    return terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
-        origin.w);
+    if opaque_quad(layer, origin.w) { return to_wire(left_out()); }
+    return to_wire(terrain_vertex(position, terrain_uv(uv, origin.w), layer, color, light, origin.xyz,
+        origin.w));
 }
 // Solid section draws that read their vertices from the arena page (gfx.rs's `pulled`
 // pipelines; `mesher/packed.rs`): a draw's vertex indices below PACKED_BASE name vertices
@@ -511,37 +558,37 @@ fn corner_vertex(c: ArenaCorner, origin: vec4<f32>) -> TerrainOut {
        unorm8x4(c.r.z), light, origin.xyz, origin.w);
 }
@vertex fn vs_section(@builtin(vertex_index) vertex: u32,
-    @location(5) origin: vec4<f32>) -> TerrainOut {
-    return corner_vertex(section_corner(vertex).c, origin);
+    @location(5) origin: vec4<f32>) -> TerrainWire {
+    return to_wire(corner_vertex(section_corner(vertex).c, origin));
 }
@vertex fn vs_section_opaque(@builtin(vertex_index) vertex: u32,
-    @location(5) origin: vec4<f32>) -> TerrainOut {
+    @location(5) origin: vec4<f32>) -> TerrainWire {
    let s = section_corner(vertex);
-    if !opaque_quad(corner_layer(s.c), origin.w) { return left_out(); }
-    return corner_vertex(s.c, origin);
+    if !opaque_quad(corner_layer(s.c), origin.w) { return to_wire(left_out()); }
+    return to_wire(corner_vertex(s.c, origin));
 }
@vertex fn vs_section_cutout(@builtin(vertex_index) vertex: u32,
-    @location(5) origin: vec4<f32>) -> TerrainOut {
+    @location(5) origin: vec4<f32>) -> TerrainWire {
    let s = section_corner(vertex);
-    if opaque_quad(corner_layer(s.c), origin.w) { return left_out(); }
-    return corner_vertex(s.c, origin);
+    if opaque_quad(corner_layer(s.c), origin.w) { return to_wire(left_out()); }
+    return to_wire(corner_vertex(s.c, origin));
 }
-@vertex fn vs_section_flat(@builtin(vertex_index) vertex: u32) -> TerrainOut {
+@vertex fn vs_section_flat(@builtin(vertex_index) vertex: u32) -> TerrainWire {
    let s = section_corner(vertex);
    let origin = slot_origins[block_slots[s.slot >> 8u]];
-    return corner_vertex(s.c, origin);
+    return to_wire(corner_vertex(s.c, origin));
 }
-@vertex fn vs_section_flat_opaque(@builtin(vertex_index) vertex: u32) -> TerrainOut {
+@vertex fn vs_section_flat_opaque(@builtin(vertex_index) vertex: u32) -> TerrainWire {
    let s = section_corner(vertex);
    let origin = slot_origins[block_slots[s.slot >> 8u]];
-    if !opaque_quad(corner_layer(s.c), origin.w) { return left_out(); }
-    return corner_vertex(s.c, origin);
+    if !opaque_quad(corner_layer(s.c), origin.w) { return to_wire(left_out()); }
+    return to_wire(corner_vertex(s.c, origin));
 }
-@vertex fn vs_section_flat_cutout(@builtin(vertex_index) vertex: u32) -> TerrainOut {
+@vertex fn vs_section_flat_cutout(@builtin(vertex_index) vertex: u32) -> TerrainWire {
    let s = section_corner(vertex);
    let origin = slot_origins[block_slots[s.slot >> 8u]];
-    if opaque_quad(corner_layer(s.c), origin.w) { return left_out(); }
-    return corner_vertex(s.c, origin);
+    if opaque_quad(corner_layer(s.c), origin.w) { return to_wire(left_out()); }
+    return to_wire(corner_vertex(s.c, origin));
 }
 // HDR lighting: how far a surface's light carries it above paper white, 0 to 1. Only the
 // strongest light does, so dark stays as dark as in SDR; sky light by how the face meets the sun.
@@ -620,11 +667,13 @@ fn hdr_mark(tier: u32, y: f32) -> f32 {
    let lift = smoothstep(globals.hdr_windows[0][t], globals.hdr_windows[1][t], y);
    return 0.175 * f32(3u - t) + 0.165 * (1.0 - lift);
 }
-@fragment fn fs_solid(in: TerrainOut) -> @location(0) vec4<f32> {
+@fragment fn fs_solid(wire: TerrainWire) -> @location(0) vec4<f32> {
+    let in = from_wire(wire);
    return solid_color(in);
 }
 // `fs_solid` for the opaque pass (`opaque_quad`): no fade, no cutout, no discard.
-@fragment fn fs_opaque(in: TerrainOut) -> @location(0) vec4<f32> {
+@fragment fn fs_opaque(wire: TerrainWire) -> @location(0) vec4<f32> {
+    let in = from_wire(wire);
    if HDR_LIGHTING && globals.hdr_light.z != 0.0 {
        hdr_normal = normalize(cross(dpdy(in.local), dpdx(in.local)));
    }
@@ -635,7 +684,8 @@ fn hdr_mark(tier: u32, y: f32) -> f32 {
 }
 // The water mirror (gfx.rs's reflection pass): what lies below the water plane
 // (`fog_ends.w`, camera-relative) would show above it in the mirror, so it is cut away.
-@fragment fn fs_solid_mirror(in: TerrainOut) -> @location(0) vec4<f32> {
+@fragment fn fs_solid_mirror(wire: TerrainWire) -> @location(0) vec4<f32> {
+    let in = from_wire(wire);
    if in.height < globals.fog_ends.w { discard; }
    return solid_color(in);
 }
@@ -703,7 +753,8 @@ fn solid_finish_at(in: TerrainOut, texel: vec4<f32>, color: vec4<f32>, du: vec2<
 // HDR lighting on what's mostly opaque among translucent faces (water), drawn again after
 // them with only alpha written: `fs_translucent` blends its alpha as coverage, so a lake's
 // value would be diluted. Clear glass leaves what's behind it, light sources included, alone.
-@fragment fn fs_translucent_mark(in: TerrainOut) -> @location(0) vec4<f32> {
+@fragment fn fs_translucent_mark(wire: TerrainWire) -> @location(0) vec4<f32> {
+    let in = from_wire(wire);
    let dx = dpdx(in.local);
    let dy = dpdy(in.local);
    hdr_normal = normalize(cross(dy, dx));
@@ -716,7 +767,8 @@ fn solid_finish_at(in: TerrainOut, texel: vec4<f32>, color: vec4<f32>, du: vec2<
 // Water, glass and other see-through faces draw whole as they fade in, the
 // layer drawn first in front (gfx.rs's water tiers): dithered, the faded-out
 // pixels showed the layer behind through the one in front, twice the water.
-@fragment fn fs_translucent(in: TerrainOut) -> @location(0) vec4<f32> {
+@fragment fn fs_translucent(wire: TerrainWire) -> @location(0) vec4<f32> {
+    let in = from_wire(wire);
    var color = sprite(in.uv, in.layer & 0x7fffu) * in.color;
    color = mix(globals.fog_color * vec4(1.0, 1.0, 1.0, color.a), color, in.visibility);
    if color.a < 0.01 { discard; }
@@ -9,6 +9,102 @@ use horizon_assets::palette::apply_palette;
 use serde_json::Value;
 use std::{collections::HashMap, fs, path::Path};

+/// Runtime trim slots and the completed ordered requests for their current atlas.
+/// A frame with more requests than slots keeps the same final residents as the
+/// sequential LRU pass, without decoding and evicting them again every frame.
+#[derive(Default)]
+pub struct TrimSlots {
+    slots: Vec<(String, usize)>,
+    atlas_revision: u64,
+    prepared: Option<Vec<TrimTexture>>,
+}
+
+impl TrimSlots {
+    /// The renderer was rebuilt: runtime pixels must be uploaded again.
+    pub fn forget(&mut self) {
+        self.atlas_revision = 0;
+        self.prepared = None;
+    }
+
+    pub fn prepare(
+        &mut self,
+        wanted: Vec<TrimTexture>,
+        root: &Path,
+        atlas: &mut crate::hud::HudAtlas,
+        patches: &mut Vec<crate::font::Patch>,
+    ) {
+        if self.atlas_revision != atlas.revision {
+            for (name, _) in self.slots.drain(..) {
+                atlas.sprites.remove(&name);
+            }
+            self.atlas_revision = atlas.revision;
+            self.prepared = None;
+        }
+        let before = self.slots.len();
+        self.slots
+            .retain(|(name, _)| atlas.sprites.contains_key(name));
+        if before != self.slots.len() {
+            self.prepared = None;
+        }
+        if self.prepared.as_ref() == Some(&wanted) {
+            return;
+        }
+        let mut complete = true;
+        for t in &wanted {
+            let name = t.sprite();
+            if let Some(i) = self.slots.iter().position(|e| e.0 == name) {
+                let e = self.slots.remove(i);
+                self.slots.push(e);
+                continue;
+            }
+            let Some((w, h, rgba)) = t.generate(root) else {
+                complete = false;
+                continue;
+            };
+            let slot =
+                match (0..crate::hud::TRIM_SLOTS).find(|i| !self.slots.iter().any(|e| e.1 == *i)) {
+                    Some(free) => free,
+                    None => {
+                        let (old, slot) = self.slots.remove(0);
+                        atlas.sprites.remove(&old);
+                        slot
+                    }
+                };
+            let Some(area) = atlas.sprites.get(&format!("horizon/trim{slot}")).copied() else {
+                complete = false;
+                continue;
+            };
+            if w > area.w || h > area.h {
+                complete = false;
+                continue;
+            }
+            let (aw, ah) = (atlas.width as f32, atlas.height as f32);
+            let (x, y) = ((area.u0 * aw).round(), (area.v0 * ah).round());
+            patches.push(crate::font::Patch {
+                x: x as u32,
+                y: y as u32,
+                width: w,
+                height: h,
+                rgba,
+            });
+            atlas.sprites.insert(
+                name.clone(),
+                crate::hud::Rect {
+                    u0: area.u0,
+                    v0: area.v0,
+                    u1: (x + w as f32) / aw,
+                    v1: (y + h as f32) / ah,
+                    w,
+                    h,
+                },
+            );
+            self.slots.push((name, slot));
+        }
+        // Failed or not-yet-available textures retain their per-frame retries.
+        self.prepared = complete.then_some(wanted);
+    }
+}
+
 /// An RGBA image: width, height, pixels.
 pub type Image = (u32, u32, Vec<u8>);

@@ -249,6 +345,9 @@ fn png_size(path: &Path) -> Option<(u32, u32)> {
    (&head[12..16] == b"IHDR").then(|| (be(16), be(20)))
 }

+#[cfg(test)]
+mod slots_tests;
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -0,0 +1,192 @@
+use super::*;
+use crate::hud::{HudAtlas, Rect, TRIM_SLOTS};
+use std::path::PathBuf;
+
+struct Fixture(PathBuf);
+
+impl Fixture {
+    fn new() -> Self {
+        static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+        let root = std::env::temp_dir().join(format!(
+            "horizon-trim-slots-{}-{}",
+            std::process::id(),
+            NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+        ));
+        fs::create_dir_all(&root).unwrap();
+        Self(root)
+    }
+
+    fn texture(&self, id: u8) -> TrimTexture {
+        TrimTexture {
+            texture: format!("test:trims/entity/humanoid/{id}"),
+            palette: None,
+        }
+    }
+
+    fn write(&self, id: u8, width: u32) {
+        let path = asset_path(&self.0, "textures", &self.texture(id).texture, ".png");
+        fs::create_dir_all(path.parent().unwrap()).unwrap();
+        let mut encoder = png::Encoder::new(fs::File::create(path).unwrap(), width, 1);
+        encoder.set_color(png::ColorType::Rgba);
+        encoder.set_depth(png::BitDepth::Eight);
+        encoder
+            .write_header()
+            .unwrap()
+            .write_image_data(&[id, 255 - id, 42, 255].repeat(width as usize))
+            .unwrap();
+    }
+
+    fn atlas(&self) -> HudAtlas {
+        let mut atlas = HudAtlas::fonts(&self.0).unwrap();
+        atlas.width = TRIM_SLOTS as u32 * 2;
+        atlas.height = 1;
+        atlas.pixels = vec![0; atlas.width as usize * 4];
+        for i in 0..TRIM_SLOTS {
+            atlas.sprites.insert(
+                format!("horizon/trim{i}"),
+                Rect {
+                    u0: i as f32 / TRIM_SLOTS as f32,
+                    u1: (i + 1) as f32 / TRIM_SLOTS as f32,
+                    v0: 0.0,
+                    v1: 1.0,
+                    w: 2,
+                    h: 1,
+                },
+            );
+        }
+        atlas
+    }
+}
+
+impl Drop for Fixture {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.0);
+    }
+}
+
+fn upload(atlas: &mut HudAtlas, patches: &mut Vec<crate::font::Patch>) {
+    for patch in patches.drain(..) {
+        for y in 0..patch.height as usize {
+            let offset = ((patch.y as usize + y) * atlas.width as usize + patch.x as usize) * 4;
+            let width = patch.width as usize * 4;
+            atlas.pixels[offset..offset + width]
+                .copy_from_slice(&patch.rgba[y * width..(y + 1) * width]);
+        }
+    }
+}
+
+fn color(atlas: &HudAtlas, texture: &TrimTexture) -> Option<[u8; 4]> {
+    let rect = atlas.sprites.get(&texture.sprite())?;
+    let x = (rect.u0 * atlas.width as f32).round() as usize;
+    Some(atlas.pixels[x * 4..x * 4 + 4].try_into().unwrap())
+}
+
+#[test]
+fn overflow_keeps_the_rendered_pixels_without_reuploading_each_frame() {
+    let fixture = Fixture::new();
+    let wanted: Vec<_> = (0..33).map(|id| fixture.texture(id)).collect();
+    for id in 0..33 {
+        fixture.write(id, 2);
+    }
+    let mut atlas = fixture.atlas();
+    let mut slots = TrimSlots::default();
+    let mut patches = Vec::new();
+    slots.prepare(wanted.clone(), &fixture.0, &mut atlas, &mut patches);
+    upload(&mut atlas, &mut patches);
+    // The original sequential 32-slot pass finishes with requests 1..=32.
+    assert_eq!(color(&atlas, &wanted[0]), None);
+    for (id, texture) in wanted.iter().enumerate().skip(1) {
+        assert_eq!(
+            color(&atlas, texture),
+            Some([id as u8, 255 - id as u8, 42, 255])
+        );
+    }
+    for _ in 0..3 {
+        slots.prepare(wanted.clone(), &fixture.0, &mut atlas, &mut patches);
+        assert!(
+            patches.is_empty(),
+            "unchanged overflow must not upload again"
+        );
+    }
+    wanted
+        .iter()
+        .skip(1)
+        .for_each(|t| assert!(color(&atlas, t).is_some()));
+}
+
+#[test]
+fn changing_request_order_or_equipment_changes_the_resident_images() {
+    let fixture = Fixture::new();
+    for id in 0..34 {
+        fixture.write(id, 2);
+    }
+    let mut wanted: Vec<_> = (0..33).map(|id| fixture.texture(id)).collect();
+    let mut atlas = fixture.atlas();
+    let mut slots = TrimSlots::default();
+    let mut patches = Vec::new();
+    slots.prepare(wanted.clone(), &fixture.0, &mut atlas, &mut patches);
+    upload(&mut atlas, &mut patches);
+    wanted.rotate_left(1);
+    slots.prepare(wanted.clone(), &fixture.0, &mut atlas, &mut patches);
+    upload(&mut atlas, &mut patches);
+    assert_eq!(color(&atlas, &fixture.texture(1)), None);
+    assert_eq!(color(&atlas, &fixture.texture(0)), Some([0, 255, 42, 255]));
+    wanted = vec![fixture.texture(33), fixture.texture(2)];
+    slots.prepare(wanted.clone(), &fixture.0, &mut atlas, &mut patches);
+    upload(&mut atlas, &mut patches);
+    assert_eq!(color(&atlas, &wanted[0]), Some([33, 222, 42, 255]));
+    assert_eq!(color(&atlas, &wanted[1]), Some([2, 253, 42, 255]));
+}
+
+#[test]
+fn an_atlas_rebuild_uploads_the_same_requests_again() {
+    let fixture = Fixture::new();
+    fixture.write(7, 2);
+    let wanted = vec![fixture.texture(7)];
+    let mut slots = TrimSlots::default();
+    let mut patches = Vec::new();
+    let mut atlas = fixture.atlas();
+    slots.prepare(wanted.clone(), &fixture.0, &mut atlas, &mut patches);
+    upload(&mut atlas, &mut patches);
+    atlas = fixture.atlas();
+    fixture.write(7, 1);
+    slots.prepare(wanted.clone(), &fixture.0, &mut atlas, &mut patches);
+    assert_eq!(patches.len(), 1);
+    assert_eq!(patches[0].width, 1, "reload must decode the new image");
+    upload(&mut atlas, &mut patches);
+    assert_eq!(color(&atlas, &wanted[0]), Some([7, 248, 42, 255]));
+    atlas.pixels.fill(0);
+    slots.forget();
+    slots.prepare(wanted.clone(), &fixture.0, &mut atlas, &mut patches);
+    assert_eq!(
+        patches.len(),
+        1,
+        "a rebuilt renderer needs the pixels again"
+    );
+    upload(&mut atlas, &mut patches);
+    assert_eq!(color(&atlas, &wanted[0]), Some([7, 248, 42, 255]));
+    atlas.sprites.remove(&wanted[0].sprite());
+    slots.prepare(wanted.clone(), &fixture.0, &mut atlas, &mut patches);
+    assert_eq!(patches.len(), 1, "an erased sprite must be restored too");
+    upload(&mut atlas, &mut patches);
+    assert_eq!(color(&atlas, &wanted[0]), Some([7, 248, 42, 255]));
+}
+
+#[test]
+fn missing_or_oversized_images_are_retried_when_they_become_available() {
+    let fixture = Fixture::new();
+    let wanted = vec![fixture.texture(9)];
+    let mut atlas = fixture.atlas();
+    let mut slots = TrimSlots::default();
+    let mut patches = Vec::new();
+    slots.prepare(wanted.clone(), &fixture.0, &mut atlas, &mut patches);
+    assert_eq!(color(&atlas, &wanted[0]), None);
+    fixture.write(9, 3);
+    slots.prepare(wanted.clone(), &fixture.0, &mut atlas, &mut patches);
+    assert!(patches.is_empty());
+    fixture.write(9, 2);
+    slots.prepare(wanted.clone(), &fixture.0, &mut atlas, &mut patches);
+    assert_eq!(patches.len(), 1);
+    upload(&mut atlas, &mut patches);
+    assert_eq!(color(&atlas, &wanted[0]), Some([9, 246, 42, 255]));
+}
@@ -105,6 +105,8 @@ thread_local! {
    static ACTION_SCREENS: Cell<(u64, u64)> = const { Cell::new((0, 0)) };
    /// The lists drawn with a scrollbar since `end_frame`, and the last frame's.
    static SCROLL_AREAS: RefCell<(Vec<ScrollArea>, Vec<ScrollArea>)> = const { RefCell::new((Vec::new(), Vec::new())) };
+    /// The steps screens declared since `end_frame` ([`focus_link`]), and the last frame's.
+    static FOCUS_LINKS: RefCell<(Vec<FocusLink>, Vec<FocusLink>)> = const { RefCell::new((Vec::new(), Vec::new())) };
 }

 /// Splitscreen: one player's buttons and focus targets, kept aside while another player's game
@@ -117,6 +119,7 @@ pub struct Saved(
    bool,
    (u64, u64),
    (Vec<ScrollArea>, Vec<ScrollArea>),
+    (Vec<FocusLink>, Vec<FocusLink>),
 );

 /// This thread's buttons and targets, leaving none.
@@ -128,6 +131,7 @@ pub fn take() -> Saved {
        ACTION_GLYPHS.take(),
        ACTION_SCREENS.take(),
        SCROLL_AREAS.take(),
+        FOCUS_LINKS.take(),
    )
 }

@@ -136,6 +140,7 @@ pub fn put(saved: Saved) {
    WIDGETS.set(saved.0);
    TARGETS.set(saved.1);
    SCROLL_AREAS.set(saved.5);
+    FOCUS_LINKS.set(saved.6);
    ACTIONS.set(saved.2);
    ACTION_GLYPHS.set(saved.3);
    ACTION_SCREENS.set(saved.4);
@@ -282,6 +287,7 @@ pub fn cover_frame() {
    TARGETS.with_borrow_mut(|(current, _, _)| current.clear());
    ACTIONS.with_borrow_mut(|(current, _)| current.clear());
    SCROLL_AREAS.with_borrow_mut(|(current, _)| current.clear());
+    FOCUS_LINKS.with_borrow_mut(|(current, _)| current.clear());
 }

 /// This frame drew a list with something to scroll, in `rect`, scrolled `amount`
@@ -315,6 +321,38 @@ pub fn over_scroll_area(at: (f32, f32)) -> (f32, f32) {
    })
 }

+/// A step the arrows and the D-pad take that the rectangles don't show: `down` (else up) from
+/// a focus whose middle is in `from`, to the target at `to`.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct FocusLink {
+    pub from: [f32; 4],
+    pub down: bool,
+    pub to: [f32; 4],
+}
+
+/// Down (or up) from what is in `from` goes to `to`: a screen whose layout puts the next control
+/// off to one side, where vanilla's step would pass it by (the settings shell's search field over
+/// its list, on a screen with no page list).
+pub fn focus_link(from: [f32; 4], down: bool, to: [f32; 4]) {
+    FOCUS_LINKS.with_borrow_mut(|(current, _)| current.push(FocusLink { from, down, to }));
+}
+
+/// Where the last drawn frame said a step `down` (else up) from `focus` goes, if it said.
+pub fn linked_step(focus: [f32; 4], down: bool) -> Option<[f32; 4]> {
+    let [x, y, w, h] = focus;
+    let middle = (x + w / 2.0, y + h / 2.0);
+    FOCUS_LINKS.with_borrow(|(_, last)| {
+        last.iter()
+            .find(|l| {
+                let [lx, ly, lw, lh] = l.from;
+                l.down == down
+                    && (lx..lx + lw).contains(&middle.0)
+                    && (ly..ly + lh).contains(&middle.1)
+            })
+            .map(|l| l.to)
+    })
+}
+
 /// The focus targets of the last drawn frame.
 pub fn last_targets() -> Vec<Target> {
    TARGETS.with_borrow(|(_, last, _)| last.clone())
@@ -392,6 +430,9 @@ pub fn end_frame(frames: u64) {
            SCROLL_AREAS.with_borrow_mut(|(current, last)| {
                *last = std::mem::take(current);
            });
+            FOCUS_LINKS.with_borrow_mut(|(current, last)| {
+                *last = std::mem::take(current);
+            });
            NARRATION.with_borrow_mut(|(current, last)| {
                *last = std::mem::replace(current, Narration::EMPTY);
            });
@@ -56,6 +56,32 @@ fn luma(c: vec3<f32>) -> f32 {
    return vec4(b, centre.a);
 }

+// Contrast-adaptive sharpening (after AMD's CAS) of TAA's upscaled picture: each
+// pixel pushed away from its four neighbours, less where they already differ a lot,
+// so edges get their crispness back without halos or lifted grain.
+// The Upscaling Sharpness setting, 0..1.
+override sharpness: f32 = 0.85;
+
+@fragment fn fs_sharpen(in: PostOut) -> @location(0) vec4<f32> {
+    let size = vec2<i32>(textureDimensions(world));
+    let p = clamp(vec2<i32>(in.uv * vec2<f32>(size)), vec2(0), size - 1);
+    let centre = textureLoad(world, p, 0);
+    let c = centre.rgb;
+    let n = textureLoad(world, clamp(p + vec2(0, -1), vec2(0), size - 1), 0).rgb;
+    let s = textureLoad(world, clamp(p + vec2(0, 1), vec2(0), size - 1), 0).rgb;
+    let w = textureLoad(world, clamp(p + vec2(-1, 0), vec2(0), size - 1), 0).rgb;
+    let e = textureLoad(world, clamp(p + vec2(1, 0), vec2(0), size - 1), 0).rgb;
+    let lo = min(c, min(min(n, s), min(w, e)));
+    let hi = max(c, max(max(n, s), max(w, e)));
+    // How much room there is before clipping, per channel: little at strong edges.
+    let room = clamp(min(lo, 2.0 - hi) / max(hi, vec3(0.0001)), vec3(0.0), vec3(1.0));
+    // Up to -1/5, the most CAS allows (the Upscaling Sharpness setting's 100%).
+    let lobe = -sqrt(room) * 0.2 * sharpness;
+    let sharp = (c + lobe * (n + s + w + e)) / (1.0 + 4.0 * lobe);
+    // The alpha carries the emissive mark through to HDR output (hdr.wgsl).
+    return vec4(clamp(sharp, lo, hi), centre.a);
+}
+
 // TAA (`world_post.rs`): blend this frame into the history, reprojected from the
 // depth buffer through the camera's motion and clamped to this frame's 3x3
 // neighbourhood so that what moved or appeared does not ghost.
@@ -95,6 +121,28 @@ fn sample_history(uv: vec2<f32>) -> vec3<f32> {
    return max(c / weight, vec3(0.0));
 }

+fn to_ycocg(c: vec3<f32>) -> vec3<f32> {
+    return vec3(0.25 * (c.r + 2.0 * c.g + c.b), 0.5 * (c.r - c.b), 0.25 * (2.0 * c.g - c.r - c.b));
+}
+
+fn from_ycocg(c: vec3<f32>) -> vec3<f32> {
+    return max(vec3(c.x + c.y - c.z, c.x + c.z, c.x - c.y - c.z), vec3(0.0));
+}
+
+// Moves `c` toward the box's centre until it lies inside (clipping keeps the
+// colour's hue where a per-channel clamp would shift it).
+fn clip_box(c: vec3<f32>, lo: vec3<f32>, hi: vec3<f32>) -> vec3<f32> {
+    let mid = 0.5 * (hi + lo);
+    let half_size = max(0.5 * (hi - lo), vec3(0.0001));
+    let d = c - mid;
+    let unit = abs(d / half_size);
+    let far = max(unit.x, max(unit.y, unit.z));
+    if far > 1.0 {
+        return mid + d / far;
+    }
+    return c;
+}
+
 // It runs at the history's size, which upscaling makes larger than the world's.
 // The history is unjittered: each output pixel takes the world pixel whose
 // jittered sample lands nearest its centre, weighted by how near it lands.
@@ -106,17 +154,24 @@ fn sample_history(uv: vec2<f32>) -> vec3<f32> {
    let last = vec2<i32>(size) - 1;
    let p = clamp(vec2<i32>(floor(drawn)), vec2(0), last);
    let centre = textureLoad(world, p, 0);
-    var lo = centre.rgb;
-    var hi = centre.rgb;
+    var lo = to_ycocg(centre.rgb);
+    var hi = lo;
+    // Mean and spread of the 3x3 (YCoCg): the history is clipped to a box around
+    // the mean a few deviations wide, tighter than min..max, so that what changed
+    // does not linger as a smear.
+    var m1 = vec3(0.0);
+    var m2 = vec3(0.0);
    // Reversed depth: the nearest of the 3x3 is the largest, and its motion keeps
    // the edges of what is in front from trailing.
    var near = 0.0;
    for (var y = -1; y <= 1; y++) {
        for (var x = -1; x <= 1; x++) {
            let q = clamp(p + vec2(x, y), vec2(0), last);
-            let c = textureLoad(world, q, 0).rgb;
+            let c = to_ycocg(textureLoad(world, q, 0).rgb);
            lo = min(lo, c);
            hi = max(hi, c);
+            m1 += c;
+            m2 += c * c;
            near = max(near, textureLoad(depth, q, 0).r);
        }
    }
@@ -126,12 +181,19 @@ fn sample_history(uv: vec2<f32>) -> vec3<f32> {
    if taa.jitter.z > 0.0 || any(uv != clamp(uv, vec2(0.0), vec2(1.0))) {
        return vec4(centre.rgb, centre.a);
    }
-    let past = clamp(sample_history(uv), lo, hi);
+    // How far this pixel moved since the last frame, in output pixels.
+    let speed = length((uv - in.uv) * vec2<f32>(textureDimensions(history)));
+    let moving = clamp(speed / 6.0, 0.0, 1.0);
+    let mean = m1 / 9.0;
+    let sigma = sqrt(max(m2 / 9.0 - mean * mean, vec3(0.0)));
+    let wide = mix(1.25, 0.75, moving) * sigma;
+    let past = from_ycocg(clip_box(to_ycocg(sample_history(uv)), max(lo, mean - wide), min(hi, mean + wide)));
    // How far the sample landed from this pixel's centre, in output pixels: a
    // Gaussian of it scales the new frame's share, so that frames whose sample
-    // fell far away (most of them when upscaling) barely move the pixel.
+    // fell far away (most of them when upscaling) barely move the pixel. Under
+    // motion the history is resampled every frame and blurs, so new frames weigh more.
    let off = (drawn - (vec2<f32>(p) + 0.5)) * vec2<f32>(textureDimensions(history)) / size;
-    let share = 0.1 * exp(-2.0 * dot(off, off));
+    let share = mix(0.1, 0.3, moving) * exp(-2.0 * dot(off, off));
    // The alpha carries the emissive mark through to HDR output (hdr.wgsl).
    return vec4(mix(past, centre.rgb, share), centre.a);
 }
@@ -7,7 +7,10 @@ use std::{
    fs,
    io::{self, Read, Seek, SeekFrom},
    path::Path,
-    sync::Arc,
+    sync::{
+        Arc,
+        atomic::{AtomicU64, Ordering},
+    },
 };
 use zip::{CompressionMethod, ZipArchive};

@@ -169,30 +172,12 @@ impl Zip {
        self.index(name).is_some()
    }
    pub fn read(&self, name: &str) -> io::Result<Vec<u8>> {
-        let index = self
-            .index(name)
-            .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, name.to_owned()))?;
-        // A clone shares the reader's data and the central directory: reading
-        // needs `&mut`.
-        let mut archive = self.archive.clone();
-        let mut entry = archive.by_index_raw(index).map_err(invalid)?;
-        let method = entry.compression();
-        let mut raw = Vec::with_capacity((entry.compressed_size() as usize).min(self.len));
-        entry.read_to_end(&mut raw)?;
+        let (method, raw) = self.raw(name)?;
        match method {
            CompressionMethod::Stored => Ok(raw),
            CompressionMethod::Deflated => {
-                // Java's ZipFile trusts neither size an entry declares: it
-                // inflates the stream to its end and keeps what comes out.
-                // Packs in the wild (a Nexo-generated one served through
-                // Dropbox, for one) carry central-directory sizes that point
-                // at other files, and miniz_oxide, which refuses input past
-                // the stream's end, failed whole entries with "corrupt
-                // deflate stream" and with them the whole pack. Only the
-                // size limit stands between the archive and a zip bomb.
-                let decoder = flate2::read::DeflateDecoder::new(raw.as_slice());
                let mut decoded = Vec::with_capacity(raw.len().min(MAX_ENTRY));
-                decoder
+                inflate(&raw)
                    .take(MAX_ENTRY as u64 + 1)
                    .read_to_end(&mut decoded)
                    .map_err(|_| invalid("corrupt deflate stream"))?;
@@ -204,6 +189,81 @@ impl Zip {
            _ => Err(invalid("unsupported zip compression")),
        }
    }
+    /// What [`Self::read`] reads, written to `out` a piece at a time as it inflates, each piece
+    /// taken from `budget`: the bytes left for everything sharing it. Past the budget it stops
+    /// with [`io::ErrorKind::FileTooLarge`], `out` holding part of the entry; the entry's own
+    /// limit ([`MAX_ENTRY`]) still applies. Memory stays at the compressed entry and one piece,
+    /// whatever the entry inflates to. The bytes written.
+    pub fn copy_to(
+        &self,
+        name: &str,
+        out: &mut impl io::Write,
+        budget: &AtomicU64,
+    ) -> io::Result<u64> {
+        let (method, raw) = self.raw(name)?;
+        let mut from: Box<dyn Read + '_> = match method {
+            CompressionMethod::Stored => Box::new(raw.as_slice()),
+            CompressionMethod::Deflated => Box::new(inflate(&raw)),
+            _ => return Err(invalid("unsupported zip compression")),
+        };
+        let mut piece = vec![0; 64 << 10];
+        let mut total = 0u64;
+        loop {
+            let n = match from.read(&mut piece) {
+                Ok(0) => return Ok(total),
+                Ok(n) => n,
+                Err(e) if e.kind() == io::ErrorKind::Interrupted => continue,
+                Err(_) => return Err(invalid("corrupt deflate stream")),
+            };
+            total += n as u64;
+            if total > MAX_ENTRY as u64 {
+                return Err(invalid("entry inflates past the size limit"));
+            }
+            take(budget, n as u64)?;
+            out.write_all(&piece[..n])?;
+        }
+    }
+    /// The entry `name` as stored: its compression and its bytes.
+    fn raw(&self, name: &str) -> io::Result<(CompressionMethod, Vec<u8>)> {
+        let index = self
+            .index(name)
+            .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, name.to_owned()))?;
+        // A clone shares the reader's data and the central directory: reading
+        // needs `&mut`.
+        let mut archive = self.archive.clone();
+        let mut entry = archive.by_index_raw(index).map_err(invalid)?;
+        let method = entry.compression();
+        let mut raw = Vec::with_capacity((entry.compressed_size() as usize).min(self.len));
+        entry.read_to_end(&mut raw)?;
+        Ok((method, raw))
+    }
+}
+
+/// `n` bytes taken from `budget`, or `FileTooLarge` (taking nothing) when it has fewer left.
+fn take(budget: &AtomicU64, n: u64) -> io::Result<()> {
+    let mut left = budget.load(Ordering::Relaxed);
+    loop {
+        let rest = left.checked_sub(n).ok_or_else(|| {
+            io::Error::new(
+                io::ErrorKind::FileTooLarge,
+                "the packs unpack to more than their size allows",
+            )
+        })?;
+        match budget.compare_exchange_weak(left, rest, Ordering::Relaxed, Ordering::Relaxed) {
+            Ok(_) => return Ok(()),
+            Err(now) => left = now,
+        }
+    }
+}
+
+/// A deflated entry's bytes as they inflate. Java's ZipFile trusts neither size an entry
+/// declares: it inflates the stream to its end and keeps what comes out. Packs in the wild (a
+/// Nexo-generated one served through Dropbox, for one) carry central-directory sizes that point
+/// at other files, and miniz_oxide, which refuses input past the stream's end, failed whole
+/// entries with "corrupt deflate stream" and with them the whole pack. Only the size limits
+/// stand between the archive and a zip bomb.
+fn inflate(raw: &[u8]) -> flate2::read::DeflateDecoder<&[u8]> {
+    flate2::read::DeflateDecoder::new(raw)
 }

 /// The 22 fixed bytes of the end-of-central-directory record.
@@ -109,12 +109,19 @@ objc2-foundation = { version = "0.3", default-features = false, features = ["std
 wgpu = { version = "30.0.1", default-features = false, features = ["gles"] }

 [features]
-default = ["audio", "controllers", "discord", "friends", "heartbeat"]
+default = ["audio", "controllers", "horizon-extras"]
 # Sound output. Without it (and `controllers`) the program links neither libasound nor libudev on
 # Linux: the server build (`--no-default-features`, released as horizon-engine; docs/server.md).
 audio = ["horizon-client-render/audio", "horizon-client-lib/audio"]
 # Controllers: gilrs, and the DualSense's own output. Without it only `horizon-ctl pad`'s virtual pad.
 controllers = ["horizon-client-lib/controllers", "dep:gilrs", "dep:horizon-dualsense", "horizon-client-input/controllers"]
+# Horizon's own extras over the vanilla game, for a fork that wants them out (docs/forking.md):
+# cosmetics and emotes, the "Horizon player" presence, the official and partner servers added to
+# the server list, the Horizon Settings and Mods pages, Discord, Play with Friends and the
+# heartbeat. Players always get them; there is no switch. `grep -rn horizon-extras crates/` lists
+# every place it gates. Without it (`--no-default-features --features audio,controllers`) the
+# client is best effort: CI builds only the default.
+horizon-extras = ["discord", "friends", "heartbeat"]
 # Online extras a server or a port can leave out; the server build has none of them. "Playing Horizon"
 # on Discord (game/discord.rs).
 discord = ["horizon-client-lib/discord"]
@@ -47,6 +47,21 @@
  "horizon.studio.replay.seek.invalid": "Ungültige Wiedergabeposition",
  "horizon.studio.replay.status": "Studio-Wiedergabe: %s / %s ms (%s%%), Geschwindigkeit %s×, pausiert %s, beendet %s",
  "horizon.studio.replay.closed": "Studio-Wiedergabe geschlossen",
+  "horizon.studio.freecam.enabled": "Studio-Freikamera aktiviert. WASD bewegt sie, Leertaste und Umschalt heben oder senken sie, Strg beschleunigt.",
+  "horizon.studio.freecam.disabled": "Studio-Freikamera deaktiviert",
+  "horizon.studio.freecam.unavailable": "Die Studio-Freikamera konnte keine Spielerkamera finden",
+  "horizon.studio.freecam.replay_required": "Die Studio-Freikamera ist während der Wiedergabe verfügbar",
+  "horizon.studio.freecam.usage": "Verwendung: /studio freecam <on|off>",
+  "horizon.studio.keyframe.added": "Kameraschlüsselbild bei %s ms hinzugefügt. Der Pfad wird beim Schließen der Wiedergabe gespeichert.",
+  "horizon.studio.keyframe.cleared": "Kamerapfad geleert. Die Änderung wird beim Schließen der Wiedergabe gespeichert.",
+  "horizon.studio.keyframe.removed": "Kameraschlüsselbild %s entfernt. Die Änderung wird beim Schließen der Wiedergabe gespeichert.",
+  "horizon.studio.keyframe.save_error": "Kamerapfad konnte nicht gespeichert werden: %s",
+  "horizon.studio.keyframe.remove_usage": "Verwendung: /studio keyframe remove <INDEX>",
+  "horizon.studio.keyframe.index_invalid": "Kameraschlüsselbildindex liegt außerhalb des Bereichs",
+  "horizon.studio.keyframe.usage": "Verwendung: /studio keyframe <add|remove INDEX|clear>",
+  "horizon.studio.path.locked": "Studio-Kamerapfadwiedergabe aktiviert",
+  "horizon.studio.path.unlocked": "Studio-Kamerapfadwiedergabe gestoppt",
+  "horizon.studio.path.usage": "Verwendung: /studio path <lock|unlock> (zuerst mindestens ein Schlüsselbild hinzufügen)",
  "horizon.studio.saved_recordings": "Gespeicherte Aufzeichnungen",
  "horizon.studio.empty": "Keine Aufzeichnungen im Aufnahmeordner gefunden.",
  "horizon.studio.empty_hint": "Nutze /studio record start <name> in einer Welt oder lege .mcpr-Dateien dort ab.",
@@ -113,6 +128,7 @@
  "Resolution Scale": "Auflösungsskalierung",
  "Anti-aliasing": "Kantenglättung",
  "Upscaling": "Upscaling",
+  "Upscaling Sharpness": "Upscaling-Schärfe",
  "Paper White": "Papierweiß",
  "Peak Brightness": "Spitzenhelligkeit",
  "Black Level": "Schwarzwert",
@@ -208,6 +224,7 @@
  "World pixels per screen pixel. Below 100% is faster on the GPU.": "Weltpixel pro Bildschirmpixel. Unter 100 % ist es auf der GPU schneller.",
  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Glättet Kanten. FXAA: weicher. TAA: am glattesten, evtl. Schlieren.",
  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Rendert die Welt kleiner und baut sie mit TAA wieder auf. Schneller, weicher.",
+  "Sharpens the upscaled picture. Higher: crisper edges, more shimmer.": "Schärft das hochskalierte Bild. Höher: schärfere Kanten, mehr Flimmern.",
  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "HDR-Ausgabe auf HDR-Bildschirm: Lava, Feuer, Sonne heller.",
  "How frames reach the screen while VSync is off.": "Wie Bilder auf den Bildschirm gelangen, wenn VSync aus ist.",
  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "Sparsam schläft bis zum nächsten Bild; Präzise wartet aktiv, wie in Vanilla.",
@@ -226,6 +243,7 @@
  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Pro Bild an die GPU gesendete Mesh-Daten. Weniger ist flüssiger beim Laden.",
  "Frame rate and frame times over the game, with a graph.": "Bildrate und Bildzeiten über dem Spiel, mit Diagramm.",
  "horizon.multiplayer.finding_friend": "Die Welt deines Freundes wird gesucht …",
+  "horizon.plain.official": "Offizielles Horizon mit Launcher, Mods und Updates: playhorizon.dev",
  "horizon.title.not_affiliated": "Nicht mit Mojang oder Microsoft verbunden",
  "horizon.extras.header.lighting": "Beleuchtung",
  "horizon.extras.header.third_person": "Dritte Person",
@@ -63,6 +63,8 @@
  "horizon.options.look_sensitivity": "Look Sensitivity",
  "horizon.options.invert_x": "Invert Look X",
  "horizon.options.invert_y": "Invert Look Y",
+  "horizon.options.craft_on_servers": "Quick Craft on Servers",
+  "horizon.controller.direct_craft": "Quick Craft",
  "horizon.options.sneak_button": "Sneak Button",
  "horizon.options.move_deadzone": "Move Deadzone",
  "horizon.options.look_deadzone": "Look Deadzone",
@@ -76,6 +78,9 @@
  "horizon.options.glyphs.xbox": "Xbox",
  "horizon.options.glyphs.playstation": "PlayStation",
  "horizon.options.glyphs.nintendo": "Nintendo",
+  "horizon.options.nintendo_buttons": "Nintendo Buttons",
+  "horizon.options.nintendo_buttons.position": "By Position",
+  "horizon.options.nintendo_buttons.letter": "By Letter",
  "horizon.options.keyboard.auto": "Auto",
  "horizon.options.keyboard.horizon": "Horizon",
  "horizon.options.keyboard.steam": "Steam",
@@ -104,6 +109,21 @@
  "horizon.studio.replay.seek.invalid": "Invalid replay position",
  "horizon.studio.replay.status": "Studio replay: %s / %s ms (%s%%), speed %s×, paused %s, finished %s",
  "horizon.studio.replay.closed": "Studio replay closed",
+  "horizon.studio.freecam.enabled": "Studio free camera enabled. Use WASD to move, Space and Shift to rise or descend, and Control to move faster.",
+  "horizon.studio.freecam.disabled": "Studio free camera disabled",
+  "horizon.studio.freecam.unavailable": "Studio free camera could not find a player camera",
+  "horizon.studio.freecam.replay_required": "Studio free camera is available during replay playback",
+  "horizon.studio.freecam.usage": "Usage: /studio freecam <on|off>",
+  "horizon.studio.keyframe.added": "Camera keyframe added at %s ms. The path is saved when you close the replay.",
+  "horizon.studio.keyframe.cleared": "Camera path cleared. The change is saved when you close the replay.",
+  "horizon.studio.keyframe.removed": "Removed camera keyframe %s. The change is saved when you close the replay.",
+  "horizon.studio.keyframe.save_error": "Could not save camera path: %s",
+  "horizon.studio.keyframe.remove_usage": "Usage: /studio keyframe remove <INDEX>",
+  "horizon.studio.keyframe.index_invalid": "Camera keyframe index is out of range",
+  "horizon.studio.keyframe.usage": "Usage: /studio keyframe <add|remove INDEX|clear>",
+  "horizon.studio.path.locked": "Studio camera path playback enabled",
+  "horizon.studio.path.unlocked": "Studio camera path playback stopped",
+  "horizon.studio.path.usage": "Usage: /studio path <lock|unlock> (add at least one keyframe first)",
  "horizon.pages.mods": "Mods",
  "horizon.pages.shader_packs": "Shader Packs",
  "horizon.pages.shader_options": "Shader Options",
@@ -216,6 +236,7 @@
  "Resolution Scale": "Resolution Scale",
  "Anti-aliasing": "Anti-aliasing",
  "Upscaling": "Upscaling",
+  "Upscaling Sharpness": "Upscaling Sharpness",
  "Paper White": "Paper White",
  "Peak Brightness": "Peak Brightness",
  "Black Level": "Black Level",
@@ -317,6 +338,7 @@
  "World pixels per screen pixel. Below 100% is faster on the GPU.": "World pixels per screen pixel. Below 100% is faster on the GPU.",
  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.",
  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Renders the world smaller and rebuilds it with TAA. Faster, softer.",
+  "Sharpens the upscaled picture. Higher: crisper edges, more shimmer.": "Sharpens the upscaled picture. Higher: crisper edges, more shimmer.",
  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "HDR output on an HDR display: lava, fire and sunlight shine brighter.",
  "How frames reach the screen while VSync is off.": "How frames reach the screen while VSync is off.",
  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "Efficient sleeps until the next frame; Precise spins, like vanilla.",
@@ -366,6 +388,7 @@
  "Brighter-than-white output on an HDR display.": "Brighter-than-white output on an HDR display.",
  "Results for \"%s\"": "Results for \"%s\"",
  "No settings match.": "No settings match.",
+  "horizon.plain.official": "Official Horizon with launcher, mods and updates: playhorizon.dev",
  "horizon.title.not_affiliated": "Not affiliated with Mojang or Microsoft",
  "horizon.extras.header.lighting": "Lighting",
  "horizon.extras.header.third_person": "Third person",
@@ -946,12 +969,15 @@
  "Always shows Xbox buttons.": "Always shows Xbox buttons.",
  "Always shows PlayStation buttons.": "Always shows PlayStation buttons.",
  "Always shows Nintendo buttons.": "Always shows Nintendo buttons.",
+  "A, on the right, confirms and jumps and B goes back, as on a Switch.": "A, on the right, confirms and jumps and B goes back, as on a Switch.",
+  "B, at the bottom, confirms and jumps and A goes back, as on other controllers.": "B, at the bottom, confirms and jumps and A goes back, as on other controllers.",
  "Opens Steam's keyboard on a Steam Deck under Steam, and Horizon's otherwise.": "Opens Steam's keyboard on a Steam Deck under Steam, and Horizon's otherwise.",
  "Always opens Horizon's keyboard.": "Always opens Horizon's keyboard.",
  "Always opens Steam's keyboard.": "Always opens Steam's keyboard.",
  "A DualSense's light shows your health, from green through amber to red.": "A DualSense's light shows your health, from green through amber to red.",
  "A DualSense's light changes with the dimension you're in.": "A DualSense's light changes with the dimension you're in.",
  "A DualSense keeps its own light.": "A DualSense keeps its own light.",
+  "Lets LT + A craft on servers other than your own worlds. Some servers count it as a macro.": "Lets LT + A craft on servers other than your own worlds. Some servers count it as a macro.",
  "Show the buttons for what you can do, while you play with a controller.": "Show the buttons for what you can do, while you play with a controller.",
  "How fast the stick moves the crosshair in inventories.": "How fast the stick moves the crosshair in inventories.",
  "How fast the right stick scrolls a list.": "How fast the right stick scrolls a list.",
@@ -964,6 +990,7 @@
  "The USB vendor and product the system reports. Useful when reporting a controller that misbehaves.": "The USB vendor and product the system reports. Useful when reporting a controller that misbehaves.",
  "The glyph family the game picked from the controller's maker.": "The glyph family the game picked from the controller's maker.",
  "Follow the controller, or always show one family's buttons.": "Follow the controller, or always show one family's buttons.",
+  "Whether a Nintendo controller's A and B work by where they sit or by their letters.": "Whether a Nintendo controller's A and B work by where they sit or by their letters.",
  "The buttons menus show right now.": "The buttons menus show right now.",
  "Rumble when something happens to you.": "Rumble when something happens to you.",
  "The controller keeps playing while this window isn't focused, and losing focus won't pause.": "The controller keeps playing while this window isn't focused, and losing focus won't pause.",
@@ -5,6 +5,7 @@
  "horizon.options.controller": "Mando",
  "horizon.options.three_d_skin_layers": "Capas de skin 3D",
  "horizon.options.vibration": "Vibración",
+  "horizon.options.play_in_background": "Jugar en segundo plano",
  "horizon.options.adaptive_triggers": "Gatillos adaptativos",
  "horizon.options.lightbar": "Barra de luz",
  "horizon.options.look_sensitivity": "Sensibilidad de vista",
@@ -34,6 +35,23 @@
  "horizon.studio.record.error": "Error de grabación de Studio: %s",
  "horizon.studio.record.status.active": "Grabación de Studio activa — %s s, %s paquetes, %s KB (%s)",
  "horizon.studio.record.status.inactive": "Grabación de Studio inactiva",
+  "horizon.studio.replay.usage": "Uso: /studio replay <open RUTA|pause|resume|speed MULTIPLICADOR|seek MS|status|close>",
+  "horizon.studio.replay.open.usage": "Uso: /studio replay open <RUTA>",
+  "horizon.studio.replay.opened": "Replay de Studio abierto: %s (%s s, %s paquetes)",
+  "horizon.studio.replay.open_error": "No se pudo abrir el replay: %s",
+  "horizon.studio.replay.paused": "Replay de Studio en pausa",
+  "horizon.studio.replay.resumed": "Replay de Studio reanudado",
+  "horizon.studio.replay.inactive": "No hay ningún replay de Studio activo",
+  "horizon.studio.replay.speed.usage": "Uso: /studio replay speed <MULTIPLICADOR>",
+  "horizon.studio.replay.speed.set": "Velocidad del replay de Studio ajustada a %s×",
+  "horizon.studio.replay.speed.invalid": "Velocidad de replay no válida",
+  "horizon.studio.replay.seek.usage": "Uso: /studio replay seek <MILISEGUNDOS>",
+  "horizon.studio.replay.seeked": "Replay de Studio situado en %s ms (%s s)",
+  "horizon.studio.replay.seek.error": "No se pudo mover el replay: %s",
+  "horizon.studio.replay.seek.backward_requires_standalone": "Rebobinar solo está disponible para un replay independiente.",
+  "horizon.studio.replay.seek.invalid": "Posición de replay no válida",
+  "horizon.studio.replay.status": "Replay de Studio: %s / %s ms (%s%%), velocidad %s×, en pausa %s, finalizado %s",
+  "horizon.studio.replay.closed": "Replay de Studio cerrado",
  "horizon.pages.mods": "Mods",
  "horizon.pages.shader_packs": "Paquetes de shaders",
  "horizon.pages.shader_options": "Opciones de shaders",
@@ -88,6 +106,7 @@
  "horizon.studio.empty": "No se han encontrado grabaciones en la carpeta de grabaciones.",
  "horizon.studio.empty_hint": "Usa /studio record start <nombre> en un mundo o deja archivos .mcpr allí.",
  "horizon.studio.open_folder": "Abrir grabaciones",
+  "horizon.studio.open_replay": "Reproducir replay",
  "horizon.studio.refresh": "Actualizar",
  "horizon.studio.unknown_server": "Desconocido",
  "horizon.pages.open.music": "Música...",
@@ -295,6 +314,7 @@
  "Brighter-than-white output on an HDR display.": "Salida más brillante que el blanco en una pantalla HDR.",
  "Results for \"%s\"": "Resultados de \"%s\"",
  "No settings match.": "Ningún ajuste coincide.",
+  "horizon.plain.official": "Horizon oficial con launcher, mods y actualizaciones: playhorizon.dev",
  "horizon.title.not_affiliated": "No está afiliado a Mojang ni a Microsoft",
  "horizon.extras.header.lighting": "Iluminación",
  "horizon.extras.header.third_person": "Tercera persona",
@@ -881,6 +901,7 @@
  "Follow the controller, or always show one family's buttons.": "Sigue al mando o muestra siempre los botones de una familia.",
  "The buttons menus show right now.": "Los botones que muestran los menús ahora mismo.",
  "Rumble when something happens to you.": "Vibra cuando te pasa algo.",
+  "The controller keeps playing while this window isn't focused, and losing focus won't pause.": "El mando sigue funcionando aunque esta ventana no tenga el foco, y perder el foco no pone el juego en pausa.",
  "A DualSense's triggers push back on bows and tools.": "Los gatillos de un DualSense ofrecen resistencia con arcos y herramientas.",
  "What a DualSense's light shows, over USB or Bluetooth.": "Lo que muestra la luz de un DualSense, por USB o Bluetooth.",
  "Player profile": "Perfil de jugador",
@@ -188,6 +188,7 @@
  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Données de maillage vers le GPU par image. Moins : plus fluide.",
  "Frame rate and frame times over the game, with a graph.": "Fréquence et temps d'image par-dessus le jeu, avec un graphique.",
  "horizon.multiplayer.finding_friend": "Recherche du monde de votre ami...",
+  "horizon.plain.official": "Horizon officiel avec launcher, mods et mises à jour : playhorizon.dev",
  "horizon.title.not_affiliated": "Non affilié à Mojang ou à Microsoft",
  "horizon.extras.header.lighting": "Éclairage",
  "horizon.extras.header.third_person": "Troisième personne",
@@ -231,6 +231,7 @@
  "Brighter-than-white output on an HDR display.": "Uscita più luminosa del bianco su un display HDR.",
  "Results for \"%s\"": "Risultati per \"%s\"",
  "No settings match.": "Nessuna impostazione corrisponde.",
+  "horizon.plain.official": "Horizon ufficiale con launcher, mod e aggiornamenti: playhorizon.dev",
  "horizon.title.not_affiliated": "Non affiliato con Mojang o Microsoft",
  "horizon.extras.header.lighting": "Illuminazione",
  "horizon.extras.header.third_person": "Terza persona",
@@ -29,6 +29,7 @@
  "horizon.pages.extras": "Horizon エクストラ",
  "horizon.pages.settings": "Horizon 設定",
  "horizon.pages.agent": "AIエージェント",
+  "horizon.plain.official": "ランチャー、Mod、アップデート付きの公式 Horizon: playhorizon.dev",
  "horizon.split.leave": "休暇を取る",
  "horizon.pages.split_settings": "分割画面設定",
  "horizon.pages.split_profiles": "誰が遊んでるの？",
@@ -26,6 +26,7 @@
  "horizon.pages.extras": "Horizon 추가 기능",
  "horizon.pages.settings": "Horizon 설정",
  "horizon.pages.agent": "AI 에이전트",
+  "horizon.plain.official": "런처, 모드, 업데이트가 포함된 공식 Horizon: playhorizon.dev",
  "horizon.split.leave": "나가기",
  "horizon.pages.split_settings": "화면 분할 설정",
  "horizon.pages.split_profiles": "플레이어 선택",
@@ -223,6 +223,7 @@
  "Brighter-than-white output on an HDR display.": "Helderder dan witte uitvoer op een HDR-scherm.",
  "Results for \"%s\"": "Resultaten voor \"%s\"",
  "No settings match.": "Er komen geen instellingen overeen.",
+  "horizon.plain.official": "Officiële Horizon met launcher, mods en updates: playhorizon.dev",
  "horizon.title.not_affiliated": "Niet aangesloten bij Mojang of Microsoft",
  "horizon.extras.header.lighting": "Verlichting",
  "horizon.extras.header.third_person": "Derde persoon",
@@ -222,6 +222,7 @@
  "Brighter-than-white output on an HDR display.": "Obraz jaśniejszy niż biel na ekranie HDR.",
  "Results for \"%s\"": "Wyniki dla \"%s\"",
  "No settings match.": "Żadne ustawienie nie pasuje.",
+  "horizon.plain.official": "Oficjalny Horizon z launcherem, modami i aktualizacjami: playhorizon.dev",
  "horizon.title.not_affiliated": "Niepowiązane z Mojang ani Microsoft",
  "horizon.extras.header.lighting": "Oświetlenie",
  "horizon.extras.header.third_person": "Widok z trzeciej osoby",
@@ -233,6 +233,7 @@
  "Brighter-than-white output on an HDR display.": "Saída mais brilhante que o branco em uma tela HDR.",
  "Results for \"%s\"": "Resultados para \"%s\"",
  "No settings match.": "Nenhuma configuração corresponde.",
+  "horizon.plain.official": "Horizon oficial com launcher, mods e atualizações: playhorizon.dev",
  "horizon.title.not_affiliated": "Não afiliado à Mojang ou Microsoft",
  "horizon.extras.header.lighting": "Iluminação",
  "horizon.extras.header.third_person": "Terceira pessoa",
@@ -76,6 +76,7 @@
  "Resolution Scale": "Масштаб разрешения",
  "Anti-aliasing": "Сглаживание",
  "Upscaling": "Апскейл",
+  "Upscaling Sharpness": "Резкость апскейла",
  "Paper White": "Белая точка",
  "Peak Brightness": "Пиковая яркость",
  "Black Level": "Уровень чёрного",
@@ -167,6 +168,7 @@
  "World pixels per screen pixel. Below 100% is faster on the GPU.": "Пикселей мира на пиксель экрана. Ниже 100% — быстрее для видеокарты.",
  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Сглаживает рваные края. FXAA: мягче. TAA: глаже всего, но движущееся может шлейфить.",
  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Рисует мир мельче и восстанавливает его через TAA. Быстрее, но мягче.",
+  "Sharpens the upscaled picture. Higher: crisper edges, more shimmer.": "Повышает резкость увеличенной картинки. Выше: чётче края, больше мерцания.",
  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "HDR-вывод на HDR-экране: лава, огонь и солнце светятся ярче.",
  "How frames reach the screen while VSync is off.": "Как кадры попадают на экран, когда вертикальная синхронизация выключена.",
  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "«Экономный» спит до следующего кадра; «Точный» крутится, как в ванили.",
@@ -185,6 +187,7 @@
  "Frame rate and frame times over the game, with a graph.": "Частота кадров и их время поверх игры, с графиком.",
  "horizon.multiplayer.finding_friend": "Ищем мир друга…",
  "horizon.multiplayer.not_signed_in": "Этот сервер работает в онлайн-режиме. Войдите с помощью аккаунта Microsoft в лаунчере Horizon, чтобы присоединиться.",
+  "horizon.plain.official": "Официальный Horizon с лаунчером, модами и обновлениями: playhorizon.dev",
  "horizon.realms.not_signed_in": "Войдите в лаунчере Horizon с учётной записью Microsoft, чтобы играть в Realms.",
  "horizon.multiplayer.invalid_address": "Недействительный адрес сервера: %s",
  "horizon.multiplayer.connected_friend_direct": "Установлено прямое соединение с другом…",
@@ -187,6 +187,7 @@
  "horizon.pages.shader_options": "Gölgelendirici Seçenekleri",
  "horizon.pages.split_profiles": "Kim oynuyor?",
  "horizon.pages.split_profiles.tooltip": "Kim oynuyor: bu oyun klasöründe tutulan bir profil.",
+  "horizon.plain.official": "Başlatıcı, modlar ve güncellemelerle resmi Horizon: playhorizon.dev",
  "horizon.shader_options.profile": "Profil",
  "Particle Culling": "Particle Culling",
  "Draws every particle.": "Draws every particle.",
@@ -57,6 +57,7 @@
  "horizon.mods.dev": " (розробка)",
  "horizon.mods.settings": "Налаштування",
  "horizon.mods.open_folder": "Відкрити теку з модами",
+  "horizon.plain.official": "Офіційний Horizon із лаунчером, модами та оновленнями: playhorizon.dev",
  "horizon.shader_options.profile": "Профіль",
  "horizon.agent.copy_details": "Копіювати дані з’єднання",
  "horizon.multiplayer.join": "Приєднатися",
@@ -471,5 +472,450 @@
  "Pack settings": "Налаштування пакета",
  "Built-in settings": "Вбудовані налаштування",
  "%s settings": "Налаштування %s",
-  "Settings made by the pack's author: they change only this pack.": "Налаштування, створені автором пакета: вони змінюють лише цей пакет."
+  "Settings made by the pack's author: they change only this pack.": "Налаштування, створені автором пакета: вони змінюють лише цей пакет.",
+  "horizon.extras.header.world": "Світ",
+  "horizon.extras.pregen": "Попередня генерація чанків",
+  "horizon.extras.pregen.tooltip": "Вмикає /pregen у ваших одиночних і LAN-світах. З увімкненими читами введіть /pregen start, щоб згенерувати область, перш ніж її досліджувати. На серверах, до яких ви приєднуєтесь, команда не вмикається.",
+  "horizon.options.three_d_skin_layers": "3D-шари скіна",
+  "horizon.options.play_in_background": "Гра у фоні",
+  "horizon.options.trigger_threshold": "Поріг тригера",
+  "horizon.studio.record.usage": "Використання: /studio record <start [назва]|stop|status>",
+  "horizon.studio.record.started": "Запис Studio розпочато: %s",
+  "horizon.studio.record.saved": "Запис Studio збережено: %s",
+  "horizon.studio.record.error": "Помилка запису Studio: %s",
+  "horizon.studio.record.status.active": "Запис Studio триває — %s с, %s пакетів, %s КБ (%s)",
+  "horizon.studio.record.status.inactive": "Запис Studio не ведеться",
+  "horizon.studio.replay.usage": "Використання: /studio replay <open ШЛЯХ|pause|resume|speed МНОЖНИК|seek МС|status|close>",
+  "horizon.studio.replay.open.usage": "Використання: /studio replay open <ШЛЯХ>",
+  "horizon.studio.replay.opened": "Повтор Studio відкрито: %s (%s с, %s пакетів)",
+  "horizon.studio.replay.open_error": "Не вдалося відкрити повтор: %s",
+  "horizon.studio.replay.paused": "Повтор Studio призупинено",
+  "horizon.studio.replay.resumed": "Повтор Studio продовжено",
+  "horizon.studio.replay.inactive": "Немає активного повтору Studio",
+  "horizon.studio.replay.speed.usage": "Використання: /studio replay speed <МНОЖНИК>",
+  "horizon.studio.replay.speed.set": "Швидкість повтору Studio: %s×",
+  "horizon.studio.replay.speed.invalid": "Неправильна швидкість повтору",
+  "horizon.studio.replay.seek.usage": "Використання: /studio replay seek <МІЛІСЕКУНДИ>",
+  "horizon.studio.replay.seeked": "Повтор Studio перемотано на %s мс (%s с)",
+  "horizon.studio.replay.seek.error": "Не вдалося перемотати повтор: %s",
+  "horizon.studio.replay.seek.backward_requires_standalone": "Перемотування назад доступне лише в окремому повторі.",
+  "horizon.studio.replay.seek.invalid": "Неправильна позиція повтору",
+  "horizon.studio.replay.status": "Повтор Studio: %s / %s мс (%s%%), швидкість %s×, пауза: %s, завершено: %s",
+  "horizon.studio.replay.closed": "Повтор Studio закрито",
+  "horizon.pages.studio": "Студія повторів",
+  "horizon.pages.music": "Музика",
+  "horizon.pages.music.menu": "Меню",
+  "horizon.pages.music.overworld": "Верхній світ",
+  "horizon.pages.music.creative": "Творчий режим",
+  "horizon.pages.music.underwater": "Під водою",
+  "horizon.pages.music.end": "Енд",
+  "horizon.pages.music.boss": "Бос",
+  "horizon.pages.music.credits": "Титри",
+  "horizon.pages.music.overworld_biomes": "Біоми Верхнього світу",
+  "horizon.pages.music.nether_biomes": "Біоми Незеру",
+  "horizon.pages.music.end_biomes": "Біоми Енду",
+  "horizon.pages.music.other": "Інша музика",
+  "horizon.pages.music.empty": "Немає музичних треків: звуки гри не завантажено.",
+  "horizon.pages.music.tooltip": "Вбудовані треки за ситуаціями: увімкніть будь-який зараз або вимкніть, щоб гра більше його не обирала.",
+  "horizon.pages.studio.tooltip": "Перегляд збережених записів і їхніх метаданих.",
+  "horizon.pages.open.studio": "Студія повторів...",
+  "horizon.studio.saved_recordings": "Збережені записи",
+  "horizon.studio.empty": "У теці записів немає жодного запису.",
+  "horizon.studio.empty_hint": "Введіть у світі /studio record start <назва> або покладіть туди файли .mcpr.",
+  "horizon.studio.open_folder": "Відкрити записи",
+  "horizon.studio.open_replay": "Відтворити повтор",
+  "horizon.studio.refresh": "Оновити",
+  "horizon.studio.unknown_server": "Невідомо",
+  "horizon.pages.open.music": "Музика...",
+  "horizon.mods.in_world": " (вийдіть зі світу, щоб змінити)",
+  "horizon.mods.browse": "Огляд модів...",
+  "horizon.mods.browse.title": "Огляд модів",
+  "horizon.mods.browse.search": "Пошук модів...",
+  "horizon.mods.browse.project": "Мод",
+  "horizon.mods.browse.loading": "Читання реєстру модів Horizon...",
+  "horizon.mods.browse.failed": "Не вдалося прочитати реєстр модів: %s",
+  "horizon.mods.browse.none": "Модів не знайдено",
+  "horizon.mods.browse.has_update": " (оновлення)",
+  "horizon.mods.browse.is_installed": " (встановлено)",
+  "horizon.mods.browse.by": "автор: %s",
+  "horizon.mods.browse.installing": "Встановлення...",
+  "horizon.mods.browse.install": "Встановити",
+  "horizon.mods.browse.update": "Оновити",
+  "horizon.mods.browse.installed": "Встановлено",
+  "horizon.mods.browse.open_page": "Відкрити сторінку",
+  "horizon.mods.browse.enabled": "Мод",
+  "horizon.mods.browse.changelog": "Список змін",
+  "horizon.mods.browse.done": "%s %s встановлено й увімкнено.",
+  "horizon.mods.browse.install_failed": "Не вдалося встановити: %s",
+  "horizon.mods.switch.worldgen": "змінює генерацію світу",
+  "horizon.mods.switch.registries": "додає блоки, предмети чи інші записи реєстрів",
+  "horizon.mods.switch.restart": "Перезапустіть гру, щоб застосувати %s: вони додають блоки, предмети або генерацію світу.",
+  "GPU Culling": "Відсікання на GPU",
+  "HDR Lighting": "HDR-освітлення",
+  "Light sources, the sun and sunlight shine past white. Off: just as SDR.": "Джерела світла, сонце й сонячне світло сяють яскравіше за білий. Вимкнено: як у SDR.",
+  "Smooth Gradients": "Плавні градієнти",
+  "16-bit frame: dark skies and shadows don't band. A bit more VRAM. Next start.": "16-бітний кадр: темне небо й тіні без смуг. Трохи більше відеопам’яті. З наступного запуску.",
+  "Not with software rendering, which runs it on the CPU.": "Не з програмним рендерингом, який виконує це на CPU.",
+  "Out of video memory: off until the next start.": "Забракло відеопам’яті: вимкнено до наступного запуску.",
+  "The graphics device was lost: off until the next start.": "Графічний пристрій втрачено: вимкнено до наступного запуску.",
+  "Not on DirectX 12 yet: try the Vulkan graphics API.": "Поки не працює на DirectX 12: спробуйте графічний API Vulkan.",
+  "Culls nearby terrain on the GPU: less CPU at high render distance, more GPU.": "Відсікає ближній рельєф на GPU: за великої дальності промальовування менше навантажує CPU, більше — GPU.",
+  "horizon.realms.not_signed_in": "Увійдіть за допомогою акаунта Microsoft у лаунчері Horizon, щоб грати на Realms.",
+  "horizon.extras.music_page": "Сторінка «Музика»",
+  "horizon.extras.zoom": "Наближення",
+  "horizon.extras.zoom_mod_install": "Наближення: встановіть у модах",
+  "horizon.extras.wheel_cycles_list_settings.tooltip": "Коліщатко миші над кнопкою в списку налаштувань змінює її значення. Вимкнено, як у ванільній грі: коліщатко прокручує список.",
+  "horizon.extras.pack_browser": "Огляд наборів ресурсів",
+  "horizon.extras.music_page.tooltip": "У «Музика і звуки» з’являється сторінка «Музика...»: увімкніть будь-який вбудований трек зараз або вимкніть, щоб гра більше його не обирала. Нічого не змінюється, доки ви не вимкнете трек.",
+  "horizon.friends.relay_stopped": "Забагато неправильних коротких кодів, тому ретранслятор вимкнено, доки ви знову не поділитеся світом. Друзі все ще можуть приєднатися за повним кодом.",
+  "horizon.extras.pack_browser.tooltip": "У «Вибрати набори ресурсів» з’являється кнопка «Додати», яка шукає в Modrinth і встановлює набір у вашу теку наборів. Вимкнено: гра ніколи не звертається до Modrinth.",
+  "horizon.splitscreen.online_only": "Цей сервер працює в онлайн-режимі: офлайн-профілі не можуть приєднатися, кожному гравцеві потрібен власний акаунт Minecraft.",
+  "horizon.splitscreen.own_account": "Цей сервер вимагає від кожного гравця власного акаунта Minecraft",
+  "horizon.splitscreen.local_only": "Інші гравці можуть приєднатися до цього сервера лише з власним акаунтом Minecraft: офлайн-профілі грають у вашому світі, через LAN або на сервері у вашій локальній мережі.",
+  "Shaders": "Шейдери",
+  "Shader packs, Horizon's and shaders/ folder ones, and their options.": "Пакети шейдерів — від Horizon і з теки shaders/ — та їхні налаштування.",
+  "Shader packs": "Пакети шейдерів",
+  "Vanilla's own preset: sets only vanilla's options, as Minecraft does.": "Власний пресет ванільної гри: задає лише ванільні налаштування, як це робить Minecraft.",
+  "Fullscreen takes the display over, at the mode below.": "Повноекранний режим займає весь дисплей у режимі, вказаному нижче.",
+  "The display mode exclusive fullscreen uses. Applies when you leave.": "Режим дисплея для ексклюзивного повноекранного режиму. Застосовується, коли ви виходите.",
+  "Blurs the world behind menus.": "Розмиває світ за меню.",
+  "How textures are sampled: sharper at a slant with Anisotropic.": "Як вибираються текстури: з анізотропною фільтрацією чіткіші під кутом.",
+  "How far Anisotropic filtering goes. Higher is sharper at a slant.": "Рівень анізотропної фільтрації. Вищий — чіткіше під кутом.",
+  "Only with Anisotropic texture filtering.": "Лише з анізотропною фільтрацією текстур.",
+  "Picks a shader pack, Horizon's or a shaders/ folder one, and sets its options.": "Обирає пакет шейдерів — від Horizon чи з теки shaders/ — і задає його налаштування.",
+  "Hidden Faces": "Приховані грані",
+  "Drops leaf faces behind two leaf layers: faster, same crowns.": "Прибирає грані листя за двома шарами листя: швидше, а крони ті самі.",
+  "Entity Culling Precheck": "Попередня перевірка відсікання сутностей",
+  "Runs the mob AABB precheck after this many loaded mobs. Zero disables it.": "Запускає попередню перевірку AABB мобів, коли завантажено стільки мобів. Нуль вимикає її.",
+  "%s mobs": "%s мобів",
+  "horizon.splitscreen.profiles.offline": " (Офлайн)",
+  "horizon.splitscreen.profiles.microsoft": " (Microsoft)",
+  "horizon.splitscreen.profiles.sign_in": "Увійдіть знову в лаунчері",
+  "horizon.splitscreen.profiles.online": "Microsoft онлайн",
+  "horizon.splitscreen.account_unavailable": "%s офлайн. Увійдіть знову в лаунчері, потім перезапустіть гру.",
+  "horizon.splitscreen.account_expired": "Вхід Microsoft для %s закінчився. Увійдіть знову в лаунчері, потім перезапустіть гру.",
+  "horizon.pack.add": "+",
+  "horizon.pack.addInfo": "Додати набір ресурсів із Modrinth",
+  "horizon.pack.addWorking": "Запит до Modrinth...",
+  "horizon.pack.addNone": "Наборів ресурсів не знайдено",
+  "horizon.pack.addTitle": "Додати набір ресурсів",
+  "horizon.pack.install": "Встановити",
+  "horizon.pack.installing": "Встановлення",
+  "horizon.pack.installed": "Встановлено",
+  "horizon.pack.search": "Пошук",
+  "horizon.pack.searchHint": "Пошук у Modrinth...",
+  "horizon.pack.filters": "Фільтри",
+  "horizon.pack.filter.realistic": "Реалістичні",
+  "horizon.pack.filter.simplistic": "Спрощені",
+  "horizon.pack.filter.vanillaLike": "Як ванільні",
+  "horizon.pack.filter.x16": "16x",
+  "horizon.pack.filter.x32": "32x",
+  "horizon.pack.filter.x64": "64x",
+  "horizon.pack.addFailed": "Не вдалося додати набір: %s",
+  "horizon.extras.header.cosmetics": "Косметика",
+  "horizon.extras.cosmetics_mine": "Моя косметика",
+  "horizon.extras.cosmetics_mine.tooltip": "Приховано: усі гравці Horizon бачать вас без косметики, і ви теж. Той самий перемикач, що й у Гардеробі лаунчера.",
+  "key.emote": "Колесо емоцій",
+  "horizon.emote_wheel.title": "Емоції",
+  "horizon.emote_wheel.empty": "Емоцій поки немає",
+  "horizon.emote_wheel.help": "Відпустіть або клацніть, щоб відтворити · 1–8 · Esc закриває",
+  "horizon.extras.cosmetics_others": "Косметика інших гравців",
+  "horizon.extras.cosmetics_others.tooltip": "Що носять інші гравці Horizon: усе, лише стилі ніків або нічого. Приховано, якщо у вас немає косметики, доки ви не оберете. Коли приховано, гра ніколи не питає, що вони носять.",
+  "horizon.extras.cosmetics_hide_fx": "Приховати сліди й аури інших гравців",
+  "horizon.extras.cosmetics_hide_fx.tooltip": "Сліди й аури інших гравців приховано; решту їхньої косметики видно. Типово вимкнено.",
+  "horizon.extras.cosmetics.shown": "Показано",
+  "horizon.extras.cosmetics.hidden": "Приховано",
+  "horizon.extras.cosmetics.name_tags": "Лише ніки",
+  "horizon.moderation.duration.minute": "%s хв",
+  "horizon.moderation.duration.minutes": "%s хв",
+  "horizon.moderation.duration.hour": "%s год",
+  "horizon.moderation.duration.hours": "%s год",
+  "horizon.moderation.duration.day": "%s дн.",
+  "horizon.moderation.duration.days": "%s дн.",
+  "horizon.moderation.reason": "%1$s: %2$s",
+  "horizon.moderation.mutelist.empty": "Заглушених гравців немає",
+  "horizon.moderation.mutelist.count": "Заглушених гравців: %s:",
+  "horizon.moderation.chat_filter": "фільтр чату",
+  "horizon.moderation.until_unmuted": "до зняття заглушення",
+  "horizon.moderation.remaining": "ще на %s",
+  "horizon.moderation.mutelist.entry": "%1$s заглушено гравцем %2$s %3$s",
+  "horizon.moderation.invalid_duration": "%s — не тривалість: 10m, 2h, 1d",
+  "horizon.moderation.usage.mute": "/mute <гравець> [тривалість] [причина]",
+  "horizon.moderation.usage.tempmute": "/tempmute <гравець> <тривалість> [причина]",
+  "horizon.moderation.usage.unmute": "/unmute <гравець>",
+  "horizon.moderation.usage.mutelist": "/mutelist",
+  "horizon.moderation.for_duration": "на %s",
+  "horizon.moderation.muted": "Заглушено %1$s %2$s",
+  "horizon.moderation.unmuted": "Знято заглушення з %s",
+  "horizon.moderation.not_muted": "%s не заглушено",
+  "horizon.tempban.usage": "/tempban <гравець> <тривалість> [причина]",
+  "horizon.tempban.invalid_duration": "%s — не тривалість: 30m, 12h, 7d",
+  "horizon.tempban.dedicated_required": "Тимчасові бани потребують виділеного сервера",
+  "horizon.tempban.success": "%1$s на %2$s, до %3$s",
+  "horizon.tempban.list.empty": "Тимчасових банів немає",
+  "horizon.tempban.list.count": "Тимчасових банів: %s:",
+  "horizon.tempban.list.entry": "%1$s забанено гравцем %2$s %3$s (до %4$s)",
+  "horizon.options.pointer_speed": "Швидкість курсора в меню",
+  "horizon.options.scroll_speed": "Швидкість прокрутки в меню",
+  "horizon.options.repeat_delay": "Затримка повтору навігації",
+  "horizon.options.repeat_interval": "Інтервал повтору навігації",
+  "horizon.options.milliseconds": "%s мс",
+  "horizon.extras.cosmetics_solo": "В одиночній грі",
+  "horizon.extras.cosmetics_solo.tooltip": "Показувати вашу косметику й значок вашого ніка також в одиночних світах (сам нік — із «Власним ніком»). Вимкнено: лише на серверах.",
+  "horizon.extras.horizon_marks": "Логотипи Horizon",
+  "horizon.extras.horizon_marks.tooltip": "Показувати логотип Horizon біля гравців Horizon: маленький логотип перед іменами інших гравців, які грають у Horizon, над їхніми головами та в списку гравців. Його бачать лише гравці Horizon: сервери нічого не отримують.",
+  "horizon.extras.horizon_me": "Показувати мене як гравця Horizon",
+  "horizon.extras.horizon_me.tooltip": "Показувати мене як гравця Horizon: інші гравці Horizon бачать логотип біля вашого імені. Коли ввімкнено, сервіс відповідає кожному, хто про вас питає, що ви грали в Horizon за останні 3 години; коли вимкнено — ніколи про вас не повідомляє.",
+  "horizon.pages.pvp": "PvP та HUD",
+  "horizon.pages.pvp.tooltip": "Налаштування прицілу, HUD і PvP, усі типово вимкнені. Тут немає нічого, що показує більше, ніж ванільна гра.",
+  "horizon.pages.open.pvp": "PvP та HUD...",
+  "horizon.pvp.header.crosshair": "Приціл",
+  "horizon.pvp.crosshair": "Власний приціл",
+  "horizon.pvp.crosshair_shape": "Форма",
+  "horizon.pvp.crosshair_size": "Розмір",
+  "horizon.pvp.crosshair_gap": "Проміжок",
+  "horizon.pvp.crosshair_thickness": "Товщина",
+  "horizon.pvp.crosshair_colour": "Колір",
+  "horizon.pvp.crosshair_outline": "Обведення",
+  "horizon.pvp.crosshair_dot": "Точка в центрі",
+  "horizon.pvp.crosshair_hover": "Колір на сутностях",
+  "horizon.pvp.crosshair.tooltip": "Малює ваш власний приціл замість ванільного. Початкові налаштування виглядають як ванільний.",
+  "horizon.pvp.crosshair_shape.tooltip": "Хрест, T, X, коло, квадрат або лише точка.",
+  "horizon.pvp.crosshair_size.tooltip": "Довжина кожного променя в пікселях інтерфейсу.",
+  "horizon.pvp.crosshair_gap.tooltip": "Порожнє місце посередині.",
+  "horizon.pvp.crosshair_thickness.tooltip": "Ширина кожної лінії.",
+  "horizon.pvp.crosshair_colour.tooltip": "«Інвертований» показує колір під прицілом інвертованим, як ванільний приціл.",
+  "horizon.pvp.crosshair_outline.tooltip": "Тонкий чорний край, щоб приціл було видно на будь-якому фоні.",
+  "horizon.pvp.crosshair_dot.tooltip": "Точка посередині прицілу.",
+  "horizon.pvp.crosshair_hover.tooltip": "Інший колір, коли приціл наведено на моба чи гравця, якого можна вдарити, — як це визначає ванільний індикатор атаки.",
+  "horizon.pvp.colour.inverted": "Інвертований",
+  "horizon.pvp.colour.white": "Білий",
+  "horizon.pvp.colour.red": "Червоний",
+  "horizon.pvp.colour.orange": "Помаранчевий",
+  "horizon.pvp.colour.yellow": "Жовтий",
+  "horizon.pvp.colour.green": "Зелений",
+  "horizon.pvp.colour.cyan": "Бірюзовий",
+  "horizon.pvp.colour.blue": "Синій",
+  "horizon.pvp.colour.magenta": "Пурпуровий",
+  "horizon.pvp.colour.black": "Чорний",
+  "horizon.pvp.shape.cross": "Хрест",
+  "horizon.pvp.shape.t": "T",
+  "horizon.pvp.shape.x": "X",
+  "horizon.pvp.shape.circle": "Коло",
+  "horizon.pvp.shape.square": "Квадрат",
+  "horizon.pvp.shape.dot": "Точка",
+  "horizon.pvp.outline": "Власне обведення блока",
+  "horizon.pvp.outline.tooltip": "Змінює обведення навколо блока, на який ви дивитеся.",
+  "horizon.pvp.outline_colour": "Колір",
+  "horizon.pvp.outline_colour.tooltip": "Колір обведення. Чорний на 40% — ванільний.",
+  "horizon.pvp.outline_opacity": "Непрозорість",
+  "horizon.pvp.outline_opacity.tooltip": "Наскільки щільне обведення.",
+  "horizon.pvp.outline_thickness": "Товщина",
+  "horizon.pvp.outline_thickness.tooltip": "Ширина обведення, у разах від ванільної.",
+  "horizon.pvp.outline_fill": "Заливка",
+  "horizon.pvp.outline_fill.tooltip": "Злегка підфарбовує грані блока, на який ви дивитеся.",
+  "horizon.pvp.hit": "Власний колір удару",
+  "horizon.pvp.hit.tooltip": "Змінює колір, яким спалахують моби й гравці, коли їм завдають шкоди. Червоний на 30% — ванільний.",
+  "horizon.pvp.hit_colour": "Колір",
+  "horizon.pvp.hit_colour.tooltip": "Колір, яким спалахують поранені моби й гравці.",
+  "horizon.pvp.hit_opacity": "Непрозорість",
+  "horizon.pvp.hit_opacity.tooltip": "Наскільки колір їх покриває.",
+  "horizon.pvp.header.outline": "Обведення блока",
+  "horizon.pvp.header.hit": "Колір удару",
+  "horizon.pvp.hud_armour": "Броня",
+  "horizon.pvp.hud_armour.tooltip": "Броня, яку ви носите, починаючи з голови, і скільки використань лишилося в кожного предмета.",
+  "horizon.pvp.hud_armour_corner": "Кут броні",
+  "horizon.pvp.hud_armour_corner.tooltip": "Де показується броня.",
+  "horizon.pvp.hud_armour_percent": "Міцність у %",
+  "horizon.pvp.hud_armour_percent.tooltip": "Залишок використань у відсотках від максимуму предмета замість числа.",
+  "horizon.pvp.hud_effects": "Ефекти",
+  "horizon.pvp.hud_effects.tooltip": "Ваші ефекти з назвами, рівнями й часом, що лишився, замість значків угорі праворуч.",
+  "horizon.pvp.hud_effects_corner": "Кут ефектів",
+  "horizon.pvp.hud_effects_corner.tooltip": "Де показуються ефекти.",
+  "horizon.pvp.hud_held": "Кількість предмета в руці",
+  "horizon.pvp.hud_held.tooltip": "Скільки предметів, як у вашій руці, є в інвентарі; з луком чи арбалетом — стріл.",
+  "horizon.pvp.hud_held_corner": "Кут кількості",
+  "horizon.pvp.hud_held_corner.tooltip": "Де показується кількість.",
+  "horizon.pvp.hud_background": "Фон віджетів",
+  "horizon.pvp.hud_background.tooltip": "Темна підкладка під кожним віджетом.",
+  "horizon.pvp.hud_opacity": "Непрозорість фону",
+  "horizon.pvp.hud_opacity.tooltip": "Наскільки темні підкладки під віджетами.",
+  "horizon.pvp.hud_text_colour": "Колір тексту",
+  "horizon.pvp.hud_text_colour.tooltip": "Колір тексту віджетів. Міцність лишається від зеленого до червоного.",
+  "horizon.pvp.hud_shadow": "Тінь тексту",
+  "horizon.pvp.hud_shadow.tooltip": "Тінь під текстом віджетів, як у тексту ванільного HUD.",
+  "horizon.pvp.header.hud": "Віджети HUD",
+  "horizon.pvp.corner.top_left": "Угорі ліворуч",
+  "horizon.pvp.corner.top_right": "Угорі праворуч",
+  "horizon.pvp.corner.bottom_left": "Унизу ліворуч",
+  "horizon.pvp.corner.bottom_right": "Унизу праворуч",
+  "horizon.pvp.hud_ping": "Пінг",
+  "horizon.pvp.hud_ping.tooltip": "Затримка, яку сервер повідомляє для вас, у мілісекундах. Лише в мережевій грі.",
+  "horizon.pvp.hud_ping_corner": "Кут пінгу",
+  "horizon.pvp.hud_ping_corner.tooltip": "Де показується пінг.",
+  "horizon.pvp.hud_coords": "Координати",
+  "horizon.pvp.hud_coords.tooltip": "Ваша позиція в блоках і напрямок погляду, як їх показує F3. Приховано, коли світ чи сервер скорочує F3.",
+  "horizon.pvp.hud_coords_corner": "Кут координат",
+  "horizon.pvp.hud_coords_corner.tooltip": "Де показуються координати.",
+  "horizon.pvp.hud_server": "Адреса сервера",
+  "horizon.pvp.hud_server.tooltip": "Адреса сервера, на якому ви граєте. Лише в мережевій грі.",
+  "horizon.pvp.hud_server_corner": "Кут сервера",
+  "horizon.pvp.hud_server_corner.tooltip": "Де показується адреса.",
+  "horizon.pvp.hud_combo": "Лічильник комбо",
+  "horizon.pvp.hud_combo.tooltip": "Удари поспіль, підтверджені сервером, доки вас не поранять або не мине 3 секунди без удару.",
+  "horizon.pvp.hud_combo_corner": "Кут комбо",
+  "horizon.pvp.hud_combo_corner.tooltip": "Де показується комбо.",
+  "horizon.pvp.hud.ping": "Пінг: %s мс",
+  "horizon.pvp.hud.coords": "XYZ: %s %s %s",
+  "horizon.pvp.hud.facing": "Напрямок: %s",
+  "horizon.pvp.hud.combo": "Комбо: %s",
+  "horizon.pvp.hud.direction.north": "Північ",
+  "horizon.pvp.hud.direction.south": "Південь",
+  "horizon.pvp.hud.direction.east": "Схід",
+  "horizon.pvp.hud.direction.west": "Захід",
+  "horizon.pvp.hud_fps": "FPS",
+  "horizon.pvp.hud_fps.tooltip": "Кадрів за останню секунду.",
+  "horizon.pvp.hud_fps_corner": "Кут FPS",
+  "horizon.pvp.hud_fps_corner.tooltip": "Де показується FPS.",
+  "horizon.pvp.hud_cps": "Кліки за секунду",
+  "horizon.pvp.hud_cps.tooltip": "Ваші ліві й праві кліки за останню секунду.",
+  "horizon.pvp.hud_cps_corner": "Кут CPS",
+  "horizon.pvp.hud_cps_corner.tooltip": "Де показуються кліки за секунду.",
+  "horizon.pvp.hud_keys": "Натискання клавіш",
+  "horizon.pvp.hud_keys.tooltip": "Клавіші руху, кнопки миші та стрибок, які підсвічуються, поки ви їх тримаєте, і кліки за секунду.",
+  "horizon.pvp.hud_keys_corner": "Кут натискань",
+  "horizon.pvp.hud_keys_corner.tooltip": "Де показуються натискання клавіш.",
+  "horizon.pvp.hud_clock": "Годинник",
+  "horizon.pvp.hud_clock.tooltip": "Час на вашому комп’ютері.",
+  "horizon.pvp.hud_clock_corner": "Кут годинника",
+  "horizon.pvp.hud_clock_corner.tooltip": "Де показується годинник.",
+  "horizon.pvp.hud_reach": "Дальність",
+  "horizon.pvp.hud_reach.tooltip": "На якій відстані від ваших очей влучив останній удар, протягом 3 секунд. Це лише вимірювання: ваша дальність лишається ванільною.",
+  "horizon.pvp.hud_reach_corner": "Кут дальності",
+  "horizon.pvp.hud_reach_corner.tooltip": "Де показується дальність.",
+  "horizon.pvp.hud_speed": "Швидкість",
+  "horizon.pvp.hud_speed.tooltip": "Як швидко ви рухаєтеся по землі, у блоках за секунду.",
+  "horizon.pvp.hud_speed_corner": "Кут швидкості",
+  "horizon.pvp.hud_speed_corner.tooltip": "Де показується швидкість.",
+  "horizon.pvp.hud.fps": "%s FPS",
+  "horizon.pvp.hud.cps": "CPS: %s | %s",
+  "horizon.pvp.hud.reach": "Дальність: %s",
+  "horizon.pvp.hud.speed": "Швидкість: %s б/с",
+  "horizon.pvp.hud.keys.attack": "ЛКМ",
+  "horizon.pvp.hud.keys.use": "ПКМ",
+  "horizon.pvp.hud.keys.cps": "%s CPS",
+  "horizon.pvp.numeric_enchants": "Рівні чар числами",
+  "horizon.pvp.numeric_enchants.tooltip": "Підказки та чарувальний стіл показують «Гострота 5» замість «Гострота V».",
+  "horizon.pvp.header.items": "Предмети",
+  "horizon.pvp.fire_lower": "Нижчий вогонь",
+  "horizon.pvp.fire_lower.tooltip": "Опускає полум’я, яке ви бачите, коли горите, щоб воно менше закривало екран.",
+  "horizon.pvp.shield_size": "Розмір щита",
+  "horizon.pvp.shield_size.tooltip": "Розмір щита у вашій руці від першої особи.",
+  "horizon.pvp.totem_size": "Розмір анімації тотема",
+  "horizon.pvp.totem_size.tooltip": "Розмір тотема, що заповнює екран, коли рятує вас.",
+  "horizon.pvp.glint_colour": "Колір блиску чар",
+  "horizon.pvp.glint_colour.tooltip": "Колір мерехтіння на зачарованих предметах і броні. Вимкнено — ванільний фіолетовий.",
+  "horizon.pvp.clear_water": "Прозора вода",
+  "horizon.pvp.clear_water.tooltip": "Під водою одразу бачите так далеко, як ванільна гра дозволяє лише після 30 секунд під водою.",
+  "horizon.pvp.clear_lava": "Прозора лава",
+  "horizon.pvp.clear_lava.tooltip": "У лаві бачите так далеко, як дозволяє ванільна Вогнестійкість, без цього ефекту.",
+  "horizon.pvp.header.visual": "Візуальні зміни",
+  "horizon.pvp.view_time": "Час доби",
+  "horizon.pvp.view_time.tooltip": "Час доби, який ви бачите: лише небо та його світло. Час у світі йде далі, і на сервер нічого не надсилається.",
+  "horizon.pvp.view_weather": "Погода",
+  "horizon.pvp.view_weather.tooltip": "Погода, яку ви бачите: лише дощ, його світло й туман. Погода у світі не змінюється, і на сервер нічого не надсилається.",
+  "horizon.pvp.header.view": "Що ви бачите",
+  "horizon.pvp.view.world": "Як у світі",
+  "horizon.pvp.time.morning": "Ранок",
+  "horizon.pvp.time.noon": "Полудень",
+  "horizon.pvp.time.sunset": "Захід сонця",
+  "horizon.pvp.time.midnight": "Опівніч",
+  "horizon.pvp.weather.clear": "Ясно",
+  "horizon.pvp.weather.rain": "Дощ",
+  "horizon.pvp.weather.thunder": "Гроза",
+  "horizon.chat.timestamp": "[%s] ",
+  "horizon.chat.repeats": " (x%s)",
+  "horizon.pvp.header.chat": "Чат",
+  "horizon.chat.copied": "Повідомлення скопійовано",
+  "horizon.chat.search": "Пошук у чаті:",
+  "horizon.pvp.chat_timestamps": "Позначки часу",
+  "horizon.pvp.chat_timestamps.tooltip": "Перед кожним повідомленням — час, коли воно надійшло.",
+  "horizon.pvp.chat_compact": "Компактний чат",
+  "horizon.pvp.chat_compact.tooltip": "Повідомлення, повторене кілька разів поспіль, показується один раз із кількістю повторів: (x3).",
+  "horizon.pvp.chat_copy": "Копіювання клацанням",
+  "horizon.pvp.chat_copy.tooltip": "Клацання по повідомленню у відкритому чаті копіює його текст, якщо клацання не робить чогось іншого.",
+  "horizon.pvp.chat_search": "Пошук у чаті",
+  "horizon.pvp.chat_search.tooltip": "Ctrl+F у відкритому чаті: показуються лише повідомлення, що містять введений текст. Enter або повторне Ctrl+F завершує пошук.",
+  "horizon.pvp.preset": "PvP-пресет",
+  "horizon.pvp.preset.tooltip": "Вмикає власний приціл, віджети броні й ефектів, перемикання бігу та скрадання, нижчий вогонь, а також моди лічильника FPS і натискань клавіш, якщо їх встановлено. Ваші налаштування кожного з них зберігаються.",
+  "horizon.pvp.hud_editor_key": "Клавіша редактора HUD",
+  "horizon.pvp.hud_editor_key.tooltip": "Відкриває редактор HUD із гри. Клацніть, потім натисніть клавішу; Escape скасовує призначення.",
+  "horizon.pvp.editor": "Редагувати HUD",
+  "horizon.pvp.editor.tooltip": "Розставте віджети просто в грі: перетягуйте куди завгодно, змінюйте розмір коліщатком, клацніть правою кнопкою, щоб повернути віджет у його кут.",
+  "horizon.pvp.editor.hint": "Перетягуйте віджети · Коліщатко: розмір · Права кнопка: назад у кут",
+  "horizon.pvp.combat_feel": "Відчуття бою",
+  "horizon.pvp.combat_feel.tooltip": "«Класичне» показує бої як у 1.8.9: предмет у руці, його змах, їжу, лук і піднятий меч, поки ви тримаєте «використати», без просідання після кожного удару та без індикатора атаки. Лише вигляд: те, що ви надсилаєте серверу, не змінюється.",
+  "horizon.pvp.combat_indicator": "Індикатор атаки в «Класичному»",
+  "horizon.pvp.combat_indicator.tooltip": "Залишає в «Класичному» індикатор атаки, якого в 1.8.9 не було.",
+  "horizon.pvp.combat_feel.modern": "Сучасне",
+  "horizon.pvp.combat_feel.legacy": "Класичне (1.8.9)",
+  "horizon.pvp.header.combat": "Відчуття бою",
+  "horizon.pvp.combat_sounds": "Звуки ударів 1.8",
+  "horizon.pvp.combat_sounds.tooltip": "У «Класичному» прибирає звуки атаки, додані в 1.9 (сильний, слабкий, розмашистий, критичний удар...). Звуки поранення лишаються.",
+  "horizon.pvp.combat_rules": "Бій 1.8 у ваших світах",
+  "horizon.pvp.combat_rules.tooltip": "В одиночній грі та у світах, відкритих для LAN, бої йдуть за правилами 1.8.9: без перезарядки атаки й розмашистого удару, зі шкодою зброї, Силою, Гостротою і критичними ударами як у 1.8. Сервери, до яких ви приєднуєтесь, лишають свої правила.",
+  "Bindings": "Призначення",
+  "Play": "Гра",
+  "Device": "Пристрій",
+  "Look": "Огляд",
+  "Movement": "Рух",
+  "Menus": "Меню",
+  "Actions": "Дії",
+  "Reset": "Скинути",
+  "Detected": "Виявлено",
+  "Glyphs": "Значки кнопок",
+  "Feedback": "Віддача",
+  "Controller": "Геймпад",
+  "How the sticks turn and move you, and how menus repeat and scroll.": "Як стіки повертають і рухають вас, а меню повторюють і прокручують.",
+  "Which button does what. Each player has their own.": "Яка кнопка що робить. У кожного гравця — свої.",
+  "The controller the game sees, its button glyphs and its feedback.": "Геймпад, який бачить гра, значки його кнопок і віддача.",
+  "Press this row, then the button that should do it.": "Натисніть цей рядок, потім кнопку, яка має це робити.",
+  "Off, the game ignores every controller for this player.": "Вимкнено: гра ігнорує всі геймпади для цього гравця.",
+  "How fast the right stick turns the view.": "Як швидко правий стік повертає огляд.",
+  "Turn the view the other way, left and right.": "Повертати огляд у протилежний бік ліворуч і праворуч.",
+  "Turn the view the other way, up and down.": "Повертати огляд у протилежний бік угору і вниз.",
+  "How far the right stick moves before the view turns. Raise it if the view drifts.": "Наскільки має відхилитися правий стік, перш ніж огляд почне повертатися. Збільште, якщо огляд сам зсувається.",
+  "Hold the button to sneak, or press it once to start and again to stop.": "Тримайте кнопку, щоб скрадатися, або натисніть раз, щоб почати, і ще раз, щоб припинити.",
+  "How far the left stick moves before you walk. Raise it if you drift.": "Наскільки має відхилитися лівий стік, перш ніж ви підете. Збільште, якщо вас самого зносить.",
+  "How far a trigger is pulled before it counts as pressed.": "Наскільки треба натиснути тригер, щоб це вважалося натисканням.",
+  "How fast the stick moves the crosshair in inventories.": "Як швидко стік рухає курсор в інвентарях.",
+  "How fast the right stick scrolls a list.": "Як швидко правий стік прокручує список.",
+  "How long a held direction waits before it repeats.": "Скільки утримуваний напрямок чекає перед першим повтором.",
+  "How long a held direction takes between repeats.": "Скільки часу минає між повторами утримуваного напрямку.",
+  "Which on-screen keyboard opens when a text field is pressed.": "Яка екранна клавіатура відкривається, коли натискаєте текстове поле.",
+  "Every action back on its default button.": "Повернути всі дії на типові кнопки.",
+  "These settings belong to this player's profile.": "Ці налаштування належать профілю цього гравця.",
+  "The controller driving this player, or else the first one connected.": "Геймпад, яким керує цей гравець, або інакше перший підключений.",
+  "The USB vendor and product the system reports. Useful when reporting a controller that misbehaves.": "Виробник і продукт USB, які повідомляє система. Знадобиться, коли повідомляєте про геймпад, що працює неправильно.",
+  "The glyph family the game picked from the controller's maker.": "Набір значків, який гра обрала за виробником геймпада.",
+  "Follow the controller, or always show one family's buttons.": "Як у підключеного геймпада або завжди кнопки одного набору.",
+  "The buttons menus show right now.": "Кнопки, які меню показують зараз.",
+  "Rumble when something happens to you.": "Вібрація, коли з вами щось стається.",
+  "The controller keeps playing while this window isn't focused, and losing focus won't pause.": "Геймпад працює, навіть коли це вікно не у фокусі, а втрата фокусу не ставить гру на паузу.",
+  "A DualSense's triggers push back on bows and tools.": "Тригери DualSense чинять опір, коли ви стріляєте з лука чи працюєте інструментами.",
+  "What a DualSense's light shows, over USB or Bluetooth.": "Що показує підсвічування DualSense через USB або Bluetooth.",
+  "Player profile": "Профіль гравця",
+  "Vendor and product": "Виробник і продукт",
+  "Detected glyphs": "Виявлені значки",
+  "Glyphs in use": "Поточні значки",
+  "Unknown": "Невідомо",
+  "No controller": "Немає геймпада",
+  "Editing: %s": "Редагування: %s",
+  "Press the button for this. %s cancels.": "Натисніть кнопку для цього. %s — скасувати.",
+  "This button also does: %s": "Ця кнопка також робить: %s",
+  "horizon.pad.notice.connected.press": "Натисніть, щоб використовувати",
+  "horizon.recipe_transfer.missing": "Бракує предметів",
+  "horizon.recipe_transfer.no_room": "Інвентар заповнено",
+  "horizon.recipe_transfer.unavailable": "Рецепт не підходить для цього меню",
+  "horizon.recipe_transfer.unsupported": "Сервер вимагає відомого рецепта"
 }
@@ -195,6 +195,7 @@
  "horizon.pages.shader_options": "光影选项",
  "horizon.pages.split_profiles": "谁在玩？",
  "horizon.pages.split_profiles.tooltip": "谁在玩：保存在此游戏文件夹中的一份档案。",
+  "horizon.plain.official": "带启动器、模组和更新的官方 Horizon：playhorizon.dev",
  "horizon.shader_options.profile": "档案",
  "General": "常规",
  "Advanced": "高级",
@@ -7,6 +7,18 @@ fn main() {
    let out_dir = std::path::PathBuf::from(std::env::var_os("OUT_DIR").unwrap());
    horizon_mod_api_gen::generate(&root, &out_dir, horizon_mod_api_gen::Target::Client)
        .expect("generating native mod API");
+    // A workspace horizon-mixins changed holds native mods, whichever tool ran it (the launcher,
+    // or a mod's own script with no `native-mods.json` beside its game): `HORIZON_MIXIN_MODS`
+    // names them for `game::mods::built_with_native_mods`. Watched only once it exists: a
+    // bundle applied in place also edits `game/`, which `generate` watches.
+    let stage = root.join(horizon_mod_api_gen::MIXINS_STAGE);
+    if stage.is_file() {
+        println!("cargo:rerun-if-changed={}", stage.display());
+    }
+    let staged = horizon_mod_api_gen::staged_mods(&root);
+    if !staged.is_empty() {
+        println!("cargo:rustc-env=HORIZON_MIXIN_MODS={}", staged.join(","));
+    }
    let manifest_dir = std::path::PathBuf::from(std::env::var_os("CARGO_MANIFEST_DIR").unwrap());
    let ico = manifest_dir
        .join("../..")
@@ -1,7 +1,7 @@
 //! Headless transport for the block-entity render parity gate: replays each
 //! case (block state, light, partial tick and ticked block-entity fields)
 //! through `BlockEntityRenderer` at the block origin and writes the quads
-//! (texture, sprite-local UVs, baked colour, light) and sign text calls.
+//! (texture, sprite-local UVs, tint, normal, light) and sign text calls.
 #![forbid(unsafe_code)]
 use glam::{DVec3, Mat4, Quat, Vec3};
 use horizon_client::{
@@ -10,6 +10,7 @@ use horizon_client::{
    block_entity_anim::EnchantingBook,
    block_entity_render::{
        BlockAnim, BlockEntityRenderer, END_GATEWAY_LAYER, END_PORTAL_LAYER, Scene, TextCall,
+        text_vertices,
    },
    chunk::{Chunk, Light},
    hud::{HudAtlas, Rect},
@@ -86,12 +87,19 @@ fn find_state(registry: &BlockRegistry, spec: &str) -> Option<u32> {

 fn sign_side(v: &Value) -> SignText {
    let mut side = SignText::default();
-    for (line, text) in side
-        .lines
-        .iter_mut()
-        .zip(v["lines"].as_array().into_iter().flatten())
+    for (i, value) in v["lines"]
+        .as_array()
+        .into_iter()
+        .flatten()
+        .take(4)
+        .enumerate()
    {
-        *line = text.as_str().unwrap_or_default().to_owned();
+        let line = horizon_client::scoreboard::comp_text(value);
+        side.lines[i] = line.plain();
+        side.saved[i] = Some(horizon_client::signs::SavedLine {
+            text: line.plain(),
+            component: horizon_client::lan::data::json_to_nbt(value),
+        });
    }
    let color = v["color"].as_str().unwrap_or("black");
    side.color = DYE_TEXT.iter().position(|(n, _)| *n == color).unwrap_or(15) as u8;
@@ -373,6 +381,7 @@ pub fn main() -> Result<()> {
            skull: &|_| None,
            glyph: &|c| atlas.glyph_cell(c),
            glyphs: atlas.font.epoch(),
+            font: Some(&atlas.font),
            dynamic_visible: None,
        };
        let mut verts = Vec::new();
@@ -417,7 +426,8 @@ pub fn main() -> Result<()> {
                        ])
                    })
                    .collect();
-                json!({"texture": texture, "v": v, "color": q[0].color, "light": q[0].light})
+                json!({"texture": texture, "v": v, "color": q[0].color, "light": q[0].light,
+                       "normal": q[0].normal})
            })
            .collect();
        let texts: Vec<Value> = texts
@@ -425,8 +435,26 @@ pub fn main() -> Result<()> {
            .iter()
            .filter(|t| !t.text.is_empty())
            .map(|t| {
+                let mut x = t.x;
+                let glyphs: Vec<_> = t.text.chars().map(|c| {
+                    let g = json!({"matrix": t.matrix.to_cols_array(), "x": x, "y": t.y,
+                        "text": c.to_string(), "color": t.color,
+                        "light": ((t.light & 0xFF) << 16 | (t.light >> 8 & 0xFF)),
+                        "style": [t.style.is_bold(), t.style.is_italic(), t.style.underlined == Some(true),
+                                  t.style.strikethrough == Some(true), t.style.obfuscated == Some(true)]});
+                    x += atlas.font.advance(c, &t.style);
+                    g
+                }).collect();
+                let mut vertices = Vec::new();
+                let mut local = t.clone();
+                local.matrix = Mat4::IDENTITY;
+                text_vertices(&|c| atlas.font.glyph_styled(c, &t.style), Some(atlas.font.white()), &local, &mut vertices);
+                let vertices: Vec<_> = vertices.iter().map(|v| {
+                    let c = v.color;
+                    json!([v.pos[0], v.pos[1], v.pos[2], (c & 0xff00ff00) | (c & 255) << 16 | (c >> 16 & 255)])
+                }).collect();
                json!({"matrix": t.matrix.to_cols_array(), "x": t.x, "y": t.y, "text": t.text,
-                       "color": t.color, "outline": t.outline,
+                       "color": t.color, "outline": t.outline, "glyphs": glyphs, "textVertices": vertices,
                       "light": ((t.light & 0xFF) << 16 | (t.light >> 8 & 0xFF))})
            })
            .collect();
@@ -0,0 +1,79 @@
+//! Rust side of tools/test_enchant_durability_parity.py: `Enchantments` value
+//! effects for the `minecraft:item_damage` (Unbreaking) and
+//! `minecraft:repair_with_xp` (Mending) components on one stack per case.
+use horizon_client::{
+    enchant::{EffectContext, Enchantments},
+    item_data::StackData,
+    items::{ItemStack, Items},
+};
+use horizon_core::random::LegacyRandom;
+use horizon_world::loot::PackOverlay;
+use serde_json::Value;
+use std::{fs, io::Write, path::Path};
+
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<String> = crate::args().collect();
+    let input = fs::read_to_string(args.get(1).ok_or("missing INPUT")?)?;
+    let root = input
+        .lines()
+        .find_map(|line| line.strip_prefix("#resources "))
+        .map(Path::new)
+        .ok_or("no #resources line")?;
+    let enchantments = Enchantments::load(root);
+    let items = Items::catalog(root, &PackOverlay::NONE)?;
+    let out = fs::File::create(args.get(2).ok_or("missing OUTPUT")?)?;
+    let mut out = std::io::BufWriter::new(out);
+    for line in input.lines() {
+        if line.starts_with("#resources ") || line.trim().is_empty() {
+            continue;
+        }
+        let case: Value = serde_json::from_str(line)?;
+        let item = case["item"].as_str().unwrap();
+        let level = case["level"].as_u64().unwrap() as u32;
+        let component = if case["mode"] == "unbreaking" {
+            "minecraft:item_damage"
+        } else {
+            "minecraft:repair_with_xp"
+        };
+        let stack = ItemStack {
+            item: item.into(),
+            count: 1,
+            damage: case["damage"].as_u64().unwrap() as u32,
+            extra: Some(Box::new(StackData {
+                enchantments: vec![(
+                    component_enchantment(case["mode"].as_str().unwrap()).into(),
+                    level,
+                )],
+                ..Default::default()
+            })),
+        };
+        let ctx = EffectContext {
+            tool: Some(&stack.item),
+            items: Some(&items),
+            ..Default::default()
+        };
+        let mut random = LegacyRandom::new(case["seed"].as_i64().unwrap());
+        let value = enchantments.modify_value(
+            Some(&stack),
+            component,
+            &ctx,
+            &mut random,
+            case["amount"].as_i64().unwrap() as f32,
+        );
+        let value = if case["mode"] == "mending" {
+            value.max(0.0)
+        } else {
+            value
+        };
+        writeln!(out, "{}", value as i64)?;
+    }
+    Ok(())
+}
+
+fn component_enchantment(mode: &str) -> &'static str {
+    if mode == "unbreaking" {
+        "minecraft:unbreaking"
+    } else {
+        "minecraft:mending"
+    }
+}
@@ -283,6 +283,7 @@ pub fn main() -> horizon_client::Result<()> {
                loot: &loot,
                damage: Some(source),
                player: player.filter(|_| pkill),
+                player_killed: pkill,
                luck: get("luck", "0").parse()?,
                vehicle: c.get("vehicle").map(|v| LootEntity::new(v)),
                mob_drops: true,
@@ -0,0 +1,76 @@
+//! Environment attribute entries for tools/test_environment_attribute_modifier_parity.py: each
+//! case parses an entry for an attribute and applies it to a subject value.
+use horizon_world::environment_attributes::{ATTRIBUTES, Attribute, Entry, Kind, Value, attribute};
+use std::{error::Error, fmt::Write};
+
+fn bits(f: f32) -> String {
+    format!("{:08x}", f.to_bits())
+}
+
+fn format(value: &Value) -> String {
+    match value {
+        Value::Bool(b) => b.to_string(),
+        Value::Float(f) => bits(*f),
+        Value::Rgb(v) => v.map(bits).join(" "),
+        Value::Argb(v) => v.map(bits).join(" "),
+        Value::Other(json) => json.to_string(),
+    }
+}
+
+fn run(attribute: &Attribute, subject: &str, entry: &str) -> Result<String, Box<dyn Error>> {
+    let subject = match Entry::parse(attribute, &serde_json::from_str(subject)?)? {
+        Entry::Override(value) => value,
+        _ => return Err("the subject is not a plain value".into()),
+    };
+    let Ok(entry) = Entry::parse(attribute, &serde_json::from_str(entry)?) else {
+        return Ok("error".into());
+    };
+    let value = entry.apply(&subject);
+    Ok(format!(
+        "{}\t{}",
+        format(&value),
+        format(&attribute.sanitize(value.clone()))
+    ))
+}
+
+/// Every attribute in registration order: id, type, default, and how a float range clamps.
+fn registry(output: &mut String) -> std::fmt::Result {
+    for a in &ATTRIBUTES {
+        let kind = match a.kind {
+            Kind::Boolean => "minecraft:boolean",
+            Kind::Float => "minecraft:float",
+            Kind::AngleDegrees => "minecraft:angle_degrees",
+            Kind::RgbColor => "minecraft:rgb_color",
+            Kind::ArgbColor => "minecraft:argb_color",
+            Kind::Other => "other",
+        };
+        let default = a.default_value();
+        let range = match default {
+            Some(Value::Float(_)) => format!(
+                "{} {}",
+                format(&a.sanitize(Value::Float(f32::NEG_INFINITY))),
+                format(&a.sanitize(Value::Float(f32::INFINITY)))
+            ),
+            _ => "-".into(),
+        };
+        let default = default.map_or("unported".into(), |v| format(&v));
+        writeln!(output, "minecraft:{}\t{kind}\t{default}\t{range}", a.id)?;
+    }
+    Ok(())
+}
+
+pub fn main() -> Result<(), Box<dyn Error>> {
+    let args: Vec<String> = crate::args().collect();
+    let mut output = String::new();
+    for line in std::fs::read_to_string(&args[1])?.lines() {
+        if line == "registry" {
+            registry(&mut output)?;
+            continue;
+        }
+        let fields: Vec<&str> = line.split('\t').collect();
+        let attribute = attribute(fields[0]).ok_or("unknown attribute")?;
+        writeln!(output, "{}", run(attribute, fields[1], fields[2])?)?;
+    }
+    std::fs::write(&args[2], output)?;
+    Ok(())
+}
@@ -0,0 +1,159 @@
+//! Rust side of tools/test_falling_block_parity.py: replays the landing branch
+//! of `FallingBlockEntity.tick` over the case's block map through
+//! `horizon_world::level::Behaviours::falling_block_landed` and prints the same
+//! decision, changed blocks and numeric level events as the Java oracle.
+use horizon_core::{position::BlockPos, random::LegacyRandom};
+use horizon_world::{
+    fluid::FluidKind,
+    level::{Behaviours, Dimension, Landing, LevelAccess, LevelEvent, Ticks, data::load_registry},
+    registry::BlockStateId,
+};
+use serde_json::Value;
+use std::{
+    collections::HashMap,
+    io::{BufRead, Write},
+    path::Path,
+};
+
+struct Cells {
+    cells: HashMap<BlockPos, BlockStateId>,
+    air: BlockStateId,
+    random: LegacyRandom,
+    events: Vec<String>,
+}
+impl LevelAccess for Cells {
+    fn block_state(&self, pos: BlockPos) -> BlockStateId {
+        self.cells.get(&pos).copied().unwrap_or(self.air)
+    }
+    fn set_raw(&mut self, pos: BlockPos, state: BlockStateId) -> Option<BlockStateId> {
+        let old = self.block_state(pos);
+        if state == self.air {
+            self.cells.remove(&pos);
+        } else {
+            self.cells.insert(pos, state);
+        }
+        Some(old)
+    }
+    fn is_loaded(&self, _pos: BlockPos) -> bool {
+        true
+    }
+    fn min_y(&self) -> i32 {
+        -64
+    }
+    fn max_y(&self) -> i32 {
+        320
+    }
+    fn random(&mut self) -> &mut LegacyRandom {
+        &mut self.random
+    }
+    fn game_time(&self) -> i64 {
+        0
+    }
+    fn dimension(&self) -> Dimension {
+        Dimension::Overworld
+    }
+    fn emit(&mut self, event: LevelEvent) {
+        if let LevelEvent::LevelEvent { id, pos, data } = event
+            && id == 1031
+        {
+            self.events
+                .push(format!("L {} {},{},{} {}", id, pos.x, pos.y, pos.z, data));
+        }
+    }
+}
+
+fn pos(v: &Value) -> BlockPos {
+    BlockPos::new(
+        v[0].as_i64().unwrap() as i32,
+        v[1].as_i64().unwrap() as i32,
+        v[2].as_i64().unwrap() as i32,
+    )
+}
+
+fn main_landing(case: &Value, b: &Behaviours, air: BlockStateId, out: &mut Vec<String>) {
+    let mut level = Cells {
+        cells: HashMap::new(),
+        air,
+        random: LegacyRandom::new(case["seed"].as_i64().unwrap()),
+        events: Vec::new(),
+    };
+    for c in case["cells"].as_array().unwrap() {
+        let state = BlockStateId(c[3].as_i64().unwrap() as u32);
+        if state != air {
+            level.cells.insert(pos(c), state);
+        }
+    }
+    let at = pos(&case["pos"]);
+    let before = level.cells.clone();
+    let original = BlockStateId(case["state"].as_i64().unwrap() as u32);
+    // `FallingBlockEntity.fall` drops the WATERLOGGED property before the entity
+    // carries the state and puts the source's legacy fluid block at the cell;
+    // `falling_block_fall` does the same for the caller. The case's destination
+    // state is then restored for the landing probe.
+    let state = b
+        .table
+        .with_bool(original, b.props.waterlogged, false)
+        .unwrap_or(original);
+    let destination = level.cells.get(&at).copied();
+    let legacy = b.legacy_block(b.fluid(original));
+    if legacy == air {
+        level.cells.remove(&at);
+    } else {
+        level.cells.insert(at, legacy);
+    }
+    if let Some(destination) = destination {
+        level.cells.insert(at, destination);
+    }
+    let stuck = matches!(
+        b.fluid(level.block_state(at)).kind(),
+        FluidKind::Water | FluidKind::FlowingWater
+    );
+    let mut ticks = Ticks::new(0);
+    let landing = b.falling_block_landed(&mut level, &mut ticks, at, state, stuck);
+    match landing {
+        Landing::Placed(placed) => {
+            out.push(format!("decision placed {}", placed.0));
+        }
+        Landing::Broken => out.push("decision broken".into()),
+        Landing::Continue => out.push("decision continue".into()),
+    }
+    let mut changed: Vec<BlockPos> = before
+        .keys()
+        .copied()
+        .chain(level.cells.keys().copied())
+        .collect();
+    changed.sort_by_key(|p| (p.x, p.y, p.z));
+    changed.dedup();
+    for p in changed {
+        let now = level.block_state(p);
+        if before.get(&p).copied().unwrap_or(air) != now {
+            out.push(format!("set {},{},{} {}", p.x, p.y, p.z, now.0));
+        }
+    }
+    out.extend(level.events);
+}
+
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut args = crate::args().skip(1);
+    let resources = args.next().expect("resource directory");
+    let cases = args.next().expect("case file");
+    let output = args.next().expect("output file");
+    let resources = Path::new(&resources);
+    let registry = load_registry(resources)?;
+    let behaviours = Behaviours::load(&registry, resources)?;
+    let air = registry.default_state("minecraft:air").unwrap();
+    let mut out = std::io::BufWriter::new(std::fs::File::create(output)?);
+    for (index, line) in std::io::BufReader::new(std::fs::File::open(cases)?)
+        .lines()
+        .enumerate()
+    {
+        let case: Value = serde_json::from_str(&line?)?;
+        let mut lines = Vec::new();
+        main_landing(&case, &behaviours, air, &mut lines);
+        writeln!(out, "== {index}")?;
+        for line in lines {
+            writeln!(out, "{line}")?;
+        }
+    }
+    Ok(())
+}
@@ -0,0 +1,106 @@
+//! Furnace parity (tools/test_furnace_parity.py): reads "furnace KIND TICKS
+//! INPUT FUEL OUTPUT TIMER TOTAL LIT LITTOTAL SPEED CHANGE_AT NEW_INPUT"
+//! lines, runs the furnace model and prints the slots, timers, LIT state,
+//! RecipesUsed counts and each used recipe's experience.
+//!
+//! The first input line is `#resources RESOURCES`; usage: furnace_fixture INPUT OUTPUT
+use horizon_client::{
+    crafting::Recipes,
+    furnace::FurnaceCooking,
+    item_data::{canon_stack, parse_stack},
+    items::Items,
+};
+use horizon_client_render::{
+    chunk::block_entity::{Furnace, FurnaceKind},
+    providers::Providers,
+};
+use horizon_world::loot::PackOverlay;
+use std::{collections::HashMap, fmt::Write as _, fs};
+
+pub fn main() -> horizon_client::Result<()> {
+    let args: Vec<String> = crate::args().collect();
+    let input = fs::read_to_string(args.get(1).ok_or("missing INPUT")?)?;
+    let root = input
+        .lines()
+        .find_map(|line| line.strip_prefix("#resources "))
+        .map(std::path::PathBuf::from)
+        .ok_or("no #resources line")?;
+    let items = Items::catalog(&root, &PackOverlay::NONE)?;
+    let recipes = Recipes::load(&root, &items, &PackOverlay::NONE)?;
+    let providers = Providers::load(&root);
+    let mut out = String::new();
+    for (n, line) in input
+        .lines()
+        .filter(|line| !line.starts_with('#'))
+        .enumerate()
+    {
+        let f: Vec<&str> = line.split(' ').collect();
+        let kind = match f[1] {
+            "furnace" => FurnaceKind::Furnace,
+            "blast_furnace" => FurnaceKind::BlastFurnace,
+            "smoker" => FurnaceKind::Smoker,
+            _ => return Err("unknown furnace kind".into()),
+        };
+        let ticks: u32 = f[2].parse()?;
+        let mut items3 = [None, None, None];
+        for i in 0..3 {
+            items3[i] = parse_stack(f[3 + i])?;
+        }
+        let mut furnace = Furnace {
+            kind,
+            items: items3,
+            lit_remaining: f[8].parse()?,
+            lit_total: f[9].parse()?,
+            cooking_timer: f[6].parse()?,
+            cooking_total: f[7].parse()?,
+            speed: f[10].parse()?,
+            recipes_used: HashMap::new(),
+        };
+        let change_at: i32 = f[11].parse()?;
+        let new_input = parse_stack(f[12])?;
+        let mut lit_state = false;
+        let mut drops = Vec::new();
+        for t in 0..ticks {
+            if t as i32 == change_at {
+                furnace.set_input(&recipes, new_input.clone());
+            }
+            if let Some(lit) = furnace.tick(&recipes, &items, &providers, &mut drops) {
+                lit_state = lit;
+            }
+        }
+        if change_at == ticks as i32 {
+            furnace.set_input(&recipes, new_input.clone());
+        }
+        write!(out, "{n} kind={} ", f[1])?;
+        for i in 0..3 {
+            write!(out, "s{i}={} ", canon_stack(furnace.items[i].as_ref()))?;
+        }
+        write!(
+            out,
+            "timer={} total={} lit={} littotal={} speed={:.3} state={lit_state} used=",
+            furnace.cooking_timer,
+            furnace.cooking_total,
+            furnace.lit_remaining,
+            furnace.lit_total,
+            furnace.speed
+        )?;
+        let mut ids: Vec<&String> = furnace.recipes_used.keys().collect();
+        ids.sort();
+        for (i, id) in ids.iter().enumerate() {
+            if i > 0 {
+                out.push(',');
+            }
+            write!(out, "{id}={}", furnace.recipes_used[*id])?;
+        }
+        out.push_str(" xp=");
+        for (i, id) in ids.iter().enumerate() {
+            if i > 0 {
+                out.push(',');
+            }
+            write!(out, "{id}={}", recipes.cooking_experience(id))?;
+        }
+        writeln!(out)?;
+    }
+    fs::write(args.get(2).ok_or("missing OUTPUT")?, out)?;
+    Ok(())
+}