Storage: is_multiple_of in fixed_shift (clippy on main)

#10553 wrote stride % self.per_word == 0, which clippy 1.99 rejects (manual_is_multiple_of) under -D warnings: main's checks and every PR's verify fail to compile horizon-core. per_word is never 0, so the result is the same. Co-Authored-By: Claude Opus 5.5 <[email protected]>
Merge pull request #10538 from arslanarm/shaderpacks/end-fog-sky-fan
2026-11-07 11:06:11 -10:00 · 2026-11-07 12:48:37 +01:00 · 2026-11-07 12:37:21 +01:00 · 2026-11-07 12:34:18 +01:00 · 2026-11-07 12:31:28 +01:00 · 2026-11-07 12:30:08 +01:00
802 changed files with 57435 additions and 4443 deletions
@@ -234,14 +234,15 @@ jobs:
        run: python ../tools/check_pe_arch.py arm64 target/aarch64-pc-windows-msvc/release/horizon-launcher.exe
      - name: Check launcher DLL imports and command-line startup
        working-directory: launcher
-        shell: pwsh
+        # bash, as launcher.yml's check on the same runner: the launcher is a GUI-subsystem program, and a pwsh
+        # `$output = & launcher --version` read no output from it (run 42217014588).
+        shell: bash
        run: |
-          $ErrorActionPreference = 'Stop'
-          $launcher = 'target/aarch64-pc-windows-msvc/release/horizon-launcher.exe'
-          python ../tools/check_imports.py $launcher
-          $output = & $launcher --version 2>&1
-          if ($LASTEXITCODE -ne 0 -or -not $output) { throw 'horizon-launcher --version failed' }
-          Write-Output ($output -join "`n")
+          launcher=target/aarch64-pc-windows-msvc/release/horizon-launcher.exe
+          python ../tools/check_imports.py "$launcher"
+          out=$("$launcher" --version)
+          echo "$out"
+          [[ "$out" == "horizon-launcher "* ]] || { echo "::error::horizon-launcher --version printed '$out'"; exit 1; }
      - name: Build a native-mod game with the launcher's managed toolchain
        working-directory: launcher
        shell: pwsh
@@ -51,7 +51,7 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 | `horizon-command` | Command parsing (Brigadier): the vanilla tree, argument types, selectors, suggestions, the tree's network form. Re-exported as `horizon_client::command` |
 | `horizon-client-core` | The client lib's bottom layer: `text.rs`, `lang.rs`, `snbt.rs`, `nbt_path.rs`, `component.rs`, `scoreboard.rs`, `bossbar.rs`, `gamerules.rs`, `block_entity_nbt.rs`, registry/particle/sound tables. Re-exported under the old paths (`horizon_client::text`...) |
 | `horizon-client-input` | Key bindings and key names, toggle keys, mouse options, controller settings and glyphs, the clipboard, window options (`keybinds.rs`, `gamepad.rs`, `mouse.rs`, `window.rs`...). Re-exported under the old paths |
-| `horizon-client-render` | The client's world data, rendering and screens (chunks, meshing, light, streaming, `gfx`, HUD, menus, settings): ~80 modules that horizon-client re-exports under the same paths. Nothing in it reaches gameplay |
+| `horizon-client-render` | The client's world data, rendering and screens (chunks, meshing, light, streaming, `gfx`, HUD, menus, settings), modules that horizon-client re-exports under the same paths. Nothing in it reaches gameplay |
 | `horizon-world` | Vanilla world data with no gameplay loop: NBT, regions, chunks, `datafix/`, `worldgen/`, `level/` (server-side block behaviour, ticks, redstone), entity physics, items, effects, food, damage |
 | `horizon-core` | Simulation primitives: Java `Random`s, `jmath` (HotSpot-exact `Math`), positions, noise, density, paletted storage, `version.rs` (the pinned version) |
 | `horizon-protocol` | Network protocol 777: codecs, framing, encryption, `packets/{handshake,status,login,configuration,play}.rs`, `entity_data.rs` |
@@ -65,6 +65,7 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 | `horizon-mods`, `cargo-horizon-mod` | Content mods (`.hmod`: manifest, content fence, no code), the registry index and `.hpack`, and `cargo horizon-mod` (`new`, `build`, `run`, `check`, `registry`) ([docs/mods.md](docs/mods.md)). Code mods are native, built by the launcher ([docs/native-mods.md](docs/native-mods.md)) |
 | `horizon-port-pack` | Porting Java modpacks ([docs/modpacks.md](docs/modpacks.md)) |
 | `horizon-optifine` | OptiFine-format pack files below every feature that reads them: `.properties`, the name/range/block matchers, paths and `optifine/` folders, and custom entity models (`cem/`: `.jem`/`.jpm` parsing and baking) |
+| `horizon-polytone` | Polytone-format pack files (`assets/*/polytone/`), read clean-room from the public wiki: targets, biome and dimension modifiers and their environment attribute layers (#11486) |
 | `horizon-shader-api` | Horizon's own WGSL shader packs ([docs/api/shaders.md](docs/api/shaders.md)): `horizon-shaders.toml`, the `.hshader` package; shared by the game, the launcher and the registry |
 | `horizon-shaders` | Shader packs (the `shaders/` folder format), rebuilt clean-room from a written spec of the format; no wgpu |
 | `horizon-theme` | Design tokens and fonts for the launcher, the game's own menus and the website |
@@ -92,8 +93,8 @@ reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` an
 ```sh
 python3 tools/pr_ready.py                  # the self-check: fmt, clippy -D warnings, touched crates' tests, harnesses; paste its block in the PR
 python3 tools/pr_ready.py --quick          # same without harnesses
-cargo test -p horizon-client -p horizon-client-lib --lib --bins --tests   # skips the 104 examples (pr_ready does this); `--doc` separately
-cargo test -p horizon-client-lib --lib mod_content::tests:: -- --ignored   # the 5 slow content-root tests, #[ignore]d; pr_ready runs them when mod content, assets, blocks or items change
+cargo test -p horizon-client -p horizon-client-lib --lib --bins --tests   # skips the examples (pr_ready does this); `--doc` separately
+cargo test -p horizon-client-lib --lib mod_content::tests:: -- --ignored   # the slow content-root tests, #[ignore]d; pr_ready runs them when mod content, assets, blocks or items change
 cargo build --profile fast -p horizon-client        # optimized, quick to link: use it to play or run lan_e2e
 python3 tools/parity.py --changed origin/main       # the harnesses your branch can affect (CI's parity job)
 python3 tools/parity.py --changed-files paths.txt --list   # which harnesses cover these files, without running them
@@ -105,8 +106,8 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 - Harnesses and the game need the vanilla data in `.local/` (`minecraft/`, `horizon-client/26.3`, `datagen/`,
  `tools/`): see [docs/parity-workflow.md](docs/parity-workflow.md). Without it, pr_ready lists the
  harnesses for CI.
- A harness = `tools/test_<name>_parity.py` (324 of them) + a Java oracle (`mods/horizon/src/test/java/dev/horizonlab/parity/Vanilla*Oracle.java`)
-  + a Rust probe: `crates/<crate>/examples/<name>_{probe,fixture}.rs` (horizon-world 175, horizon-client 104),
+- A harness = `tools/test_<name>_parity.py` + a Java oracle (`mods/horizon/src/test/java/dev/horizonlab/parity/Vanilla*Oracle.java`)
+  + a Rust probe: `crates/<crate>/examples/<name>_{probe,fixture}.rs` (mostly horizon-world and horizon-client),
  or the game binary with a fixture env var (`game/dispense_fixture.rs`, `game/sculk_fixture.rs`,
  `game/command_harness.rs`, `game/net_harness.rs`). Copy a nearby harness for a new one.
 - Developing a native mod? Run `horizon-launcher settings native-profile dev` once. `dev` builds the game crate
@@ -176,7 +177,7 @@ state stays separate from the library tests. This compiles gameplay twice for ex

 ## How `Game` is organised

- `struct Game` (game.rs, ~290 fields) holds everything. Its methods are spread over ~180 files: game.rs keeps
+- `struct Game` (game.rs) holds everything. Its methods are spread over many files: game.rs keeps
  the core (tick, render, input, inventory, world open/close) and each `game/<feature>.rs` adds an
  `impl Game<'_>` block for one feature, with its own state types. Fields stay private to the gameplay module and its descendants. Gameplay tests run in the gameplay library, separate from reusable-library tests.
 - Find a feature's code: `grep -rn "fn tick_<thing>\|fn <verb>_<thing>" crates/horizon-client/src/game*`;
@@ -33,7 +33,7 @@ queue (the hub, or `/suggest` on Discord) rather than to issues, which are for b
 Wherever vanilla has a feature, vanilla is the specification, down to the order of random calls. "Parity" here means
 Horizon gives the same results as the pinned 26.3 client and server for the same inputs, checked by a **harness**: a
 `tools/test_*_parity.py` script that runs a small Java oracle against the real game and a Rust probe against Horizon,
-and compares their outputs. There are about 290 of them.
+and compares their outputs.

 - **Read the vanilla code before writing Horizon's.** `tools/rea_vanilla.py` queries the pinned game bytecode:
  `python3 tools/rea_vanilla.py method net.minecraft.world.level.block.DispenserBlock dispenseFrom`.
@@ -131,9 +131,9 @@ dependencies = [

 [[package]]
 name = "arboard"
-version = "3.6.1"
+version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf"
+checksum = "aeb9553e62312c8756a5979254fc6d7da8bbeb5986a1e17037fab932f7037917"
 dependencies = [
 "clipboard-win",
 "log",
@@ -142,7 +142,7 @@ dependencies = [
 "objc2-foundation 0.3.2",
 "parking_lot",
 "percent-encoding",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 "wl-clipboard-rs",
 "x11rb",
 ]
@@ -153,6 +153,12 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "03918c3dbd7701a85c6b9887732e2921175f26c350b4563841d0958c21d57e6d"

+[[package]]
+name = "arraydeque"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d902e3d592a523def97af8f317b08ce16b7ab854c1985a0c671e6f15cebc236"
+
 [[package]]
 name = "arrayref"
 version = "0.3.9"
@@ -485,6 +491,7 @@ checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
 dependencies = [
 "iana-time-zone",
 "num-traits",
+ "serde",
 "windows-link",
 ]

@@ -540,6 +547,12 @@ dependencies = [
 "unicode-width",
 ]

+[[package]]
+name = "color_quant"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
 [[package]]
 name = "combine"
 version = "4.6.8"
@@ -946,6 +959,18 @@ version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7"

+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
 [[package]]
 name = "fdeflate"
 version = "0.3.7"
@@ -1105,8 +1130,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
 dependencies = [
 "cfg-if",
+ "js-sys",
 "libc",
 "wasi",
+ "wasm-bindgen",
 ]

 [[package]]
@@ -1135,6 +1162,16 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "gif"
+version = "0.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159"
+dependencies = [
+ "color_quant",
+ "weezl",
+]
+
 [[package]]
 name = "gilrs"
 version = "0.11.2"
@@ -1264,6 +1301,15 @@ dependencies = [
 "serde_core",
 ]

+[[package]]
+name = "hashlink"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a596f1b20ed2cc5ecac41a164aaebc7258057060f06c0cf7a2ba3991ee7990fb"
+dependencies = [
+ "hashbrown 0.17.1",
+]
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -1365,6 +1411,7 @@ dependencies = [
 "ab_glyph",
 "bytemuck",
 "chrono",
+ "crc32fast",
 "dunce",
 "flate2",
 "fs4",
@@ -1447,6 +1494,7 @@ dependencies = [
 "ab_glyph",
 "bytemuck",
 "chrono",
+ "crc32fast",
 "flate2",
 "fs4",
 "getrandom 0.3.4",
@@ -1603,7 +1651,7 @@ dependencies = [
 "serde",
 "serde_json",
 "sha2",
- "socket2 0.5.10",
+ "socket2",
 "spake2",
 ]

@@ -1660,10 +1708,15 @@ dependencies = [
 name = "horizon-mod-deps"
 version = "0.1.0"
 dependencies = [
+ "gif",
 "mysql",
+ "quinn",
 "redis",
+ "rusqlite",
 "rusty-opus",
+ "snap",
 "tungstenite",
+ "yaml-rust2",
 ]

 [[package]]
@@ -1703,6 +1756,14 @@ dependencies = [
 "regex",
 ]

+[[package]]
+name = "horizon-polytone"
+version = "0.1.0"
+dependencies = [
+ "regex",
+ "serde_json",
+]
+
 [[package]]
 name = "horizon-port-pack"
 version = "0.1.0"
@@ -1742,6 +1803,7 @@ dependencies = [
 "serde_json",
 "sha1",
 "sha2",
+ "socket2 0.5.10",
 ]

 [[package]]
@@ -2001,12 +2063,12 @@ dependencies = [

 [[package]]
 name = "if-addrs"
-version = "0.13.4"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69b2eeee38fef3aa9b4cc5f1beea8a2444fc00e7377cafae396de3f5c2065e24"
+checksum = "c0a05c691e1fae256cf7013d99dad472dc52d5543322761f83ec8d47eab40d2b"
 dependencies = [
 "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -2076,7 +2138,7 @@ version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4d40460c0ce33d6ce4b0630ad68ff63d6661961c48b6dba35e5a4d81cfb48222"
 dependencies = [
- "socket2 0.6.5",
+ "socket2",
 "widestring",
 "windows-registry",
 "windows-result 0.4.1",
@@ -2268,6 +2330,17 @@ dependencies = [
 "redox_syscall 0.9.4",
 ]

+[[package]]
+name = "libsqlite3-sys"
+version = "0.39.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14a5f01b87b92705d07b433c06f96cbc764637d81a0bffb5734ce17cf0f9a2b3"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "libudev-sys"
 version = "0.1.4"
@@ -2323,6 +2396,12 @@ version = "0.16.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f66e8d5d03f609abc3a39e6f08e4164ebf1447a732906d39eb9b99b7919ef39"

+[[package]]
+name = "lru-slab"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4050469837a6ff301cd14c1f8f24f88549e6d548f24f64e2148eb0f72cebc51f"
+
 [[package]]
 name = "lz4_flex"
 version = "0.14.0"
@@ -2432,7 +2511,7 @@ dependencies = [
 "percent-encoding",
 "rustls",
 "rustls-pemfile",
- "socket2 0.6.5",
+ "socket2",
 "twox-hash",
 "url",
 "webpki",
@@ -2450,6 +2529,7 @@ dependencies = [
 "btoi",
 "byteorder",
 "bytes",
+ "chrono",
 "crc32fast",
 "flate2",
 "getrandom 0.3.4",
@@ -2484,7 +2564,7 @@ dependencies = [
 "num-traits",
 "once_cell",
 "pp-rs",
- "rustc-hash",
+ "rustc-hash 1.1.0",
 "spirv",
 "thiserror 2.0.21",
 "unicode-ident",
@@ -2498,7 +2578,7 @@ checksum = "590afbf58a6f4f62873cd5cff4468061844bafa1cdf399cc954537c22d768d49"
 dependencies = [
 "hashbrown 0.17.1",
 "indexmap",
- "rustc-hash",
+ "rustc-hash 1.1.0",
 "thiserror 2.0.21",
 ]

@@ -3354,6 +3434,62 @@ dependencies = [
 "memchr",
 ]

+[[package]]
+name = "quinn"
+version = "0.11.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4051e23e9185c255a7e33ef59cdbca87a22d359052eecd22fc6b901fb37d9d11"
+dependencies = [
+ "bytes",
+ "cfg_aliases",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash 2.1.3",
+ "rustls",
+ "socket2",
+ "thiserror 2.0.21",
+ "tokio",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.11.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e750cca55fe4f0439a15d0bb529da9651e79993e8e72c61a899a36d462befbe"
+dependencies = [
+ "bytes",
+ "getrandom 0.4.3",
+ "lru-slab",
+ "rand",
+ "rand_pcg",
+ "ring",
+ "rustc-hash 2.1.3",
+ "rustls",
+ "rustls-pki-types",
+ "slab",
+ "thiserror 2.0.21",
+ "tinyvec",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-udp"
+version = "0.5.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af66907df18639dcf4db56ca65490cabc4b27a97dbadd96f2926cca73298f016"
+dependencies = [
+ "cfg_aliases",
+ "libc",
+ "once_cell",
+ "socket2",
+ "tracing",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.47"
@@ -3401,6 +3537,15 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"

+[[package]]
+name = "rand_pcg"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a"
+dependencies = [
+ "rand_core 0.10.1",
+]
+
 [[package]]
 name = "range-alloc"
 version = "0.1.5"
@@ -3458,7 +3603,7 @@ dependencies = [
 "itoa",
 "percent-encoding",
 "ryu",
- "socket2 0.6.5",
+ "socket2",
 "url",
 "xxhash-rust",
 ]
@@ -3539,12 +3684,32 @@ dependencies = [
 "windows-sys 0.52.0",
 ]

+[[package]]
+name = "rusqlite"
+version = "0.41.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da9bba6f3506135e120a6586df05be18b48d18896600646a4bec8f993d91a594"
+dependencies = [
+ "bitflags 2.13.2",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "smallvec",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"

+[[package]]
+name = "rustc-hash"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -3619,6 +3784,7 @@ version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
 dependencies = [
+ "web-time",
 "zeroize",
 ]

@@ -3884,14 +4050,10 @@ dependencies = [
 ]

 [[package]]
-name = "socket2"
-version = "0.5.10"
+name = "snap"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
-dependencies = [
- "libc",
- "windows-sys 0.52.0",
-]
+checksum = "199905e6153d6405f9728fe44daace35f8f837bbf830bb6e85fbd5828709a886"

 [[package]]
 name = "socket2"
@@ -4198,13 +4360,23 @@ dependencies = [
 "zerovec",
 ]

+[[package]]
+name = "tinyvec"
+version = "1.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd3ca314f692efd6c868f8408f53fe444634a845f96c028b97d35f6a1f79f0ee"
+
 [[package]]
 name = "tokio"
 version = "1.53.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e95f91fcc7a621e8b030f6aa23c71fe9838ae2fb4d8118b75602a328f5144044"
 dependencies = [
+ "libc",
+ "mio",
 "pin-project-lite",
+ "socket2",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -4274,6 +4446,9 @@ name = "tracing-core"
 version = "0.1.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]

 [[package]]
 name = "tree_magic_mini"
@@ -4412,6 +4587,12 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
 [[package]]
 name = "vec_map"
 version = "0.8.2"
@@ -4675,6 +4856,12 @@ dependencies = [
 "rustls-pki-types",
 ]

+[[package]]
+name = "weezl"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
+
 [[package]]
 name = "wgpu"
 version = "30.0.1"
@@ -4728,7 +4915,7 @@ dependencies = [
 "portable-atomic",
 "profiling",
 "raw-window-handle",
- "rustc-hash",
+ "rustc-hash 1.1.0",
 "smallvec",
 "thiserror 2.0.21",
 "wgpu-core-deps-apple",
@@ -5051,15 +5238,6 @@ dependencies = [
 "windows-targets 0.52.6",
 ]

-[[package]]
-name = "windows-sys"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
-dependencies = [
- "windows-targets 0.53.5",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.61.2"
@@ -5093,30 +5271,13 @@ dependencies = [
 "windows_aarch64_gnullvm 0.52.6",
 "windows_aarch64_msvc 0.52.6",
 "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm 0.52.6",
+ "windows_i686_gnullvm",
 "windows_i686_msvc 0.52.6",
 "windows_x86_64_gnu 0.52.6",
 "windows_x86_64_gnullvm 0.52.6",
 "windows_x86_64_msvc 0.52.6",
 ]

-[[package]]
-name = "windows-targets"
-version = "0.53.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
-dependencies = [
- "windows-link",
- "windows_aarch64_gnullvm 0.53.1",
- "windows_aarch64_msvc 0.53.1",
- "windows_i686_gnu 0.53.1",
- "windows_i686_gnullvm 0.53.1",
- "windows_i686_msvc 0.53.1",
- "windows_x86_64_gnu 0.53.1",
- "windows_x86_64_gnullvm 0.53.1",
- "windows_x86_64_msvc 0.53.1",
-]
-
 [[package]]
 name = "windows-threading"
 version = "0.2.1"
@@ -5138,12 +5299,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"

-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.42.2"
@@ -5156,12 +5311,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"

-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.42.2"
@@ -5174,24 +5323,12 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"

-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
-
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"

-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.42.2"
@@ -5204,12 +5341,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"

-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.42.2"
@@ -5222,12 +5353,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"

-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.42.2"
@@ -5240,12 +5365,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"

-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.42.2"
@@ -5258,12 +5377,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"

-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
-
 [[package]]
 name = "winit"
 version = "0.30.13"
@@ -5471,6 +5584,16 @@ version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "550a2b930b62486a393c52d5c3b84bff264b28aa437ed64694d31e93b1757af7"

+[[package]]
+name = "yaml-rust2"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57e5b818a27a4cd30884ea380857a5e56f7ec3ba24a3990a3cc0b95af3238e18"
+dependencies = [
+ "arraydeque",
+ "hashlink",
+]
+
 [[package]]
 name = "yasna"
 version = "0.6.0"
@@ -37,6 +37,7 @@ members = [
    "crates/horizon-port-pack",
    "crates/horizon-shaders",
    "crates/horizon-optifine",
+    "crates/horizon-polytone",
    "crates/horizon-shader-api",
    "crates/horizon-release-sign",
    "crates/horizon-mod-deps",
@@ -47,7 +48,7 @@ resolver = "2"
 [workspace.package]
 edition = "2024"
 license = "MIT"
-rust-version = "1.85"
+rust-version = "1.95"

 # Ports mirror vanilla's Java signatures, index loops and nested generic types
 # one to one so they can be checked against the decompiled sources.
@@ -410,16 +410,6 @@ The panel's later features (bans, worlds, server.properties import, logs and cra

 </details>

-#### Ely.by and other sign-in providers
-
-Sign in with other account providers, such as Ely.by or any Yggdrasil-compatible one, beside Microsoft.
-
-<details><summary>Technical</summary>
-
-Issue [#1270](https://github.com/horizon-rust/horizon/issues/1270) asks for Ely.by and Yggdrasil-compatible servers with an account selector in the launcher. It builds on the Microsoft sign-in ([docs/microsoft-account.md](docs/microsoft-account.md)).
-
-</details>
-
 #### Join servers on older versions

 Join servers that run older Minecraft versions, such as 1.21 or 1.8 PvP servers, from Horizon.
@@ -1,5 +1,15 @@
 # Third-party notices

+## Catnip / Ponder
+
+`crates/horizon-client-render/src/fluid_render.rs` translates the still-fluid face tiling and
+UV rules of Catnip's `FluidRenderHelper` from Ponder 1.0.82 for Minecraft 1.21.1
+(`net.createmod.ponder:ponder-neoforge:1.0.82+mc1.21.1`). Copyright (c) 2022 The Create Team,
+licensed under MIT (`LICENSE_Ponder` in that artifact); the full license heads the Rust file.
+The native renderer uses Horizon's own block-sprite arrays, pose and light packing. The
+development-only oracle calls the unchanged helper from the player's local artifact. No
+original classes, game shaders, textures or prepared resources are distributed here.
+
 ## wgpu-hal

 `third_party/wgpu-hal` is [wgpu-hal](https://github.com/gfx-rs/wgpu) 30.0.1 by the gfx-rs
@@ -212,3 +222,35 @@ 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.
 ```
+
+## Just Enough Items
+
+The Recipes settings icon is from [Just Enough Items 31.17.0.108](https://github.com/mezz/JustEnoughItems) by mezz and contributors. It is distributed under the MIT license in `crates/horizon-client-render/src/jei_recipes/LICENSE.txt`.
+
+## Flywheel native model directional shading
+
+The two-light diffuse expression and transformed-normal policy in
+`terrain.wgsl`'s native model entries follow Flywheel 1.0.6
+(`internal/diffuse.glsl`, `instance/transformed.vert`, `internal/common.vert`).
+No Flywheel classes, compiled shaders or original model/texture assets are bundled.
+
+Copyright (c) 2021-2024 Jozufozu
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+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.
@@ -3,7 +3,7 @@ name = "cargo-horizon-mod"
 version = "0.1.0"
 edition.workspace = true
 license.workspace = true
-rust-version = "1.86"
+rust-version.workspace = true
 description = "cargo horizon-mod new/build/run/check: make Horizon content mods (docs/mods.md)"

 # `cargo binstall --git https://github.com/horizon-rust/horizon cargo-horizon-mod` (#2120) reads this: the archive
@@ -3,7 +3,7 @@ name = "horizon-anticheat"
 version = "0.1.0"
 edition.workspace = true
 license.workspace = true
-rust-version = "1.85"
+rust-version.workspace = true
 description = "The dedicated server's anticheat: its [anticheat] settings, violation levels and the checks' rules, with no game state (docs/anticheat.md)"

 [dependencies]
@@ -34,7 +34,10 @@ pub fn element(v: &Element) -> Value {
        .collect();
    json!({"from":bits(v.from),"to":bits(v.to),"faces":faces,"rotation":v.rotation.as_ref().map(rotation),"shade":v.shade_direction_override.map(Direction::name),"light":v.light_emission})
 }
-#[allow(dead_code)] // Shared by fixtures which normalize different model stages.
+#[allow(
+    dead_code,
+    reason = "shared by fixtures which normalize different model stages"
+)]
 pub fn model(v: &CuboidModel) -> Value {
    let textures: BTreeMap<_, _> = v
        .textures
@@ -34,6 +34,8 @@ pub struct ModelQuad {
 /// NeoForge's `render_type` names.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum RenderType {
+    /// A declared render type unknown to this baker; distinct from an absent default.
+    Unsupported,
    Solid,
    Cutout,
    CutoutMipped,
@@ -234,7 +236,10 @@ fn bake_into(
    skip_flat: bool,
    output: &mut Vec<ModelQuad>,
 ) -> Result<()> {
-    let render_type = model.render_type.as_deref().and_then(RenderType::by_name);
+    let render_type = model
+        .render_type
+        .as_deref()
+        .map(|name| RenderType::by_name(name).unwrap_or(RenderType::Unsupported));
    for element in model.elements() {
        let element = element
            .as_ref()
@@ -292,7 +297,10 @@ fn bake_obj(
    transform: BlockModelTransform,
    output: &mut Vec<ModelQuad>,
 ) -> Result<()> {
-    let render_type = model.render_type.as_deref().and_then(RenderType::by_name);
+    let render_type = model
+        .render_type
+        .as_deref()
+        .map(|name| RenderType::by_name(name).unwrap_or(RenderType::Unsupported));
    for face in obj.faces.iter().filter(|f| !hidden.contains(&f.object)) {
        let slot = match obj.materials.get(&face.material) {
            Some(MtlTexture::Sprite(sprite)) => {
@@ -179,19 +179,19 @@ impl Condition {
        let fields = object(raw)?;
        if fields.len() == 1 {
            for name in ["OR", "AND"] {
-                if let Some(raw) = fields.get(name) {
-                    if let Ok(values) = array(raw).and_then(|values| {
+                if let Some(raw) = fields.get(name)
+                    && let Ok(values) = array(raw).and_then(|values| {
                        values
                            .into_iter()
                            .map(Self::decode)
                            .collect::<Result<Vec<_>>>()
-                    }) {
-                        return Ok(if name == "OR" {
-                            Self::Or(values)
-                        } else {
-                            Self::And(values)
-                        });
-                    }
+                    })
+                {
+                    return Ok(if name == "OR" {
+                        Self::Or(values)
+                    } else {
+                        Self::And(values)
+                    });
                }
            }
        }
@@ -777,6 +777,23 @@ mod tests {
        );
    }
    #[test]
+    fn an_unknown_declared_render_type_remains_distinct_from_absent() {
+        let json = LIGHTS.replace("minecraft:cutout", "fixture:custom_material");
+        let library = library(&[("block/custom", &json)]);
+        let model = library.resolve("block/custom").unwrap();
+        let quads = crate::bake::bake_block_model(
+            &model,
+            crate::bake::BlockModelTransform::new([0; 3], false),
+        )
+        .unwrap();
+        assert!(!quads.is_empty());
+        assert!(
+            quads
+                .iter()
+                .all(|q| q.render_type == Some(crate::bake::RenderType::Unsupported))
+        );
+    }
+    #[test]
    fn render_type_comes_from_the_leaf_most_model_and_loses_its_prefix() {
        let library = library(&[
            ("block/base", r#"{"render_type":"translucent"}"#),
@@ -2,6 +2,7 @@
 name = "horizon-bench"
 version = "0.1.0"
 edition = "2021"
+rust-version.workspace = true
 license = "MIT"
 description = "The benchmark report format (docs/benchmark-report.md), shared by the game, the launcher and the upload"

@@ -90,6 +90,9 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
  --seed N               default 12345
  --explore-speed B      blocks a second an explore bot flies; default 22 (as fast as chunks come)
  --pvp B                fight bots also attack each other (true or false); default true
+  --crits                fight bots swing at a sword's full strength (every 13 ticks) and jump into every
+                         other swing, landing it while falling: a critical hit, then a sweep from the
+                         ground (give them swords); for PvP benches (crit and sweep particles)
  --name PREFIX          bot names: PREFIX0, PREFIX1...; default Bot
  --brand B              the client brand sent in configuration (minecraft:brand); default none
  --height H             blocks above spawn the bots fly at (walk, explore, idle); default 24
@@ -165,6 +168,8 @@ struct Options {
    attack_after: f64,
    attack_rounds: u32,
    no_swing: bool,
+    /// --crits: fight bots alternate jumped critical hits and sweeps at a sword's cooldown.
+    crits: bool,
    flood: usize,
    no_read: bool,
    no_loaded: bool,
@@ -202,6 +207,7 @@ fn options() -> Result<Options, String> {
        attack_after: 5.0,
        attack_rounds: u32::MAX,
        no_swing: false,
+        crits: false,
        flood: 100,
        no_read: false,
        no_loaded: false,
@@ -230,6 +236,10 @@ fn options() -> Result<Options, String> {
            o.no_swing = true;
            continue;
        }
+        if arg == "--crits" {
+            o.crits = true;
+            continue;
+        }
        if arg == "--no-loaded" {
            o.no_loaded = true;
            continue;
@@ -532,11 +542,84 @@ fn distance(a: [f64; 3], b: [f64; 3]) -> f64 {
    ((a[0] - b[0]).powi(2) + (a[1] - b[1]).powi(2) + (a[2] - b[2]).powi(2)).sqrt()
 }

+/// A sword's attack speed is 1.6 a second: full strength 20 / 1.6 = 12.5 ticks after a swing.
+const SWORD_COOLDOWN_TICKS: u32 = 13;
+/// `LivingEntity.getJumpPower`: a jump's first upward motion, in blocks a tick.
+const JUMP_POWER: f64 = 0.42;
+
+/// `--crits`: a fight bot that swings at a sword's full strength and jumps into every other swing, so
+/// it lands while falling (`Player.attack`'s critical hit: falling, not on the ground, full strength),
+/// and the next one from the ground (a sweep: on the ground, full strength, a sword).
+#[derive(Default)]
+struct Crits {
+    /// Vertical motion while in the air (`LivingEntity.travel`: minus 0.08 a tick, times 0.98).
+    jump: Option<f64>,
+    ground: f64,
+    /// The next swing is the jumped one.
+    crit_next: bool,
+}
+
+impl Crits {
+    fn airborne(&self) -> bool {
+        self.jump.is_some()
+    }
+
+    /// One tick: walk up to the target and, with a full cooldown, strike; jump ahead of a crit's swing.
+    fn tick(
+        &mut self,
+        pos: &mut [f64; 3],
+        target: (i32, [f64; 3]),
+        since: &mut u32,
+    ) -> Option<i32> {
+        if let Some(v) = self.jump {
+            pos[1] += v;
+            if pos[1] <= self.ground {
+                pos[1] = self.ground;
+                self.jump = None;
+            } else {
+                self.jump = Some((v - 0.08) * 0.98);
+            }
+        } else {
+            self.ground = pos[1];
+            // A jump takes 6 ticks to its top: start it so the cooldown ends on the way down.
+            if self.crit_next && *since + 8 >= SWORD_COOLDOWN_TICKS {
+                self.jump = Some(JUMP_POWER);
+            }
+        }
+        let falling = self.jump.is_some_and(|v| v < 0.0);
+        if self.crit_next && !falling {
+            *since = since.saturating_add(1);
+            fight_step(pos, target.1);
+            return None;
+        }
+        let hit = fight_tick(pos, target, since, SWORD_COOLDOWN_TICKS);
+        if hit.is_some() {
+            self.crit_next = !self.crit_next;
+        }
+        hit
+    }
+}
+
 /// One tick of a fighting bot with a target: walk up to it, and strike once the cooldown is over.
 /// Returns the entity to attack. `since_attack` counts ticks since the last swing.
-fn fight_tick(pos: &mut [f64; 3], target: (i32, [f64; 3]), since_attack: &mut u32) -> Option<i32> {
+fn fight_tick(
+    pos: &mut [f64; 3],
+    target: (i32, [f64; 3]),
+    since_attack: &mut u32,
+    cooldown: u32,
+) -> Option<i32> {
    *since_attack = since_attack.saturating_add(1);
    let (id, at) = target;
+    fight_step(pos, at);
+    if *since_attack >= cooldown && distance(*pos, at) <= ATTACK_REACH {
+        *since_attack = 0;
+        return Some(id);
+    }
+    None
+}
+
+/// Walk toward `at`, stopping `CLOSE_IN` short of it.
+fn fight_step(pos: &mut [f64; 3], at: [f64; 3]) {
    let (dx, dz) = (at[0] - pos[0], at[2] - pos[2]);
    let horizontal = dx.hypot(dz);
    if horizontal > CLOSE_IN {
@@ -544,11 +627,6 @@ fn fight_tick(pos: &mut [f64; 3], target: (i32, [f64; 3]), since_attack: &mut u3
        pos[0] += dx / horizontal * step;
        pos[2] += dz / horizontal * step;
    }
-    if *since_attack >= ATTACK_COOLDOWN_TICKS && distance(*pos, at) <= ATTACK_REACH {
-        *since_attack = 0;
-        return Some(id);
-    }
-    None
 }

 /// One tick of walking to random points around the spawn, at sprint speed (5.6 blocks a second).
@@ -616,7 +694,7 @@ fn costly(
        Behaviour::FloodUse => {
            // A block within reach: place stone there, or break what is there.
            let at = [0, 1, 2].map(|k| block[k] + (random.unit() * 7.0) as i32 - 3);
-            if i % 2 == 0 {
+            if i.is_multiple_of(2) {
                play::Serverbound::UseItemOn(play::UseItemOn {
                    hand: 0,
                    pos: at,
@@ -645,7 +723,7 @@ fn costly(
            carried: None,
        }),
        Behaviour::FloodSuggest => {
-            let text = if i % 2 == 0 {
+            let text = if i.is_multiple_of(2) {
                "/"
            } else {
                LONG_COMMAND.as_str()
@@ -1124,6 +1202,7 @@ fn run_bot(
        spawn[1] + o.height
    };
    let mut since_attack = ATTACK_COOLDOWN_TICKS;
+    let mut crits = Crits::default();
    let heading = random.unit() * std::f64::consts::TAU;
    let mut target = pos;
    let mut next = Instant::now();
@@ -1181,11 +1260,16 @@ fn run_bot(
                Behaviour::Fight => {
                    let near = lock(&bot.entities).nearest(pos, o.pvp, &bots);
                    if let Some(near) = near {
-                        if let Some(victim) = fight_tick(&mut pos, near, &mut since_attack) {
+                        let hit = if o.crits {
+                            crits.tick(&mut pos, near, &mut since_attack)
+                        } else {
+                            fight_tick(&mut pos, near, &mut since_attack, ATTACK_COOLDOWN_TICKS)
+                        };
+                        if let Some(victim) = hit {
                            // The client sends the attack, then swings the arm.
                            let sent = send(
                                play::Serverbound::Attack(play::Attack { id: victim }).encode(),
-                            ) && send(raw(sb::PUNCH, |w| w.varint(0)));
+                            ) && send(play::Serverbound::Punch(Empty).encode());
                            if sent {
                                bot.attacks.fetch_add(1, Ordering::Relaxed);
                            }
@@ -1300,9 +1384,10 @@ fn run_bot(
                x: pos[0],
                y: pos[1],
                z: pos[2],
-                // Fight bots stand on the ground; the others fly.
+                // Fight bots stand on the ground (but in a --crits jump); the others fly.
                flags: u8::from(
-                    matches!(behaviour, Behaviour::Fight | Behaviour::Stand) || o.ground,
+                    (matches!(behaviour, Behaviour::Fight | Behaviour::Stand) && !crits.airborne())
+                        || o.ground,
                ),
            })
            .encode(),
@@ -1470,10 +1555,10 @@ fn main() {
    });
    if o.report.as_deref() == Some("-") {
        println!("{summary:#}");
-    } else if let Some(path) = &o.report {
-        if let Err(e) = std::fs::write(path, format!("{summary:#}\n")) {
-            eprintln!("horizon-bots: {path}: {e}");
-        }
+    } else if let Some(path) = &o.report
+        && let Err(e) = std::fs::write(path, format!("{summary:#}\n"))
+    {
+        eprintln!("horizon-bots: {path}: {e}");
    }
    let errors: Vec<String> = bots
        .iter()
@@ -1600,7 +1685,9 @@ mod tests {
        let target = (3, [1.0, 64.0, 0.0]);
        let mut since = ATTACK_COOLDOWN_TICKS;
        let hits: Vec<u32> = (0..40)
-            .filter_map(|tick| fight_tick(&mut pos, target, &mut since).map(|_| tick))
+            .filter_map(|tick| {
+                fight_tick(&mut pos, target, &mut since, ATTACK_COOLDOWN_TICKS).map(|_| tick)
+            })
            .collect();
        assert_eq!(hits[0], 0, "a bot in reach strikes at once");
        assert!(
@@ -1617,7 +1704,7 @@ mod tests {
        let mut since = ATTACK_COOLDOWN_TICKS;
        let mut first = None;
        for tick in 0..100 {
-            if fight_tick(&mut pos, target, &mut since).is_some() {
+            if fight_tick(&mut pos, target, &mut since, ATTACK_COOLDOWN_TICKS).is_some() {
                first = Some(tick);
                break;
            }
@@ -1627,6 +1714,43 @@ mod tests {
        assert!(pos[0] < 10.0 - CLOSE_IN + 1e-9);
    }

+    #[test]
+    fn crits_alternate_a_falling_swing_and_a_grounded_one() {
+        let mut pos = [0.0, 64.0, 0.0];
+        let target = (3, [1.0, 64.0, 0.0]);
+        let (mut since, mut crits) = (SWORD_COOLDOWN_TICKS, Crits::default());
+        let mut last_y = pos[1];
+        let mut hits = Vec::new();
+        for tick in 0..120u32 {
+            let hit = crits.tick(&mut pos, target, &mut since);
+            if hit.is_some() {
+                hits.push((tick, crits_state(pos[1], last_y)));
+            }
+            last_y = pos[1];
+        }
+        assert!(hits.len() >= 6, "{hits:?}");
+        for (i, w) in hits.windows(2).enumerate() {
+            assert!(
+                w[1].0 - w[0].0 >= SWORD_COOLDOWN_TICKS,
+                "full strength each time: {hits:?}"
+            );
+            assert_ne!(w[0].1, w[1].1, "swing {i} and the next alternate: {hits:?}");
+        }
+        // A crit lands in the air, on the way down; a sweep from the ground.
+        assert!(hits.iter().any(|h| h.1 == "falling") && hits.iter().any(|h| h.1 == "ground"));
+        assert!(pos[1] >= 64.0);
+    }
+
+    fn crits_state(y: f64, before: f64) -> &'static str {
+        if y == 64.0 {
+            "ground"
+        } else if y < before {
+            "falling"
+        } else {
+            "rising"
+        }
+    }
+
    #[test]
    fn percentiles_use_nearest_rank() {
        assert_eq!(percentile(&[], 50), 0);
@@ -3,7 +3,7 @@ name = "horizon-chat-filter"
 version = "0.1.0"
 edition.workspace = true
 license.workspace = true
-rust-version = "1.88"
+rust-version.workspace = true
 description = "The dedicated server's chat filter: its [chat_filter] settings, the slur list's matcher and the mutes, with no game state (docs/chat-filter.md)"

 [dependencies]
@@ -3,7 +3,7 @@ name = "horizon-client-core"
 version = "0.1.0"
 edition.workspace = true
 license.workspace = true
-rust-version = "1.90"
+rust-version.workspace = true
 description = "The client's lowest layer: chat text and translations, SNBT and NBT paths, the scoreboard, boss bars, game rules and the registry and particle tables commands name"

 [dependencies]
@@ -275,6 +275,25 @@ impl Registries {
                .clone_from(&e.advancement_criteria);
        }
    }
+    /// Add the damage catalog's types ([`Self::damage_types`]: content mods'
+    /// and the world's packs' with vanilla's) to the commands'
+    /// `minecraft:damage_type` ids, which the export lists for vanilla alone.
+    /// `ResourceArgument` looks a type up in the server's registries, so
+    /// `/damage` takes every type the world has. The export's tags stay. The
+    /// ids are replaced, not extended: `by_registry` outlives a world, and a
+    /// pack's type must not stay accepted in the next world opened.
+    pub fn sync_damage_type_ids(&mut self) {
+        if self.damage_types.is_empty() {
+            return;
+        }
+        let mut ids = self.damage_types.clone();
+        ids.sort();
+        ids.dedup();
+        self.by_registry
+            .entry("minecraft:damage_type".into())
+            .or_default()
+            .ids = ids;
+    }
    /// The element ids of a registry (sorted).
    pub fn ids(&self, registry: &str) -> &[String] {
        if let Some(r) = self.by_registry.get(registry) {
@@ -312,3 +331,49 @@ impl Registries {
        }
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Registries;
+
+    /// A content mod's damage type joins vanilla's in the commands' ids, the
+    /// export's tags stay, and a second world open lists each type once.
+    #[test]
+    fn damage_type_ids_take_the_catalogs_types() {
+        let export = Registries::from_export(&serde_json::json!({
+            "by_registry": {"minecraft:damage_type": {
+                "ids": ["minecraft:fall", "minecraft:magic"],
+                "tags": ["minecraft:is_fall"],
+            }},
+        }));
+        let mut reg = Registries {
+            damage_types: vec![
+                "minecraft:magic".into(),
+                "example:test".into(),
+                "minecraft:fall".into(),
+            ],
+            ..Registries::default()
+        };
+        reg.fill_from_exported(&export);
+        assert_eq!(
+            reg.ids("minecraft:damage_type"),
+            ["minecraft:fall", "minecraft:magic"],
+            "the export alone lists vanilla's types"
+        );
+        for _ in 0..2 {
+            reg.sync_damage_type_ids();
+            assert_eq!(
+                reg.ids("minecraft:damage_type"),
+                ["example:test", "minecraft:fall", "minecraft:magic"]
+            );
+            assert_eq!(reg.tags("minecraft:damage_type"), ["minecraft:is_fall"]);
+        }
+        // The next world, without the pack: its type is no longer accepted.
+        reg.damage_types = vec!["minecraft:fall".into(), "minecraft:magic".into()];
+        reg.sync_damage_type_ids();
+        assert_eq!(
+            reg.ids("minecraft:damage_type"),
+            ["minecraft:fall", "minecraft:magic"]
+        );
+    }
+}
@@ -3,7 +3,7 @@ name = "horizon-client-input"
 version = "0.1.0"
 edition.workspace = true
 license.workspace = true
-rust-version = "1.90"
+rust-version.workspace = true
 description = "The client's input layer: key bindings and their names, mouse, controllers, clipboard and window options"

 [dependencies]
@@ -393,38 +393,17 @@ impl FullscreenState {
        let reapply = self.set_exclusive(exclusive);
        self.set_preferred_mode(preferred);
        let mode_change = !in_video_screen && self.take_mode_change();
-        if wanted && window.is_maximized() {
-            window.set_maximized(false);
-            window.set_fullscreen(Some(fullscreen_request(
+        match request {
+            Some(false) => window.set_fullscreen(None),
+            Some(true) => enter_fullscreen(
                window,
-                exclusive,
-                preferred.as_ref(),
-            )));
-        } else {
-            match request {
-                Some(false) => window.set_fullscreen(None),
-                Some(true) => {
-                    if window.is_maximized() {
-                        window.set_maximized(false);
-                    }
-                    window.set_fullscreen(Some(fullscreen_request(
-                        window,
-                        exclusive,
-                        preferred.as_ref(),
-                    )));
-                }
-                None if reapply || mode_change => {
-                    if window.is_maximized() {
-                        window.set_maximized(false);
-                    }
-                    window.set_fullscreen(Some(fullscreen_request(
-                        window,
-                        exclusive,
-                        preferred.as_ref(),
-                    )));
-                }
-                None => {}
-            }
+                fullscreen_request(window, exclusive, preferred.as_ref()),
+            ),
+            None if reapply || mode_change => enter_fullscreen(
+                window,
+                fullscreen_request(window, exclusive, preferred.as_ref()),
+            ),
+            None => {}
        }
    }

@@ -602,6 +581,34 @@ fn monitor_current_mode(
        .max_by_key(|m| (m.refresh_rate_millihertz(), m.bit_depth()))
 }

+/// `window.set_fullscreen(Some(fullscreen))`. On Windows a maximized window leaves its maximized
+/// state first: winit keeps a maximized window's client area inside the work area, so a
+/// borderless fullscreen kept the taskbar over its bottom and pushed its top off screen (#9984).
+pub fn enter_fullscreen(window: &winit::window::Window, fullscreen: winit::window::Fullscreen) {
+    #[cfg(target_os = "windows")]
+    if window.is_maximized() {
+        window.set_maximized(false);
+    }
+    window.set_fullscreen(Some(fullscreen));
+}
+
+/// Borderless fullscreen on the window's own monitor (the primary one when it has none).
+pub fn borderless_fullscreen(window: &winit::window::Window) -> winit::window::Fullscreen {
+    winit::window::Fullscreen::Borderless(
+        window
+            .current_monitor()
+            .or_else(|| window.primary_monitor()),
+    )
+}
+
+/// A window created fullscreen that the system also marked maximized enters it again
+/// unmaximized ([`enter_fullscreen`]); only Windows does that.
+pub fn settle_created_fullscreen(window: &winit::window::Window, fullscreen: bool) {
+    if cfg!(target_os = "windows") && fullscreen && window.is_maximized() {
+        enter_fullscreen(window, borderless_fullscreen(window));
+    }
+}
+
 /// `Window.applyFullscreen`: the fullscreen the window asks for. Exclusive fullscreen takes
 /// `Monitor.getPreferredVideoMode` (the preferred mode if the monitor has it, else the desktop
 /// mode); a monitor with no usable mode falls back to borderless, as vanilla does.
@@ -6,7 +6,7 @@ autotests = false
 version = "0.1.0"
 edition.workspace = true
 license.workspace = true
-rust-version = "1.90"
+rust-version.workspace = true
 description = "Reusable client systems, control tool and parity probes"

 [lib]
@@ -76,6 +76,7 @@ horizon-theme = { path = "../horizon-theme" }
 # the anonymous "I'm playing" ping the game sends itself (`heartbeat.rs`).
 horizon-telemetry = { path = "../horizon-telemetry", default-features = false, features = ["live"] }
 horizon-bench = { path = "../horizon-bench" }
+crc32fast = "1"
 zip = { version = "9.1.3", default-features = false, features = ["deflate"] }
 # Controllers (evdev + libudev on Linux, IOKit on macOS, Windows.Gaming.Input); the `controllers` feature.
 gilrs = { version = "0.11", optional = true }
@@ -3,7 +3,7 @@ name = "horizon-client-render"
 version = "0.1.0"
 edition.workspace = true
 license.workspace = true
-rust-version = "1.90"
+rust-version.workspace = true
 description = "The client's world data, rendering and screens: chunks, meshing, light, streaming, the renderer, the HUD, menus and settings; no gameplay"

 [dependencies]
@@ -0,0 +1,55 @@
+//! Headless production brewing-fuel component fixture.
+use horizon_client_render::{
+    brewing::{Brewing, BrewingStand, brewing_fuel},
+    providers::Providers,
+};
+use horizon_items::{
+    item_data::decode_components,
+    items::{ItemStack, Items},
+};
+use horizon_world::loot::PackOverlay;
+use std::{
+    io::{BufRead, Write},
+    path::Path,
+};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = std::env::args().collect();
+    let root = Path::new(&args[1]);
+    let items = Items::catalog(root, &PackOverlay::NONE)?;
+    let providers = Providers::load(root);
+    let brewing = Brewing {
+        recipes: vec![],
+        reagents: Default::default(),
+        inputs: Default::default(),
+    };
+    let mut out = std::io::BufWriter::new(std::fs::File::create(&args[3])?);
+    for line in std::io::BufReader::new(std::fs::File::open(&args[2])?).lines() {
+        let input: serde_json::Value = serde_json::from_str(&line?)?;
+        let mut stack = ItemStack::new(
+            input["item"].as_str().unwrap(),
+            input["count"].as_u64().unwrap() as u32,
+        );
+        let components = horizon_client_core::scoreboard::json_to_tag(&input["components"]);
+        let (_, extra) = decode_components(Some(&components));
+        stack.extra = extra;
+        let accepted = brewing_fuel(&items, &stack).is_some();
+        let mut stand = BrewingStand::new();
+        // A newly constructed vanilla block entity has no saved total yet.
+        stand.total_fuel = 0;
+        stand.items[4] = Some(stack);
+        for _ in 0..2 {
+            stand.tick(&brewing, &items, &providers);
+            writeln!(
+                out,
+                "{} {} {} {} {}",
+                accepted,
+                stand.fuel,
+                stand.total_fuel,
+                stand.speed.to_bits(),
+                stand.items[4].as_ref().map_or(0, |s| s.count)
+            )?;
+        }
+    }
+    Ok(())
+}
@@ -66,6 +66,8 @@ fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
        false,
        false,
        true,
+        false,
+        false,
    ))?;
    assert!(!renderer.pack_entity_shadows(), "no selected pack");
    renderer.set_shader_pack(0, None, &[]).unwrap();
@@ -224,6 +224,8 @@ fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
        settings.translucent_batching,
        false,
        false,
+        false,
+        false,
    ))?;
    drop(pixels);
    render.pixels.pack();
@@ -126,6 +126,8 @@ fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
        false,
        false,
        true,
+        false,
+        false,
    ))?;
    renderer.resize(320, 180);
    assert!(
@@ -348,6 +350,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        skybox: false,
        end_sky: false,
        end_sky_sprite: None,
+        boss_world_fog: false,
        environment_fog: None,
        water_fog: [0.0; 3],
        fog: None,
@@ -368,6 +371,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        visible_static_block_entity_sections: &[],
        static_block_entity_stats: Default::default(),
        entity_motion: &[],
+        entity_motion_posed: &[],
        entity_spans: &[],
        skin: None,
        glowing: &[],
@@ -261,6 +261,40 @@ pub struct Audio {
    /// Ticks since the output devices were last looked at (`DeviceTracker.tick`).
    #[cfg(feature = "audio")]
    device_ticks: u32,
+    /// The look at the output devices running on its own thread, until a tick
+    /// takes its answer: listing them can take 100 ms (#11490).
+    #[cfg(feature = "audio")]
+    device_probe: Option<PendingProbe>,
+}
+/// What one look at the output devices found: the system default, the
+/// fingerprint, and the device list when those say it may have changed.
+#[cfg(feature = "audio")]
+struct DeviceProbe {
+    default: Option<String>,
+    cards: Option<String>,
+    devices: Option<Vec<String>>,
+}
+#[cfg(feature = "audio")]
+type PendingProbe = Arc<Mutex<Option<DeviceProbe>>>;
+/// Looks at the output devices as `should_change_device` did on the render
+/// thread: the device list only when the default or the fingerprint moved.
+#[cfg(feature = "audio")]
+fn probe_devices(default_seen: Option<String>, cards_seen: Option<String>) -> DeviceProbe {
+    let default = default_output_name();
+    let cards = card_fingerprint();
+    // Listing the devices probes every one (on Linux every built-in PCM,
+    // printing ALSA's errors for the plugins this system lacks; on macOS
+    // every Core Audio device, about 90 ms with twenty of them; on Windows
+    // every endpoint, with no fingerprint to skip it); only the fingerprint's
+    // devices can change the list, and it is cheap.
+    let devices = (default != default_seen
+        || cards_changed(cards_seen.as_deref(), cards.as_deref()))
+    .then(output_devices);
+    DeviceProbe {
+        default,
+        cards,
+        devices,
+    }
 }
 fn decode(path: &Path) -> Option<(Vec<f32>, u32, u16)> {
    use symphonia::core::{
@@ -1051,6 +1085,8 @@ impl Audio {
            devices_seen: devices,
            #[cfg(feature = "audio")]
            device_ticks: 0,
+            #[cfg(feature = "audio")]
+            device_probe: None,
        }
    }
    #[cfg(not(feature = "audio"))]
@@ -1211,6 +1247,8 @@ impl Audio {
            devices_seen: self.devices_seen.clone(),
            #[cfg(feature = "audio")]
            device_ticks: 0,
+            #[cfg(feature = "audio")]
+            device_probe: None,
        }
    }
    /// Sync the volume options, refreshing the categories that changed
@@ -1232,7 +1270,8 @@ impl Audio {
    /// `SoundEngine.shouldChangeDevice`: the open device was lost, the system
    /// default changed (with no device chosen in the options), or the chosen
    /// device came back; the output is then opened again. The devices are looked
-    /// at once a second.
+    /// at once a second, on a thread of their own: a later tick reads what it
+    /// found.
    #[cfg(feature = "audio")]
    fn should_change_device(&mut self) -> bool {
        // A splitscreen share plays through the first player's output: it leaves the device,
@@ -1246,29 +1285,54 @@ impl Audio {
        };
        if lost {
            log::info!("Horizon: audio device was lost");
+            self.device_probe = None;
            self.default_seen = default_output_name();
            self.cards_seen = card_fingerprint();
            self.devices_seen = output_devices();
            return true;
        }
+        if let Some(pending) = &self.device_probe {
+            let Some(probe) = pending.lock().ok().and_then(|mut found| found.take()) else {
+                return false;
+            };
+            self.device_probe = None;
+            return self.devices_changed(probe, current);
+        }
        self.device_ticks += 1;
        if self._stream.is_none() || self.device_ticks < 20 {
            return false;
        }
        self.device_ticks = 0;
-        let default = default_output_name();
-        let cards = card_fingerprint();
-        // Listing the devices probes every one (on Linux every built-in PCM,
-        // printing ALSA's errors for the plugins this system lacks; on macOS
-        // every Core Audio device, about 90 ms with twenty of them); only the
-        // fingerprint's devices can change the list, and it is cheap.
-        if default == self.default_seen
-            && !cards_changed(self.cards_seen.as_deref(), cards.as_deref())
-        {
-            return false;
+        let pending = PendingProbe::default();
+        let out = Arc::clone(&pending);
+        let seen = (self.default_seen.clone(), self.cards_seen.clone());
+        let started = std::thread::Builder::new()
+            .name("audio-devices".into())
+            .spawn(move || {
+                let probe = probe_devices(seen.0, seen.1);
+                if let Ok(mut found) = out.lock() {
+                    *found = Some(probe);
+                }
+            });
+        match started {
+            Ok(_) => self.device_probe = Some(pending),
+            Err(e) => log::warn!("Horizon: could not look at the audio devices: {e}"),
        }
+        false
+    }
+    /// The rest of `shouldChangeDevice` with what a look at the devices found,
+    /// `current` being the device playing now.
+    #[cfg(feature = "audio")]
+    fn devices_changed(&mut self, probe: DeviceProbe, current: String) -> bool {
+        let DeviceProbe {
+            default,
+            cards,
+            devices,
+        } = probe;
+        let Some(devices) = devices else {
+            return false;
+        };
        self.cards_seen = cards;
-        let devices = output_devices();
        // Only a change in the device lists is looked at, as in vanilla: a
        // preferred device that is listed but cannot open is not retried.
        if default == self.default_seen && devices == self.devices_seen {
@@ -538,6 +538,11 @@ impl BlockEntities {
        });
        Arc::clone(&self.tickers)
    }
+    /// How many block entities tick (`Level.blockEntityTickers`, the slots still live), as of
+    /// the last [`Self::tickers`]: what a diagnostics mod counts.
+    pub fn ticking_len(&self) -> usize {
+        self.live.len()
+    }
    /// Whether a slot from `tickers` still ticks.
    pub fn is_live(&self, (pos, slot): (Pos, u32)) -> bool {
        self.live.get(&pos) == Some(&slot) && self.map.contains_key(&pos)
@@ -0,0 +1,249 @@
+//! Every block state's facts and looks by its id, for a client mod drawing blocks or a map off the main thread
+//! (`native_block_states`; docs/native-mods.md): what the game knows of each state, what its model draws on each side
+//! and the texture behind each of those sprites. A copy, so the game's own tables can change shape under it.
+use crate::{
+    block_sprites::{BlockSprites, Lookup, SpriteRef},
+    streaming::WorkerContext,
+};
+use horizon_items::blocks::{BlockFacts, MAP_COLORS, RenderShape};
+use horizon_world::{
+    block_collision::BlockCollisionRegistry, fluid::FluidState, registry::BlockStateId,
+};
+use std::{collections::HashMap, sync::Arc};
+
+/// What one block state is, as a renderer or a map reads it.
+#[derive(Clone, Debug, PartialEq)]
+#[non_exhaustive]
+pub struct BlockStateFacts {
+    /// Its block, without properties (`minecraft:grass_block`).
+    pub name: Arc<str>,
+    /// `BlockState.isAir`: air, cave air or void air.
+    pub air: bool,
+    /// No model draws it (render shape `INVISIBLE`): air, barriers, light, and water and lava, drawn as fluids.
+    pub invisible: bool,
+    /// `BlockState.getFluidState`: the fluid in it, a waterlogged block's and kelp's included; empty for none.
+    pub fluid: FluidState,
+    /// Its `waterlogged` property is true.
+    pub waterlogged: bool,
+    /// The light it gives, 0 to 15.
+    pub emission: u8,
+    /// `BlockState.getShape`, the outline the cursor picks, as block-local boxes
+    /// `[min_x, min_y, min_z, max_x, max_y, max_z]`: `[0, 0, 0, 1, 1, 1]` for a whole block, none for air. Without
+    /// the random offset of flowers and grass.
+    pub outline: Arc<[[f64; 6]]>,
+    /// `MapColor.col` (`0xRRGGBB`), its colour on a vanilla map; none for `MapColor.NONE`, which maps leave out.
+    pub map_color: Option<u32>,
+    /// It can collide at all: false for a state whose collision shape is always empty (air, flowers, water).
+    pub collides: bool,
+}
+
+// A mod builds its tables from these on a worker thread.
+const _: () = {
+    const fn shareable<T: Send + Sync + 'static>() {}
+    shareable::<BlockStates>()
+};
+
+/// Every block state by its id: its facts, and what its model draws with the resources loaded when it was made.
+#[derive(Clone)]
+pub struct BlockStates {
+    states: Arc<[BlockStateFacts]>,
+    context: Arc<WorkerContext>,
+    /// Texture names by sprite layer, across every array.
+    textures: Arc<HashMap<u32, String>>,
+    split: u32,
+}
+
+impl BlockStates {
+    /// The states of `context`'s registry, with their `facts` and `collision`, and the sprites of `context`'s
+    /// resources at `split` layers to an array (`Renderer::sprite_split`).
+    pub fn new(
+        facts: &BlockFacts,
+        collision: &BlockCollisionRegistry<'_>,
+        context: Arc<WorkerContext>,
+        split: u32,
+    ) -> Self {
+        let registry = context.assets.registry;
+        let states = facts
+            .states
+            .iter()
+            .enumerate()
+            .map(|(i, f)| {
+                let id = BlockStateId(i as u32);
+                BlockStateFacts {
+                    name: f.name.clone(),
+                    air: facts.is_air(id),
+                    invisible: f.render_shape == RenderShape::Invisible,
+                    fluid: registry
+                        .state(id)
+                        .and_then(|state| FluidState::from_block(state).ok())
+                        .unwrap_or(FluidState::EMPTY),
+                    waterlogged: f.waterlogged,
+                    emission: f.emission,
+                    outline: f.outline.clone(),
+                    map_color: MAP_COLORS
+                        .get(usize::from(f.map_color))
+                        .copied()
+                        .filter(|_| f.map_color != 0),
+                    collides: collision.may_collide(id),
+                }
+            })
+            .collect();
+        // Vanilla's names go without their namespace, as `native_draw_cube` takes them.
+        let textures = context
+            .render
+            .sprite_layers
+            .iter()
+            .map(|(name, layer)| (*layer, name.trim_start_matches("minecraft:").to_owned()))
+            .collect();
+        Self {
+            states,
+            context,
+            textures: Arc::new(textures),
+            split: split.max(1),
+        }
+    }
+
+    /// How many states there are: their ids run from 0 to one less.
+    pub fn len(&self) -> usize {
+        self.states.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.states.is_empty()
+    }
+
+    /// `state`'s facts; none for an id past the last state.
+    pub fn get(&self, state: BlockStateId) -> Option<&BlockStateFacts> {
+        self.states.get(state.0 as usize)
+    }
+
+    /// Every state with its id, in id order.
+    pub fn iter(&self) -> impl Iterator<Item = (BlockStateId, &BlockStateFacts)> {
+        self.states
+            .iter()
+            .enumerate()
+            .map(|(i, facts)| (BlockStateId(i as u32), facts))
+    }
+
+    /// What `state` draws on each side, as `native_block_sprites` says for a block by name; none for an id past the
+    /// last state.
+    pub fn sprites(&self, state: BlockStateId) -> Option<BlockSprites> {
+        self.get(state)?;
+        Some(Lookup::new(&self.context, self.split).state(state))
+    }
+
+    /// The texture `sprite` shows, by the name `native_texture_sprites` takes (`block/grass_block_top`; a mod's with
+    /// its namespace, `mymod:block/gear`).
+    pub fn texture(&self, sprite: SpriteRef) -> Option<&str> {
+        let layer = sprite
+            .array
+            .checked_mul(self.split)?
+            .checked_add(sprite.layer)?;
+        self.textures.get(&layer).map(String::as_str)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        assets::Assets, biome::Biomes, block_sprites::parse_state, light::LightTables,
+        mesher::MeshTables,
+    };
+    use horizon_assets::model::Direction;
+    use horizon_world::fluid::FluidKind;
+    use std::{path::PathBuf, sync::OnceLock};
+
+    /// Far fewer layers to an array than a GPU takes, so most sprites lie past array 0.
+    const SMALL_SPLIT: u32 = 64;
+
+    /// The game's own states from real prepared resources, loaded once for every test here.
+    fn states() -> &'static BlockStates {
+        static STATES: OnceLock<BlockStates> = OnceLock::new();
+        STATES.get_or_init(|| {
+            let root = PathBuf::from(
+                std::env::var_os("HORIZON_TEST_RESOURCES").expect("HORIZON_TEST_RESOURCES"),
+            );
+            let assets = Arc::new(Assets::load(&root).unwrap());
+            let render = Arc::new(assets.reload(&root).unwrap());
+            let facts = BlockFacts::load(&root, assets.registry).unwrap();
+            let collision = crate::collisions::load(&root, assets.registry).unwrap();
+            let visibility = crate::models::load_visibility(&root, assets.registry).unwrap();
+            let context = Arc::new(WorkerContext {
+                light: Arc::new(LightTables::load(&root, assets.registry, &facts).unwrap()),
+                tables: Arc::new(MeshTables::new(&assets, &render, &facts, visibility).unwrap()),
+                assets: assets.clone(),
+                render,
+                biomes: Arc::new(Biomes::load(&root).unwrap()),
+            });
+            BlockStates::new(&facts, &collision, context, SMALL_SPLIT)
+        })
+    }
+
+    fn facts(text: &str) -> &'static BlockStateFacts {
+        let states = states();
+        let id = parse_state(states.context.assets.registry, text).expect(text);
+        states.get(id).unwrap()
+    }
+
+    #[test]
+    #[ignore = "requires prepared resources in HORIZON_TEST_RESOURCES"]
+    fn a_grass_block_is_a_whole_solid_grass_coloured_block() {
+        let grass = facts("grass_block");
+        assert_eq!(&*grass.name, "minecraft:grass_block");
+        assert!(!grass.air && !grass.invisible && !grass.waterlogged);
+        assert_eq!(grass.fluid.kind(), FluidKind::Empty);
+        assert_eq!(grass.emission, 0);
+        assert_eq!(&*grass.outline, [[0.0, 0.0, 0.0, 1.0, 1.0, 1.0]]);
+        assert_eq!(grass.map_color, Some(0x7F_B238), "MapColor.GRASS");
+        assert!(grass.collides);
+    }
+
+    #[test]
+    #[ignore = "requires prepared resources in HORIZON_TEST_RESOURCES"]
+    fn air_and_light_are_not_drawn() {
+        let air = facts("air");
+        assert!(air.air && air.invisible && !air.collides);
+        assert!(air.outline.is_empty());
+        assert_eq!(air.map_color, None);
+        let light = facts("light[level=15]");
+        assert!(!light.air && light.invisible);
+        assert_eq!(light.emission, 15);
+    }
+
+    #[test]
+    #[ignore = "requires prepared resources in HORIZON_TEST_RESOURCES"]
+    fn a_slabs_outline_is_its_half() {
+        assert_eq!(
+            &*facts("stone_slab[type=bottom]").outline,
+            [[0.0, 0.0, 0.0, 1.0, 0.5, 1.0]]
+        );
+        assert_eq!(
+            &*facts("stone_slab[type=top]").outline,
+            [[0.0, 0.5, 0.0, 1.0, 1.0, 1.0]]
+        );
+        let wet = facts("stone_slab[type=bottom,waterlogged=true]");
+        assert!(wet.waterlogged && wet.collides);
+        assert_eq!(wet.fluid.kind(), FluidKind::Water);
+        assert!(wet.fluid.is_source());
+    }
+
+    #[test]
+    #[ignore = "requires prepared resources in HORIZON_TEST_RESOURCES"]
+    fn a_face_names_its_texture() {
+        let states = states();
+        let id = parse_state(states.context.assets.registry, "grass_block").unwrap();
+        let grass = states.sprites(id).unwrap();
+        let top = grass.sides[Direction::Up as usize][0].sprite;
+        assert_eq!(states.texture(top), Some("block/grass_block_top"));
+        let north = &grass.sides[Direction::North as usize];
+        assert_eq!(
+            states.texture(north[0].sprite),
+            Some("block/grass_block_side")
+        );
+        assert_eq!(
+            states.texture(north[1].sprite),
+            Some("block/grass_block_side_overlay")
+        );
+    }
+}
@@ -114,12 +114,8 @@ mod tests {
            ambient_occlusion: true,
            particle: None,
            cube: None,
-            faces: vec![BakedFace {
-                layer: 0,
-                opaque: true,
-                translucent: false,
-                fusion: None,
-                quad: ModelQuad {
+            faces: vec![BakedFace::new(
+                ModelQuad {
                    positions: [
                        [0.0, 0.5, 0.0],
                        [0.0, 0.5, 1.0],
@@ -142,7 +138,11 @@ mod tests {
                    render_type: None,
                    shade: true,
                },
-            }],
+                0,
+                true,
+                false,
+                None,
+            )],
        }
    }
    #[test]
@@ -387,8 +387,21 @@ impl BrewingStand {
        out.brewed = true;
    }
 }
-/// The `minecraft:brewing_fuel` providers of an item: (uses, speed_multiplier).
+/// `ItemStack.get(BREWING_FUEL)`: the stack's providers (uses, speed_multiplier),
+/// respecting component patches before falling back to the item's defaults.
 pub fn brewing_fuel(items: &Items, stack: &ItemStack) -> Option<(Value, Value)> {
+    if let Some(data) = stack.data() {
+        if data.other("!minecraft:brewing_fuel").is_some() {
+            return None;
+        }
+        if let Some(own) = data.other("minecraft:brewing_fuel") {
+            let component = horizon_client_core::scoreboard::tag_to_json(own);
+            return Some((
+                component["uses"].clone(),
+                component["speed_multiplier"].clone(),
+            ));
+        }
+    }
    items.get(&stack.item).and_then(|i| i.brewing_fuel.clone())
 }

@@ -396,6 +409,50 @@ pub fn brewing_fuel(items: &Items, stack: &ItemStack) -> Option<(Value, Value)>
 mod tests {
    use super::*;

+    #[test]
+    fn stack_fuel_controls_brew_duration_and_consumption() {
+        let items = Items::for_tests(Default::default());
+        let brewing = Brewing {
+            reagents: ["minecraft:nether_wart".to_owned()].into_iter().collect(),
+            inputs: HashSet::new(),
+            recipes: vec![BrewingRecipe {
+                id: "awkward".into(),
+                input: PotionIngredient {
+                    items: ["minecraft:potion".to_owned()].into_iter().collect(),
+                    potions: Some(["minecraft:water".to_owned()].into_iter().collect()),
+                },
+                reagent: PotionIngredient {
+                    items: ["minecraft:nether_wart".to_owned()].into_iter().collect(),
+                    potions: None,
+                },
+                output: ItemStack::new("minecraft:potion", 1).with_potion("minecraft:awkward"),
+            }],
+        };
+        let mut fuel = ItemStack::new("minecraft:stone", 2);
+        fuel.data_mut().set_loot_component(
+            "minecraft:brewing_fuel",
+            &serde_json::json!({"uses": 7, "speed_multiplier": 2.5}),
+        );
+        let mut stand = BrewingStand::new();
+        stand.items[0] = Some(ItemStack::new("minecraft:potion", 1).with_potion("minecraft:water"));
+        stand.items[3] = Some(ItemStack::new("minecraft:nether_wart", 1));
+        stand.items[4] = Some(fuel);
+        let providers = Providers::empty();
+        stand.tick(&brewing, &items, &providers);
+        assert_eq!((stand.brew_time, stand.fuel, stand.total_fuel), (160, 6, 7));
+        assert_eq!(stand.items[4].as_ref().unwrap().count, 1);
+        for _ in 1..160 {
+            assert!(!stand.tick(&brewing, &items, &providers).brewed);
+        }
+        assert!(stand.tick(&brewing, &items, &providers).brewed);
+        assert_eq!(
+            stand.items[0].as_ref().unwrap().potion(),
+            Some("minecraft:awkward")
+        );
+        assert_eq!(stand.fuel, 6);
+        assert_eq!(stand.items[4].as_ref().unwrap().count, 1);
+    }
+
    #[test]
    fn potion_colours_and_names() {
        // Swiftness: speed colour 3402751 = 0x33EBFF.
@@ -1188,11 +1188,27 @@ impl SuggestLayout {
    };
 }

+/// A suggestion accepted by Tab or a click (`SuggestionsList.useSuggestion`).
+#[derive(Debug, PartialEq, Eq)]
+pub struct SuggestionCompletion {
+    /// The suggestion list's original input, also when cycling with Tab.
+    pub original: String,
+    /// The replaced range in `original`, as Java UTF-16 start/end offsets.
+    pub range: (usize, usize),
+    pub text: String,
+    /// The resulting input, after the text field's length limit.
+    pub input: String,
+}
+
 /// The open chat screen: vanilla's `ChatScreen` with its `EditBox` and
 /// `CommandSuggestions` (argument colouring, usage lines, parse errors,
 /// the suggestion list, Tab completion, history).
 pub struct ChatScreen {
    pub input: TextField,
+    /// `ChatScreen.isDraft`: the box opened with the draft saved last time and
+    /// has not been edited since. A draft draws grey italic, and the first
+    /// Backspace clears the whole box instead of one character.
+    is_draft: bool,
    width: i32,
    height: i32,
    history_buffer: String,
@@ -1207,6 +1223,7 @@ pub struct ChatScreen {
    /// the command up to the cursor.
    request: Option<(i32, String)>,
    suggestions: Option<SuggestionList>,
+    completion: Option<SuggestionCompletion>,
    usage: Vec<Text>,
    usage_position: i32,
    usage_width: i32,
@@ -1300,11 +1317,13 @@ fn truncate_utf16(s: &str, max_units: usize) -> String {
    s.to_owned()
 }
 impl ChatScreen {
-    /// `ChatScreen.init`: the input at the bottom, focused, holding `initial`.
+    /// `ChatScreen.init`: the input at the bottom, focused, holding `initial`,
+    /// which is a draft when `is_draft` (`ChatComponent.createScreen`).
    pub fn new(
        m: &Measure,
        c: &Commands,
        initial: &str,
+        is_draft: bool,
        history_len: usize,
        width: i32,
        height: i32,
@@ -1317,6 +1336,7 @@ impl ChatScreen {
        input.set_value(m, initial);
        let mut s = Self {
            input,
+            is_draft,
            width,
            height,
            history_buffer: String::new(),
@@ -1326,6 +1346,7 @@ impl ChatScreen {
            awaiting: None,
            request: None,
            suggestions: None,
+            completion: None,
            usage: Vec::new(),
            usage_position: 0,
            usage_width: 0,
@@ -1353,6 +1374,7 @@ impl ChatScreen {
        input.set_value(m, command);
        let mut s = Self {
            input,
+            is_draft: false,
            width,
            height,
            history_buffer: String::new(),
@@ -1362,6 +1384,7 @@ impl ChatScreen {
            awaiting: None,
            request: None,
            suggestions: None,
+            completion: None,
            usage: Vec::new(),
            usage_position: 0,
            usage_width: 0,
@@ -1377,12 +1400,18 @@ impl ChatScreen {
    pub fn value(&self) -> &str {
        &self.input.value
    }
+    /// Take the most recently accepted suggestion, at most once. Call after
+    /// each key or click to observe every acceptance, including Tab cycling.
+    pub fn take_suggestion_completion(&mut self) -> Option<SuggestionCompletion> {
+        self.completion.take()
+    }
    /// Replace the input for a suggest-command link and refresh completions.
    pub fn suggest_command(&mut self, m: &Measure, c: &Commands, command: &str) {
        self.input.set_value(m, command);
        self.edited(m, c);
    }
-    /// `ChatScreen.resize`: a new screen with the current text.
+    /// `ChatScreen.resize`: a new screen with the current text, still a draft
+    /// while it has not been edited (`ChatScreen.resize` keeps the field).
    pub fn resize(&mut self, m: &Measure, c: &Commands, width: i32, height: i32) {
        if (width, height) != (self.width, self.height) {
            let value = self.input.value.clone();
@@ -1390,7 +1419,16 @@ impl ChatScreen {
            let abilities = self.abilities;
            let message = std::mem::take(&mut self.input.message);
            *self = if self.layout == SuggestLayout::CHAT {
-                Self::new(m, c, &value, self.history_pos, width, height, abilities)
+                Self::new(
+                    m,
+                    c,
+                    &value,
+                    self.is_draft,
+                    self.history_pos,
+                    width,
+                    height,
+                    abilities,
+                )
            } else {
                Self::command_block(m, c, &value, width, height)
            };
@@ -1402,6 +1440,7 @@ impl ChatScreen {
    fn edited(&mut self, m: &Measure, c: &Commands) {
        self.allow_suggestions = true;
        self.update_command_info(m, c);
+        self.is_draft = false;
    }
    /// Ctrl+A/C/V/X in the input box.
    pub fn shortcut(
@@ -1415,6 +1454,24 @@ impl ChatScreen {
            self.edited(m, c);
        }
    }
+    /// Edit the existing input and refresh its command responder when it changes.
+    pub fn edit_input(&mut self, m: &Measure, c: &Commands, f: impl FnOnce(&mut TextField)) {
+        let before = (
+            self.input.value.clone(),
+            self.input.cursor,
+            self.input.highlight,
+        );
+        f(&mut self.input);
+        if before
+            != (
+                self.input.value.clone(),
+                self.input.cursor,
+                self.input.highlight,
+            )
+        {
+            self.edited(m, c);
+        }
+    }
    /// Typed text (`charTyped` per character).
    pub fn type_text(&mut self, m: &Measure, c: &Commands, text: &str) {
        for ch in text.chars() {
@@ -1714,6 +1771,17 @@ impl ChatScreen {
        self.select(l, l.current as isize);
        self.keep_suggestions = false;
        l.tab_cycles = true;
+        let units = |byte: usize| {
+            l.original[..byte.min(l.original.len())]
+                .encode_utf16()
+                .count()
+        };
+        self.completion = Some(SuggestionCompletion {
+            original: l.original.clone(),
+            range: (units(s.range.0), units(s.range.1)),
+            text: s.text,
+            input: self.input.value.clone(),
+        });
    }
    /// `ChatScreen.keyPressed`.
    pub fn key(
@@ -1729,6 +1797,14 @@ impl ChatScreen {
        if self.suggestions_key(m, c, key, shift) {
            return ChatAction::None;
        }
+        // ChatScreen.keyPressed: while the box holds an unedited draft, the
+        // first Backspace clears all of it rather than one character.
+        if self.is_draft && key == K::Backspace {
+            self.input.set_value(m, "");
+            self.is_draft = false;
+            self.edited(m, c);
+            return ChatAction::None;
+        }
        match key {
            K::Escape => return ChatAction::Close,
            K::Enter | K::NumpadEnter => {
@@ -1862,8 +1938,13 @@ impl ChatScreen {
        l.offset = ((l.offset as f64 - amount.clamp(-1.0, 1.0)) as i32).clamp(0, max) as usize;
        true
    }
-    /// `CommandSuggestions.formatText`: argument colours over the input.
+    /// `CommandSuggestions.formatText`: argument colours over the input. The
+    /// draft formatter (`ChatScreen.formatChat`) is registered before this one
+    /// and wins while the draft is unedited: the whole text is grey italic.
    fn format(&self, value: &str, offset: usize) -> Text {
+        if self.is_draft {
+            return Text::literal(value).with_color(text::GRAY).italic();
+        }
        let gray = Style::color(text::GRAY);
        let Some(parse) = &self.parse else {
            return Text::literal(value);
@@ -7,6 +7,85 @@ fn full() -> ChatAbilities {
    ChatAbilities::new(ChatVisibility::Full)
 }

+#[test]
+fn accepted_suggestions_report_utf16_ranges_and_tab_cycles() {
+    use winit::keyboard::KeyCode as K;
+    let font = font();
+    let m = Measure(&font);
+    let registries = Registries {
+        players: vec!["Steve".into(), "Steven".into()],
+        ..Registries::default()
+    };
+    let c = Commands {
+        dispatcher: crate::command::vanilla::game_dispatcher(),
+        registries: &registries,
+    };
+    let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, full());
+    screen.type_text(&m, &c, "😀 hi st");
+    assert!(screen.take_suggestion_completion().is_none());
+    screen.key(&m, &c, &[], K::Tab, false, false);
+    assert!(
+        screen.take_suggestion_completion().is_none(),
+        "opening is not accepting"
+    );
+    for (shift, text) in [(false, "Steve"), (false, "Steven"), (true, "Steve")] {
+        screen.key(&m, &c, &[], K::Tab, shift, false);
+        assert_eq!(screen.value(), format!("😀 hi {text}"));
+        assert_eq!(
+            screen.take_suggestion_completion(),
+            Some(SuggestionCompletion {
+                original: "😀 hi st".into(),
+                range: (6, 8),
+                text: text.into(),
+                input: format!("😀 hi {text}"),
+            })
+        );
+        assert!(
+            screen.take_suggestion_completion().is_none(),
+            "reported once"
+        );
+    }
+    screen.key(&m, &c, &[], K::ArrowDown, false, false);
+    assert!(
+        screen.take_suggestion_completion().is_none(),
+        "selection is not accepting"
+    );
+    screen.key(&m, &c, &[], K::Escape, false, false);
+    assert!(screen.take_suggestion_completion().is_none());
+}
+
+#[test]
+fn clicked_suggestion_reports_the_actual_length_limited_input() {
+    use winit::keyboard::KeyCode as K;
+    let font = font();
+    let m = Measure(&font);
+    let registries = Registries {
+        players: vec!["Steve".into()],
+        ..Registries::default()
+    };
+    let c = Commands {
+        dispatcher: crate::command::vanilla::game_dispatcher(),
+        registries: &registries,
+    };
+    let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, full());
+    screen.input.max_length = 6;
+    screen.type_text(&m, &c, "hi st");
+    screen.key(&m, &c, &[], K::Tab, false, false);
+    let [x, y, _, _] = screen.suggestions.as_ref().unwrap().rect;
+    assert!(screen.click(&m, &c, f64::from(x + 1), f64::from(y + 1)));
+    assert_eq!(screen.value(), "hi Ste");
+    assert_eq!(
+        screen.take_suggestion_completion(),
+        Some(SuggestionCompletion {
+            original: "hi st".into(),
+            range: (3, 5),
+            text: "Steve".into(),
+            input: "hi Ste".into(),
+        })
+    );
+    assert!(screen.take_suggestion_completion().is_none());
+}
+
 fn font() -> Font {
    // The missing-glyph metrics let these tests run without game assets.
    Font::load(
@@ -201,7 +280,7 @@ fn locate_coordinates_fill_chat_with_teleport_without_submitting() {
        assert_eq!(link.component()["click_event"]["command"], expected);
        let mut chat = Chat::default();
        add(&mut chat, &font, Text::literal("Found at ").append(link));
-        let mut screen = ChatScreen::new(&m, &commands, "draft", 0, 640, 360, full());
+        let mut screen = ChatScreen::new(&m, &commands, "draft", false, 0, 640, 360, full());
        let x = 4.0 + f64::from(font.width("Found at "));
        assert!(!screen.click(&m, &commands, x, 315.0));
        let Some(ClickEvent::SuggestCommand(command)) = chat.click_at(&font, 360, x, 315.0) else {
@@ -242,6 +321,7 @@ fn history_arrows_recall_messages_and_restore_the_draft() {
        &m,
        &commands,
        "unfinished draft",
+        false,
        history.len(),
        640,
        360,
@@ -263,6 +343,93 @@ fn history_arrows_recall_messages_and_restore_the_draft() {
    }
 }

+/// `ChatScreen.isDraft`: the box opens on the draft kept from last time
+/// (`ChatComponent.createScreen` passes `true`, which `ChatScreen.init`
+/// stores), so the text draws grey italic through `ChatScreen.formatChat`
+/// and the first Backspace clears the whole draft instead of one character.
+/// Editing the draft (`onEdited`) ends both.
+#[test]
+fn a_restored_draft_is_grey_italic_and_one_backspace_clears_it() {
+    use winit::keyboard::KeyCode::Backspace;
+
+    let font = font();
+    let m = Measure(&font);
+    let registries = Registries::default();
+    let c = Commands {
+        dispatcher: crate::command::vanilla::game_dispatcher(),
+        registries: &registries,
+    };
+    // The input's own text as the game draws it: x 4, y height - 12.
+    let input_text = |screen: &mut ChatScreen| -> Text {
+        screen
+            .draw(&m, (0, 0), 0, i32::MIN)
+            .into_iter()
+            .find_map(|draw| match draw {
+                Draw::Text {
+                    text, x: 4, y: 348, ..
+                } => Some(text),
+                _ => None,
+            })
+            .expect("the input draws its text")
+    };
+    let draft_style = |t: &Text| {
+        t.spans
+            .iter()
+            .all(|s| s.style.color == Some(text::GRAY) && s.style.is_italic())
+    };
+    let mut screen = ChatScreen::new(&m, &c, "half-written", true, 0, 640, 360, full());
+    assert_eq!(screen.value(), "half-written");
+    assert!(
+        draft_style(&input_text(&mut screen)),
+        "the restored draft draws grey italic"
+    );
+    // Typing into the draft (`onEdited`) ends the draft style, and Backspace
+    // eats one character again.
+    screen.type_text(&m, &c, "!");
+    assert_eq!(screen.value(), "half-written!");
+    let typed = input_text(&mut screen);
+    assert!(
+        !typed.spans.iter().any(|s| s.style.is_italic()),
+        "an edited draft is not grey italic"
+    );
+    assert_eq!(
+        screen.key(&m, &c, &[], Backspace, false, false),
+        ChatAction::None
+    );
+    assert_eq!(screen.value(), "half-written");
+    // A draft left alone clears whole on its first Backspace.
+    let mut screen = ChatScreen::new(&m, &c, "half-written", true, 0, 640, 360, full());
+    assert_eq!(
+        screen.key(&m, &c, &[], Backspace, false, false),
+        ChatAction::None
+    );
+    assert_eq!(screen.value(), "", "the first Backspace clears the draft");
+    // The flag is gone with it: typing is ordinary text, and Backspace eats
+    // one character.
+    screen.type_text(&m, &c, "hi");
+    assert_eq!(screen.value(), "hi");
+    let typed = input_text(&mut screen);
+    assert!(!typed.spans.iter().any(|s| s.style.is_italic()));
+    assert_eq!(
+        screen.key(&m, &c, &[], Backspace, false, false),
+        ChatAction::None
+    );
+    assert_eq!(screen.value(), "h");
+    // A box opened on ordinary text deletes one character at a time.
+    let mut screen = ChatScreen::new(&m, &c, "half-written", false, 0, 640, 360, full());
+    assert!(!draft_style(&input_text(&mut screen)));
+    assert_eq!(
+        screen.key(&m, &c, &[], Backspace, false, false),
+        ChatAction::None
+    );
+    assert_eq!(screen.value(), "half-writte");
+    // A command draft is grey italic as a whole: `formatChat` is registered
+    // before `CommandSuggestions.formatText`, so it wins over the argument
+    // colours.
+    let mut screen = ChatScreen::new(&m, &c, "/give @s stone", true, 0, 640, 360, full());
+    assert!(draft_style(&input_text(&mut screen)));
+}
+
 #[test]
 fn mod_commands_are_coloured_and_complete_like_vanilla_ones() {
    let font = font();
@@ -283,7 +450,7 @@ fn mod_commands_are_coloured_and_complete_like_vanilla_ones() {
            dispatcher,
            registries: &registries,
        };
-        let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, full());
+        let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, full());
        screen.type_text(&m, &c, line);
        screen
    };
@@ -333,7 +500,7 @@ fn chat_completes_the_servers_custom_completions_with_the_players() {
            dispatcher,
            registries,
        };
-        let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, full());
+        let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, full());
        screen.type_text(&m, &c, line);
        // Chat shows no list by itself: Tab shows it, Tab again uses it.
        for _ in 0..2 {
@@ -381,7 +548,7 @@ fn ask_server_nodes_wait_for_the_servers_completions() {
    let tab = |screen: &mut ChatScreen| {
        screen.key(&m, &c, &[], winit::keyboard::KeyCode::Tab, false, false);
    };
-    let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, full());
+    let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, full());
    screen.type_text(&m, &c, "/bossbar get pt");
    let (request, sent) = screen.take_request().expect("the server is asked");
    assert_eq!(sent, "/bossbar get pt");
@@ -395,15 +562,25 @@ fn ask_server_nodes_wait_for_the_servers_completions() {
    tab(&mut screen);
    assert_eq!(screen.value(), "/bossbar get pt");
    screen.server_suggestions(&m, &c, request, (13, 2), reply("pt6:check"));
+    assert!(screen.take_suggestion_completion().is_none());
    tab(&mut screen);
    assert_eq!(screen.value(), "/bossbar get pt6:check");
+    assert_eq!(
+        screen.take_suggestion_completion(),
+        Some(SuggestionCompletion {
+            original: "/bossbar get pt".into(),
+            range: (13, 15),
+            text: "pt6:check".into(),
+            input: "/bossbar get pt6:check".into(),
+        })
+    );
    // Without the server's provider the local list is done at once.
    let local = crate::command::vanilla::game_dispatcher();
    let c = Commands {
        dispatcher: local,
        registries: &registries,
    };
-    let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, full());
+    let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, full());
    screen.type_text(&m, &c, "/bossbar get pt");
    assert_eq!(screen.take_request(), None);
 }
@@ -473,7 +650,7 @@ fn the_chat_option_decides_what_may_be_sent() {
        assert_eq!(abilities.allows("hi"), chat, "{visibility:?}");
        assert_eq!(abilities.allows("/time set day"), command, "{visibility:?}");
        for (line, allowed) in [("hi", chat), ("/time set day", command)] {
-            let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, abilities);
+            let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, abilities);
            screen.type_text(&m, &c, line);
            match enter(&mut screen) {
                ChatAction::Submit(sent) => {
@@ -499,7 +676,16 @@ fn restricted_input_says_why_it_will_not_send() {
        registries: &registries,
    };
    let usage = |visibility, line: &str| {
-        let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, ChatAbilities::new(visibility));
+        let mut screen = ChatScreen::new(
+            &m,
+            &c,
+            "",
+            false,
+            0,
+            640,
+            360,
+            ChatAbilities::new(visibility),
+        );
        screen.type_text(&m, &c, line);
        screen.usage.iter().map(|t| t.plain()).collect::<Vec<_>>()
    };
@@ -11,7 +11,7 @@ use horizon_world::{
 use std::{
    collections::HashMap,
    sync::{
-        Arc,
+        Arc, Mutex, OnceLock, PoisonError,
        atomic::{AtomicU64, Ordering},
    },
 };
@@ -108,6 +108,9 @@ pub enum BlockEntity {
 pub struct ModBlockEntity {
    fields: ModBlockEntityFields,
    revision: ModRevision,
+    // A client update can consume transient effects without changing saved
+    // fields. Most entities never use this; do not allocate their queue.
+    client_update_fields: OnceLock<Mutex<Compound>>,
 }
 /// What a `ModBlockEntity` holds: its type id (`mymod:machine`), its saved
 /// compound without `id`, `x`, `y`, `z` and `Items`, its item slots
@@ -138,11 +141,55 @@ impl ModBlockEntity {
                born: MOD_BLOCK_ENTITIES_MADE.fetch_add(1, Ordering::Relaxed),
                changes: 0,
            },
+            client_update_fields: OnceLock::new(),
        }
    }
    pub fn revision(&self) -> ModRevision {
        self.revision
    }
+    /// Replace the owner's pending, one-shot client update fields. These
+    /// fields are not saved, cloned, compared or retained for drawing, and
+    /// changing them does not change this entity's revision. The owner must
+    /// explicitly take and merge them into its update tag. Calling this does
+    /// not schedule a block update.
+    ///
+    /// An empty batch clears a pending batch without allocating an idle queue.
+    pub fn set_client_update_fields(&mut self, fields: Compound) {
+        if fields.is_empty() {
+            self.clear_client_update_fields();
+            return;
+        }
+        *self
+            .client_update_fields
+            .get_or_init(|| Mutex::new(Compound::new()))
+            .lock()
+            .unwrap_or_else(PoisonError::into_inner) = fields;
+    }
+    /// Discard the owner's pending client update fields, without changing
+    /// saved data, revision or a queue that has never been used.
+    pub fn clear_client_update_fields(&mut self) {
+        if let Some(fields) = self.client_update_fields.get() {
+            fields
+                .lock()
+                .unwrap_or_else(PoisonError::into_inner)
+                .clear();
+        }
+    }
+    /// Atomically take the owner's pending fields at update-tag construction.
+    /// A loaded chunk and a block change use this same boundary. Construct a
+    /// tag once, then send that tag to every recipient; another construction
+    /// sees an empty batch. A save or a clone does not consume this batch.
+    ///
+    /// This is safe for an update-tag hook receiving only a shared reference,
+    /// including a saved chunk encoded by a worker thread. If a previous lock
+    /// holder panicked, preserve its pending data instead of dropping it.
+    pub fn take_client_update_fields(&self) -> Compound {
+        self.client_update_fields
+            .get()
+            .map_or_else(Compound::new, |fields| {
+                std::mem::take(&mut *fields.lock().unwrap_or_else(PoisonError::into_inner))
+            })
+    }
    /// A client's copy loads the tag the server sent (`loadWithComponents`
    /// in `ClientPacketListener.handleBlockEntityData`): `tag`'s fields
    /// replace its own of the same names. One it already has as sent is
@@ -706,6 +753,85 @@ pub struct CommandBlock {
 mod tests {
    use super::*;

+    #[test]
+    fn transient_client_update_fields_are_lazy_replaceable_and_drained_once() {
+        let mut machine = ModBlockEntity::new(ModBlockEntityFields {
+            id: "test:machine".into(),
+            nbt: Compound::from([("progress".into(), Tag::Int(7))]),
+            ..Default::default()
+        });
+        let revision = machine.revision();
+        let saved = machine.fields.clone();
+        let debug = format!("{machine:?}");
+        machine.clear_client_update_fields();
+        machine.set_client_update_fields(Compound::new());
+        assert!(machine.take_client_update_fields().is_empty());
+        assert!(machine.client_update_fields.get().is_none());
+
+        machine.set_client_update_fields(Compound::from([("discarded".into(), Tag::Int(1))]));
+        let expected = Compound::from([("effects".into(), Tag::List(vec![Tag::Int(2)]))]);
+        machine.set_client_update_fields(expected.clone());
+        assert_eq!(machine.take_client_update_fields(), expected);
+        assert!(machine.take_client_update_fields().is_empty());
+
+        machine.set_client_update_fields(expected.clone());
+        let copy = machine.clone();
+        assert_eq!(machine, copy, "transient fields are not retained contents");
+        assert_ne!(machine.revision(), copy.revision());
+        assert!(copy.client_update_fields.get().is_none());
+        assert!(copy.take_client_update_fields().is_empty());
+        assert_eq!(machine.take_client_update_fields(), expected);
+        machine.set_client_update_fields(expected);
+        machine.clear_client_update_fields();
+        assert!(machine.take_client_update_fields().is_empty());
+        assert_eq!(machine.fields, saved);
+        assert_eq!(machine.revision(), revision);
+        assert_eq!(format!("{machine:?}"), debug);
+    }
+
+    #[test]
+    fn concurrent_client_update_constructions_consume_one_batch() {
+        let mut machine = ModBlockEntity::default();
+        let expected = Compound::from([("effects".into(), Tag::Int(23))]);
+        machine.set_client_update_fields(expected.clone());
+        let received = std::thread::scope(|scope| {
+            let handles = (0..16)
+                .map(|_| scope.spawn(|| machine.take_client_update_fields()))
+                .collect::<Vec<_>>();
+            handles
+                .into_iter()
+                .map(|h| h.join().unwrap())
+                .collect::<Vec<_>>()
+        });
+        let nonempty = received
+            .into_iter()
+            .filter(|c| !c.is_empty())
+            .collect::<Vec<_>>();
+        assert_eq!(nonempty, [expected]);
+    }
+
+    #[test]
+    fn a_poisoned_client_update_lock_preserves_its_pending_batch() {
+        let mut machine = ModBlockEntity::default();
+        let expected = Compound::from([("effects".into(), Tag::Int(23))]);
+        machine.set_client_update_fields(expected.clone());
+        std::thread::scope(|scope| {
+            assert!(
+                scope
+                    .spawn(|| {
+                        let _held = machine.client_update_fields.get().unwrap().lock().unwrap();
+                        panic!("interrupt before consuming the queued batch");
+                    })
+                    .join()
+                    .is_err()
+            );
+        });
+        assert_eq!(machine.take_client_update_fields(), expected);
+        assert!(machine.take_client_update_fields().is_empty());
+        machine.set_client_update_fields(expected.clone());
+        assert_eq!(machine.take_client_update_fields(), expected);
+    }
+
    #[test]
    fn a_mod_block_entitys_revision_moves_with_each_change_and_only_then() {
        let mut machine = ModBlockEntity::new(ModBlockEntityFields {
@@ -0,0 +1,143 @@
+//! The files of the resources the game loaded, resource packs' over vanilla's, for a client mod reading textures and
+//! other resources on any thread (`native_client_resources`; docs/native-mods.md).
+use horizon_core::prepared_files;
+use std::path::PathBuf;
+
+/// A texture's pixels: `width` by `height` RGBA, rows top first, as its PNG stores them (gamma-encoded, alpha not
+/// premultiplied). An animated texture is its frames one under another, as in its file.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct TexturePixels {
+    pub width: u32,
+    pub height: u32,
+    pub rgba: Vec<u8>,
+}
+
+// A mod reads textures on a worker thread.
+const _: () = {
+    const fn shareable<T: Send + Sync + 'static>() {}
+    shareable::<ClientResources>()
+};
+
+/// The resources the game loaded, as one tree: vanilla's, with the resource packs turned on (a higher pack over a
+/// lower one) and the content mods' files over it. A pack turned on or off makes a new tree: ask for it again then.
+/// It reads the files on disk at each call, not a copy: while a reload rebuilds them, a read can miss a file or get
+/// the new pack's before `native_block_sprites_version()` changes.
+#[derive(Clone, Debug)]
+pub struct ClientResources {
+    root: PathBuf,
+}
+
+impl ClientResources {
+    /// The tree at `root` (the game's `options.resources`).
+    pub fn new(root: PathBuf) -> Self {
+        Self { root }
+    }
+
+    /// The bytes of the resource at `path` in the tree (`assets/minecraft/textures/entity/cow/cow_temperate.png`).
+    /// None when there is no such file, or for a path that isn't plain names under `assets/`.
+    pub fn read(&self, path: &str) -> Option<Vec<u8>> {
+        let plain = |p: &str| !p.is_empty() && p != "." && p != ".." && !p.contains('\\');
+        if !path.starts_with("assets/") || !path.split('/').all(plain) {
+            return None;
+        }
+        prepared_files::read(&self.root.join(path)).ok()
+    }
+
+    /// A texture's pixels by name (`block/stone`, `entity/cow/cow_temperate`, a mod's `mymod:item/gear`): the PNG
+    /// under `assets/<namespace>/textures/`, decoded. None when there is no such PNG or it doesn't decode.
+    pub fn texture(&self, name: &str) -> Option<TexturePixels> {
+        let path = crate::atlas_sources::texture_path(&self.root, name, "textures");
+        let (width, height, rgba) =
+            crate::hud::decode_bytes(&prepared_files::read(&path).ok()?).ok()?;
+        Some(TexturePixels {
+            width,
+            height,
+            rgba,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::packs::{build_overlay, discover};
+    use std::{fs, path::Path};
+
+    const COW: &str = "assets/minecraft/textures/entity/cow/cow_temperate.png";
+    const RED: [u8; 4] = [255, 0, 0, 255];
+    const BLUE: [u8; 4] = [0, 0, 255, 255];
+
+    fn one_pixel_png(rgba: [u8; 4]) -> Vec<u8> {
+        let mut out = Vec::new();
+        let mut encoder = png::Encoder::new(&mut out, 1, 1);
+        encoder.set_color(png::ColorType::Rgba);
+        encoder.set_depth(png::BitDepth::Eight);
+        encoder
+            .write_header()
+            .unwrap()
+            .write_image_data(&rgba)
+            .unwrap();
+        out
+    }
+
+    fn write(path: &Path, bytes: &[u8]) {
+        fs::create_dir_all(path.parent().unwrap()).unwrap();
+        fs::write(path, bytes).unwrap();
+    }
+
+    #[test]
+    fn a_resource_pack_overrides_a_texture() {
+        let base =
+            std::env::temp_dir().join(format!("horizon-client-resources-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&base);
+        let vanilla = base.join("vanilla");
+        write(&vanilla.join(COW), &one_pixel_png(RED));
+        let pack = base.join("packs/Blue cows");
+        write(
+            &pack.join("pack.mcmeta"),
+            br#"{"pack":{"description":"blue cows","pack_format":97}}"#,
+        );
+        write(&pack.join(COW), &one_pixel_png(BLUE));
+        let overlay = base.join("overlay");
+        build_overlay(&vanilla, &discover(&vanilla, &base.join("packs")), &overlay).unwrap();
+
+        let (plain, packed) = (ClientResources::new(vanilla), ClientResources::new(overlay));
+        assert_eq!(plain.read(COW), Some(one_pixel_png(RED)));
+        assert_eq!(packed.read(COW), Some(one_pixel_png(BLUE)));
+        assert_eq!(
+            packed.texture("entity/cow/cow_temperate"),
+            Some(TexturePixels {
+                width: 1,
+                height: 1,
+                rgba: BLUE.to_vec(),
+            })
+        );
+        let _ = fs::remove_dir_all(base);
+    }
+
+    #[test]
+    fn only_plain_paths_under_assets_are_read() {
+        let base = std::env::temp_dir().join(format!(
+            "horizon-client-resources-paths-{}",
+            std::process::id()
+        ));
+        let _ = fs::remove_dir_all(&base);
+        let root = base.join("root");
+        write(&root.join(COW), &one_pixel_png(RED));
+        write(&root.join("horizon-resources.json"), b"{}");
+        write(&base.join("secret.txt"), b"secret");
+
+        let resources = ClientResources::new(root);
+        assert!(resources.read(COW).is_some());
+        for refused in [
+            "horizon-resources.json",
+            "assets/../horizon-resources.json",
+            "assets/../../secret.txt",
+            "assets//minecraft/textures/entity/cow/cow_temperate.png",
+            "/assets/minecraft/textures/entity/cow/cow_temperate.png",
+        ] {
+            assert_eq!(resources.read(refused), None, "{refused}");
+        }
+        let _ = fs::remove_dir_all(base);
+    }
+}
@@ -243,11 +243,24 @@ impl SceneCollisions<'_, '_> {
        max_step: f32,
        on_ground: bool,
        border: Option<(&BorderGeometry, [f64; 2])>,
+    ) -> Result<Vec3> {
+        self.resolve_in_border_with(bounds, movement, max_step, on_ground, border, &[])
+    }
+    /// [`Self::resolve_in_border`], also stopped by `entities`: the boxes
+    /// `EntityGetter.getEntityCollisions` gave the moving entity.
+    pub fn resolve_in_border_with(
+        self,
+        bounds: Aabb,
+        movement: Vec3,
+        max_step: f32,
+        on_ground: bool,
+        border: Option<(&BorderGeometry, [f64; 2])>,
+        entities: &[Aabb],
    ) -> Result<Vec3> {
        let context = self.context(bounds);
        EntityCollisions {
            blocks: self,
-            entities: &[],
+            entities,
            border,
        }
        .resolve_with_context(bounds, movement, max_step, on_ground, context)
@@ -10,6 +10,7 @@ use std::sync::Mutex;
 use std::sync::atomic::{AtomicBool, Ordering};

 use chrono::{DateTime, Local};
+use horizon_telemetry::system::machine_arch;

 /// What the game is doing, set as it goes: graphics adapter, settings, packs, world.
 static DETAILS: Mutex<Vec<(&'static str, String)>> = Mutex::new(Vec::new());
@@ -242,9 +243,18 @@ fn read(path: &str) -> Option<String> {
    std::fs::read_to_string(path).ok()
 }

+/// The build's architecture, and the machine's after "on" when it emulates the build.
+fn arch_label(build: &str, machine: &str) -> String {
+    if build == machine {
+        build.to_owned()
+    } else {
+        format!("{build} on {machine}")
+    }
+}
+
 /// `PRETTY_NAME` of /etc/os-release and the kernel, or the system's own version string.
 fn operating_system() -> String {
-    let arch = std::env::consts::ARCH;
+    let arch = arch_label(std::env::consts::ARCH, machine_arch());
    let version = if cfg!(target_os = "linux") {
        let name = read("/etc/os-release").and_then(|t| {
            t.lines()
@@ -683,6 +693,17 @@ pub fn debug_crash_after() -> Option<std::time::Duration> {
 mod tests {
    use super::*;

+    #[test]
+    fn an_emulated_build_names_both_architectures() {
+        // A Windows ARM64 PC playing the x64 build: its reports say so (#7513 read "x86_64").
+        assert_eq!(arch_label("x86_64", "aarch64"), "x86_64 on aarch64");
+        assert_eq!(arch_label("aarch64", "aarch64"), "aarch64");
+        assert_eq!(arch_label("x86_64", "x86_64"), "x86_64");
+        // On the machine running the tests: native builds name one architecture.
+        let label = arch_label(std::env::consts::ARCH, machine_arch());
+        assert!(label.starts_with(std::env::consts::ARCH));
+    }
+
    #[test]
    fn a_release_reports_its_built_in_version() {
        // release.yml builds with HORIZON_VERSION (docs/versioning.md): `v0.2.3`, wherever it is installed.
@@ -0,0 +1,243 @@
+//! OptiFine custom skies (`horizon_optifine::sky`) as the game draws them: a pack's layers with
+//! their decoded textures, read once with the pack, and each frame's choice of layers, their
+//! brightness and rotation ([`CustomSky::draws`]), which `gfx::custom_sky` draws over the
+//! vanilla sky. A pack without `optifine/sky` gives an empty [`CustomSky`] and the sky stays
+//! vanilla.
+
+use std::path::Path;
+
+use glam::{Mat4, Vec3};
+use horizon_optifine::sky::{Blend, Conditions, Skies, SkyLayer, Transition};
+
+/// A layer's texture, RGBA8.
+pub struct Image {
+    pub width: u32,
+    pub height: u32,
+    pub rgba: Vec<u8>,
+}
+
+/// The pack's layers, by world, with one texture per layer (`images[i]` for the `i`th layer
+/// over all worlds, in `worlds` order).
+#[derive(Default)]
+pub struct CustomSky {
+    worlds: Vec<(i32, Vec<SkyLayer>)>,
+    pub images: Vec<Image>,
+}
+
+/// One layer of a frame: which texture, with which blend, how bright and turned how.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Draw {
+    pub image: u16,
+    pub blend: Blend,
+    pub brightness: f32,
+    /// Camera-relative world from the skybox's space.
+    pub rotation: Mat4,
+}
+
+/// The eased brightness of each layer, kept by the game between frames.
+#[derive(Default)]
+pub struct State {
+    world: Option<i32>,
+    eased: Vec<Transition>,
+}
+
+/// Textures past this many texels in all are left out (a skybox is a few megapixels at most).
+const TEXEL_BUDGET: u64 = 64 << 20;
+
+impl CustomSky {
+    /// The custom skies of the overlay at `root`. A layer whose texture does not decode is
+    /// dropped with a warning.
+    pub fn load(root: &Path) -> Self {
+        let skies = Skies::scan(root);
+        let mut out = Self::default();
+        let mut texels = 0u64;
+        for (world, sky) in skies.worlds {
+            let mut layers = Vec::new();
+            for layer in sky.layers {
+                match crate::hud::decode(&root.join(&layer.source)) {
+                    Ok((width, height, rgba))
+                        if texels + u64::from(width) * u64::from(height) <= TEXEL_BUDGET =>
+                    {
+                        texels += u64::from(width) * u64::from(height);
+                        out.images.push(Image {
+                            width,
+                            height,
+                            rgba,
+                        });
+                        layers.push(layer);
+                    }
+                    Ok(_) => log::warn!("{}: past the custom sky's texture budget", layer.source),
+                    Err(e) => log::warn!("{}: {e:#}", layer.source),
+                }
+            }
+            if !layers.is_empty() {
+                out.worlds.push((world, layers));
+            }
+        }
+        out
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.worlds.is_empty()
+    }
+
+    /// Whether `world` has layers (`0` the Overworld, `1` the End).
+    pub fn has(&self, world: i32) -> bool {
+        self.worlds.iter().any(|(w, _)| *w == world)
+    }
+
+    /// This frame's layers of `world` into `out` (cleared first), in drawing order: those whose
+    /// conditions hold, eased over their `transition` by `seconds` since the last frame, at the
+    /// brightness of their fade times. `sun_turns` is the sun's angle over 360° (`0` at noon).
+    pub fn draws(
+        &self,
+        world: i32,
+        conditions: &Conditions,
+        sun_turns: f32,
+        seconds: f32,
+        state: &mut State,
+        out: &mut Vec<Draw>,
+    ) {
+        out.clear();
+        let mut first = 0;
+        let mut found = None;
+        for (w, layers) in &self.worlds {
+            if *w == world {
+                found = Some(layers);
+                break;
+            }
+            first += layers.len();
+        }
+        let Some(layers) = found else {
+            state.world = None;
+            return;
+        };
+        // A new world (or pack) starts each layer where its conditions put it: no fade in.
+        let snap = state.world != Some(world) || state.eased.len() != layers.len();
+        if snap {
+            state.world = Some(world);
+            state.eased.clear();
+            state.eased.resize(layers.len(), Transition::default());
+        }
+        for (i, (layer, eased)) in layers.iter().zip(&mut state.eased).enumerate() {
+            let target = if layer.shows(conditions) { 1.0 } else { 0.0 };
+            let shown = if snap {
+                eased.value = target;
+                target
+            } else {
+                eased.step(target, seconds, layer.transition)
+            };
+            let brightness = shown * layer.brightness(conditions.day_time);
+            if brightness <= 0.0 {
+                continue;
+            }
+            let turns = layer.turns(conditions.day_time, sun_turns);
+            let rotation = if turns == 0.0 {
+                Mat4::IDENTITY
+            } else {
+                Mat4::from_axis_angle(Vec3::from_array(layer.axis), turns * std::f32::consts::TAU)
+            };
+            out.push(Draw {
+                image: (first + i) as u16,
+                blend: layer.blend,
+                brightness,
+                rotation,
+            });
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_optifine::sky::Now;
+
+    fn pack(files: &[(&str, &str)]) -> (std::path::PathBuf, CustomSky) {
+        let root = std::env::temp_dir().join(format!(
+            "horizon-custom-sky-{}-{}",
+            std::process::id(),
+            files.len()
+        ));
+        let _ = std::fs::remove_dir_all(&root);
+        let dir = root.join("assets/minecraft/optifine/sky/world0");
+        std::fs::create_dir_all(&dir).unwrap();
+        let png = {
+            let mut bytes = Vec::new();
+            let mut encoder = png::Encoder::new(&mut bytes, 6, 4);
+            encoder.set_color(png::ColorType::Rgba);
+            encoder.set_depth(png::BitDepth::Eight);
+            let mut writer = encoder.write_header().unwrap();
+            writer
+                .write_image_data(&[255, 0, 0, 255].repeat(24))
+                .unwrap();
+            writer.finish().unwrap();
+            bytes
+        };
+        for (name, text) in files {
+            std::fs::write(dir.join(format!("{name}.properties")), text).unwrap();
+            std::fs::write(dir.join(format!("{name}.png")), &png).unwrap();
+        }
+        let sky = CustomSky::load(&root);
+        (root, sky)
+    }
+
+    fn noon(biome: &str) -> Conditions<'_> {
+        Conditions {
+            day_time: 6000,
+            weather: Now::Clear,
+            biome,
+            y: 64,
+        }
+    }
+
+    #[test]
+    fn layers_ease_in_at_a_biome_border_but_not_on_arrival() {
+        let (root, sky) = pack(&[
+            ("sky1", "biomes=desert\ntransition=2"),
+            ("sky2", "blend=alpha\nrotate=false"),
+        ]);
+        let _ = std::fs::remove_dir_all(root);
+        assert!(sky.has(0) && !sky.has(1));
+        assert_eq!(sky.images[0].width, 6);
+        let (mut state, mut out) = (State::default(), Vec::new());
+        sky.draws(
+            0,
+            &noon("minecraft:desert"),
+            0.0,
+            0.05,
+            &mut state,
+            &mut out,
+        );
+        assert_eq!(
+            out.iter().map(|d| d.brightness).collect::<Vec<_>>(),
+            [1.0, 1.0]
+        );
+        // Out of the desert: the first layer fades over its two seconds.
+        sky.draws(0, &noon("minecraft:plains"), 0.0, 0.5, &mut state, &mut out);
+        assert_eq!(out[0].brightness, 0.75);
+        assert_eq!(out[1].blend, Blend::Alpha);
+        sky.draws(0, &noon("minecraft:plains"), 0.0, 2.0, &mut state, &mut out);
+        assert_eq!(out.len(), 1, "a dark layer is not drawn");
+        assert_eq!(out[0].image, 1);
+        // Into the End, which has no layers, and back: no fade.
+        sky.draws(1, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
+        assert!(out.is_empty());
+        sky.draws(0, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
+        assert_eq!(out.len(), 2);
+    }
+
+    #[test]
+    fn a_layer_turns_west_like_the_sun() {
+        let (root, sky) = pack(&[("sky1", "")]);
+        let _ = std::fs::remove_dir_all(root);
+        let (mut state, mut out) = (State::default(), Vec::new());
+        // A quarter turn after noon (sunset): the skybox's zenith has gone down to the west.
+        let c = Conditions {
+            day_time: 12000,
+            ..noon("minecraft:plains")
+        };
+        sky.draws(0, &c, 0.25, 0.0, &mut state, &mut out);
+        let up = out[0].rotation.transform_vector3(Vec3::Y);
+        assert!((up - Vec3::NEG_X).length() < 1e-5, "{up}");
+    }
+}
@@ -14,6 +14,8 @@ pub struct EffectInstance {
    pub amplifier: i32,
    pub ambient: bool,
    pub visible: bool,
+    /// `MobEffectInstance.showIcon`: whether the HUD and inventory list it.
+    pub show_icon: bool,
    pub hidden: Option<Box<EffectInstance>>,
 }
 impl EffectInstance {
@@ -24,9 +26,18 @@ impl EffectInstance {
            amplifier: amplifier.clamp(0, 255),
            ambient: false,
            visible: true,
+            show_icon: true,
            hidden: None,
        }
    }
+    /// `new MobEffectInstance(effect, duration, amplifier, ambient, visible)`:
+    /// the icon shows exactly when the particles do.
+    pub fn with_flags(mut self, ambient: bool, visible: bool) -> Self {
+        self.ambient = ambient;
+        self.visible = visible;
+        self.show_icon = visible;
+        self
+    }
    fn infinite(&self) -> bool {
        self.duration == -1
    }
@@ -71,6 +82,10 @@ impl EffectInstance {
            self.visible = take.visible;
            changed = true;
        }
+        if take.show_icon != self.show_icon {
+            self.show_icon = take.show_icon;
+            changed = true;
+        }
        changed
    }
    /// `MobEffectInstance.tickClient`: a client counts its effects down
@@ -98,6 +113,7 @@ impl EffectInstance {
            self.amplifier = h.amplifier;
            self.ambient = h.ambient;
            self.visible = h.visible;
+            self.show_icon = h.show_icon;
            self.hidden = h.hidden;
        }
    }
@@ -116,8 +132,9 @@ pub enum EffectAction {
 }
 /// `shouldApplyEffectTickThisTick` + `applyEffectTick` for the periodic effects.
 fn periodic(id: &str, tick: i32, amp: i32) -> Option<EffectAction> {
+    // Java's `>>` and `<<` take the shift distance modulo 32 (`wrapping_*`).
    let every = |base: i32| {
-        let interval = base >> amp;
+        let interval = base.wrapping_shr(amp as u32);
        interval <= 0 || tick % interval == 0
    };
    match id {
@@ -126,10 +143,12 @@ fn periodic(id: &str, tick: i32, amp: i32) -> Option<EffectAction> {
        "wither" if every(40) => Some(EffectAction::Hurt("minecraft:wither", 1.0)),
        "hunger" => Some(EffectAction::Exhaust(0.005 * (amp + 1) as f32)),
        "saturation" if tick >= 1 => Some(EffectAction::Eat(amp + 1, 1.0)),
-        "instant_health" if tick >= 1 => Some(EffectAction::Heal((4 << amp.min(30)) as f32)),
+        "instant_health" if tick >= 1 => Some(EffectAction::Heal(
+            4i32.wrapping_shl(amp as u32).max(0) as f32,
+        )),
        "instant_damage" if tick >= 1 => Some(EffectAction::Hurt(
            "minecraft:magic",
-            (6 << amp.min(30)) as f32,
+            6i32.wrapping_shl(amp as u32) as f32,
        )),
        _ => None,
    }
@@ -139,11 +158,11 @@ fn periodic(id: &str, tick: i32, amp: i32) -> Option<EffectAction> {
 pub fn instant(id: &str, amp: i32, scale: f64) -> Option<EffectAction> {
    match id {
        "instant_health" => Some(EffectAction::Heal(
-            (scale * f64::from(4 << amp.min(30)) + 0.5) as i32 as f32,
+            (scale * f64::from(4i32.wrapping_shl(amp as u32)) + 0.5) as i32 as f32,
        )),
        "instant_damage" => Some(EffectAction::Hurt(
            "minecraft:magic",
-            (scale * f64::from(6 << amp.min(30)) + 0.5) as i32 as f32,
+            (scale * f64::from(6i32.wrapping_shl(amp as u32)) + 0.5) as i32 as f32,
        )),
        "saturation" => Some(EffectAction::Eat(amp + 1, 1.0)),
        _ => None,
@@ -168,6 +187,57 @@ pub enum OmenTick {
    /// It added this effect, then returned false.
    Add(EffectInstance),
 }
+/// A saved player's effect: `MobEffectInstance.Details` under its `id`.
+#[derive(Clone, Debug, PartialEq)]
+pub struct SavedEffect {
+    pub id: String,
+    pub duration: i32,
+    pub amplifier: i32,
+    pub ambient: bool,
+    /// `show_particles`.
+    pub particles: bool,
+    /// `show_icon`.
+    pub icon: bool,
+    /// `hidden_effect`: the weaker, longer instance of the same effect that
+    /// comes back when this one ends.
+    pub hidden: Option<Box<SavedEffect>>,
+}
+impl SavedEffect {
+    /// Ambient off, particles and icon shown, nothing hidden: the codec's
+    /// defaults.
+    pub fn new(id: impl Into<String>, duration: i32, amplifier: i32) -> Self {
+        Self {
+            id: id.into(),
+            duration,
+            amplifier,
+            ambient: false,
+            particles: true,
+            icon: true,
+            hidden: None,
+        }
+    }
+    fn of(e: &EffectInstance) -> Self {
+        Self {
+            id: potions::namespaced(e.id).to_owned(),
+            duration: e.duration,
+            amplifier: e.amplifier,
+            ambient: e.ambient,
+            particles: e.visible,
+            icon: e.show_icon,
+            hidden: e.hidden.as_deref().map(|h| Box::new(Self::of(h))),
+        }
+    }
+    /// `new MobEffectInstance(effect, details)`: the hidden chain comes back
+    /// with it.
+    fn instance(&self, id: &'static str) -> EffectInstance {
+        let mut e = EffectInstance::new(id, self.duration, self.amplifier);
+        e.ambient = self.ambient;
+        e.visible = self.particles;
+        e.show_icon = self.icon;
+        e.hidden = self.hidden.as_deref().map(|h| Box::new(h.instance(id)));
+        e
+    }
+}
 #[derive(Clone, Debug, Default)]
 pub struct PlayerEffects {
    pub list: Vec<EffectInstance>,
@@ -200,39 +270,25 @@ impl PlayerEffects {
    pub fn clear(&mut self) {
        self.list.clear();
    }
-    /// The effects of a saved player (`Player.active_effects`: id,
-    /// duration, amplifier, ambient, particles visible).
-    pub fn from_saved(saved: &[(String, i32, i32, bool, bool)]) -> Self {
+    /// The effects of a saved player (`Player.active_effects`), each with
+    /// the instances it hides.
+    pub fn from_saved(saved: &[SavedEffect]) -> Self {
        let mut effects = Self::default();
-        for (id, duration, amplifier, ambient, particles) in saved {
-            if let Some(def) = potions::effect(id) {
-                let mut e = EffectInstance::new(def.id, *duration, *amplifier);
-                e.ambient = *ambient;
-                e.visible = *particles;
-                effects.add(e);
+        for s in saved {
+            if let Some(def) = potions::effect(&s.id) {
+                effects.add(s.instance(def.id));
            }
        }
        effects
    }
    /// `Player.active_effects` for the save.
-    pub fn saved(&self) -> Vec<(String, i32, i32, bool, bool)> {
-        self.list
-            .iter()
-            .map(|e| {
-                (
-                    potions::namespaced(e.id).to_owned(),
-                    e.duration,
-                    e.amplifier,
-                    e.ambient,
-                    e.visible,
-                )
-            })
-            .collect()
+    pub fn saved(&self) -> Vec<SavedEffect> {
+        self.list.iter().map(SavedEffect::of).collect()
    }
    /// ClientboundUpdateMobEffectPacket's flags without blending: ambient,
-    /// particles visible and the icon shown (always, for these effects).
+    /// particles visible and the icon shown.
    pub fn flags(e: &EffectInstance) -> i8 {
-        i8::from(e.ambient) | i8::from(e.visible) << 1 | 4
+        i8::from(e.ambient) | i8::from(e.visible) << 1 | i8::from(e.show_icon) << 2
    }
    /// `LivingEntity.tickEffects` (server part) with the omens' effect ticks:
    /// `omen` answers `BadOmenMobEffect` (every tick), `RaidOmenMobEffect`
@@ -494,7 +550,75 @@ pub fn effect_modifier(effect: &str) -> Option<(&'static str, &'static str, f64,
 #[cfg(test)]
 mod tests {
    use super::*;
+    /// `HealOrHarmMobEffect`: Java's `<<` shifts by the amplifier modulo
+    /// 32 and wraps, so amplifier 32 is amplifier 0 again; a ticked heal is
+    /// at least 0 (#11386).
+    #[test]
+    fn heal_and_harm_shift_like_java() {
+        let magic = "minecraft:magic";
+        assert_eq!(
+            instant("instant_health", 32, 1.0),
+            Some(EffectAction::Heal(4.0))
+        );
+        assert_eq!(
+            instant("instant_damage", 33, 1.0),
+            Some(EffectAction::Hurt(magic, 12.0))
+        );
+        assert_eq!(
+            instant("instant_health", 1, 0.5),
+            Some(EffectAction::Heal(4.0))
+        );
+        assert_eq!(
+            periodic("instant_health", 1, 32),
+            Some(EffectAction::Heal(4.0))
+        );
+        // 4 << 29 is i32::MIN: the heal stops at 0. 6 << 30 wraps to i32::MIN.
+        assert_eq!(
+            periodic("instant_health", 1, 29),
+            Some(EffectAction::Heal(0.0))
+        );
+        assert_eq!(
+            periodic("instant_damage", 1, 30),
+            Some(EffectAction::Hurt(magic, i32::MIN as f32))
+        );
+        // Regeneration: 50 >> 32 is 50 again, not 0 (which would heal each tick).
+        assert_eq!(periodic("regeneration", 49, 32), None);
+        assert_eq!(
+            periodic("regeneration", 50, 32),
+            Some(EffectAction::Heal(1.0))
+        );
+    }

+    /// Warden darkness (`new MobEffectInstance(DARKNESS, 260, 0, false,
+    /// false)`) shows neither particles nor its icon; a renewal that shows the
+    /// icon turns it back on (`MobEffectInstance.update`).
+    #[test]
+    fn an_effect_without_particles_hides_its_icon() {
+        let mut fx = PlayerEffects::default();
+        fx.add(EffectInstance::new("darkness", 260, 0).with_flags(false, false));
+        let darkness = fx.get("darkness").unwrap();
+        // ClientboundUpdateMobEffectPacket: no ambient, particles or icon bit.
+        assert_eq!(PlayerEffects::flags(darkness), 0);
+        assert!(!crate::hud_overlays::EffectIcon::from(darkness).show_icon);
+        assert!(fx.add(EffectInstance::new("darkness", 100, 0)));
+        assert_eq!(PlayerEffects::flags(fx.get("darkness").unwrap()), 2 | 4);
+
+        // Details keeps show_icon apart from show_particles.
+        let mut speed = EffectInstance::new("speed", 100, 0);
+        speed.show_icon = false;
+        let mut fx = PlayerEffects::default();
+        fx.add(speed);
+        let saved = fx.saved();
+        assert_eq!(
+            saved,
+            [SavedEffect {
+                icon: false,
+                ..SavedEffect::new("minecraft:speed", 100, 0)
+            }]
+        );
+        let loaded = PlayerEffects::from_saved(&saved);
+        assert_eq!(PlayerEffects::flags(loaded.get("speed").unwrap()), 2);
+    }
    #[test]
    fn adding_counts_a_change_only_when_the_effect_changed() {
        let mut fx = PlayerEffects::default();
@@ -531,6 +655,21 @@ mod tests {
        assert_eq!(fx.get("speed").unwrap().duration, 49);
        assert_eq!(fx.get("raid_omen").unwrap().amplifier, 1);
    }
+    #[test]
+    fn a_reloaded_effect_falls_back_to_the_one_it_hid() {
+        // /effect give poison 6 s level II over poison 30 s level I, saved
+        // and loaded: when level II runs out, level I resumes with what is
+        // left of its 30 s.
+        let mut fx = PlayerEffects::default();
+        fx.add(EffectInstance::new("poison", 600, 0));
+        fx.add(EffectInstance::new("poison", 120, 1));
+        let mut loaded = PlayerEffects::from_saved(&fx.saved());
+        for _ in 0..120 {
+            loaded.tick();
+        }
+        let poison = loaded.get("poison").expect("level I resumed");
+        assert_eq!((poison.amplifier, poison.duration), (0, 480));
+    }
    /// The only test here that registers mod effects (once per process).
    #[test]
    fn a_mod_effect_saves_under_its_namespace() {
@@ -546,11 +685,11 @@ mod tests {
            1,
        ));
        let saved = fx.saved();
-        assert_eq!(saved, [("ruby:glow".to_owned(), 600, 1, false, true)]);
+        assert_eq!(saved, [SavedEffect::new("ruby:glow", 600, 1)]);
        assert_eq!(PlayerEffects::from_saved(&saved).list, fx.list);
        // Without its mod the saved effect is dropped, as an unknown id is.
        assert!(
-            PlayerEffects::from_saved(&[("gone:glow".into(), 600, 1, false, true)])
+            PlayerEffects::from_saved(&[SavedEffect::new("gone:glow", 600, 1)])
                .list
                .is_empty()
        );
@@ -0,0 +1,210 @@
+// Still-fluid tiling follows Catnip/Ponder 1.0.82 FluidRenderHelper.renderTiledFace.
+// Copyright (c) 2022 The Create Team
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND 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.
+
+use horizon_core::geometry::Direction;
+
+/// Controls a still-fluid box. The tint is stack ARGB, independent of biome tint.
+#[derive(Clone, Copy, Debug)]
+pub struct NativeFluidRenderOptions {
+    pub argb: Option<u32>,
+    pub render_bottom: bool,
+    /// TextureAtlasSprite.uvShrinkRatio: 4 / the largest stitched atlas dimension.
+    /// Explicit because Horizon's block sprites occupy arrays rather than a stitched atlas.
+    pub uv_shrink_ratio: f32,
+}
+
+/// A corner before the caller's pose, with UVs within the still sprite, and its outward normal.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct FluidVertex {
+    pub pos: [f32; 3],
+    pub uv: [f32; 2],
+    pub normal: [i8; 3],
+}
+
+/// Preserve sky light and increase block light to the fluid's luminosity (native light packing).
+pub fn fluid_light(light: u32, luminosity: u8) -> u32 {
+    (light & 0xf0) | (((light >> 8 & 0xf0).max(u32::from(luminosity.min(15)) * 16)) << 8)
+}
+
+/// Emit whole tiled quads, or refuse invalid/unreasonably large geometry before emitting anything.
+/// Negative coordinates and exact integer boundaries retain the source's local UV fractions.
+pub fn fluid_box(
+    bounds: [f32; 6],
+    options: NativeFluidRenderOptions,
+    mut emit: impl FnMut(FluidVertex),
+) -> bool {
+    if !options.uv_shrink_ratio.is_finite()
+        || !(0.0..=1.0).contains(&options.uv_shrink_ratio)
+        || bounds
+            .iter()
+            .any(|x| !x.is_finite() || x.abs() > 1_048_576.0)
+        || (0..3).any(|i| bounds[i] > bounds[i + 3])
+    {
+        return false;
+    }
+    let tiles =
+        std::array::from_fn::<_, 3, _>(|i| (bounds[i + 3].ceil() - bounds[i].floor()) as u64);
+    let quads = tiles[0] * tiles[1] * 2
+        + tiles[1] * tiles[2] * 2
+        + tiles[0] * tiles[2] * if options.render_bottom { 2 } else { 1 };
+    if quads > 65_536 {
+        return false;
+    }
+    let [x0, y0, z0, x1, y1, z1] = bounds;
+    for (side, face) in [
+        (Direction::Down, [x0, z0, x1, z1, y0]),
+        (Direction::Up, [x0, z0, x1, z1, y1]),
+        (Direction::North, [x0, y0, x1, y1, z0]),
+        (Direction::South, [x0, y0, x1, y1, z1]),
+        (Direction::West, [z0, y0, z1, y1, x0]),
+        (Direction::East, [z0, y0, z1, y1, x1]),
+    ] {
+        if side != Direction::Down || options.render_bottom {
+            tiled_face(&mut emit, side, face, options.uv_shrink_ratio);
+        }
+    }
+    true
+}
+
+fn tiled_face(out: &mut impl FnMut(FluidVertex), side: Direction, face: [f32; 5], ratio: f32) {
+    let [a0, b0, a1, b1, plane] = face;
+    let positive = matches!(side, Direction::Up | Direction::South | Direction::East);
+    let shrink = ratio * 0.25;
+    let lerp = |v| v + shrink * (0.5 - v);
+    let mut a = a0;
+    while a < a1 {
+        let end_a = (a.floor() + 1.0).min(a1);
+        let (u0, u1) = if matches!(side, Direction::North | Direction::East) {
+            (end_a.ceil() - end_a, end_a.ceil() - a)
+        } else {
+            (a - a.floor(), end_a - a.floor())
+        };
+        let (u0, u1) = (lerp(u0), lerp(u1));
+        let mut b = b0;
+        while b < b1 {
+            let end_b = (b.floor() + 1.0).min(b1);
+            let (v0, v1) = if side == Direction::Up {
+                (b - b.floor(), end_b - b.floor())
+            } else {
+                (end_b.ceil() - end_b, end_b.ceil() - b)
+            };
+            let (v0, v1) = (lerp(v0), lerp(v1));
+            let positions = match side {
+                Direction::West | Direction::East => {
+                    let (near, far) = if positive { (end_a, a) } else { (a, end_a) };
+                    [
+                        [plane, end_b, near],
+                        [plane, b, near],
+                        [plane, b, far],
+                        [plane, end_b, far],
+                    ]
+                }
+                Direction::North | Direction::South => {
+                    let (near, far) = if positive { (a, end_a) } else { (end_a, a) };
+                    [
+                        [near, end_b, plane],
+                        [near, b, plane],
+                        [far, b, plane],
+                        [far, end_b, plane],
+                    ]
+                }
+                Direction::Down | Direction::Up => {
+                    let (near, far) = if positive { (b, end_b) } else { (end_b, b) };
+                    [
+                        [a, plane, near],
+                        [a, plane, far],
+                        [end_a, plane, far],
+                        [end_a, plane, near],
+                    ]
+                }
+            };
+            let normal = match side {
+                Direction::Down => [0, -1, 0],
+                Direction::Up => [0, 1, 0],
+                Direction::North => [0, 0, -1],
+                Direction::South => [0, 0, 1],
+                Direction::West => [-1, 0, 0],
+                Direction::East => [1, 0, 0],
+            };
+            for (pos, uv) in positions
+                .into_iter()
+                .zip([[u0, v0], [u0, v1], [u1, v1], [u1, v0]])
+            {
+                out(FluidVertex { pos, uv, normal });
+            }
+            b = end_b;
+        }
+        a = end_a;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn source_tiling_is_outward_and_does_not_inset_geometry() {
+        let bounds = [-1.25, 0.125, -0.25, 1.5, 1.125, 0.75];
+        let mut result = Vec::new();
+        assert!(fluid_box(
+            bounds,
+            NativeFluidRenderOptions {
+                argb: None,
+                render_bottom: false,
+                uv_shrink_ratio: 4.0 / 2048.0,
+            },
+            |v| result.push(v),
+        ));
+        assert_eq!(result.len(), (4 * 2 * 2 + 2 * 2 * 2 + 4 * 2) * 4);
+        for quad in result.as_chunks::<4>().0 {
+            let [a, b, c, _] = quad.map(|v| glam::Vec3::from_array(v.pos));
+            assert!(
+                (b - a)
+                    .cross(c - a)
+                    .dot(glam::Vec3::from_array(quad[0].normal.map(f32::from)))
+                    > 0.0
+            );
+            assert!(
+                quad.iter()
+                    .all(|v| (0..3).all(|i| v.pos[i] >= bounds[i] && v.pos[i] <= bounds[i + 3]))
+            );
+        }
+        assert!(
+            result
+                .iter()
+                .any(|v| v.pos == [bounds[0], bounds[4], bounds[2]])
+        );
+        assert!(!fluid_box(
+            [0.0, 0.0, 0.0, 1_000.0, 1_000.0, 1_000.0],
+            NativeFluidRenderOptions {
+                argb: None,
+                render_bottom: true,
+                uv_shrink_ratio: 0.0,
+            },
+            |_| panic!("invalid geometry must fail before emitting"),
+        ));
+    }
+    #[test]
+    fn luminosity_changes_only_block_light() {
+        assert_eq!(fluid_light(0x20a0, 15), 0xf0a0);
+        assert_eq!(fluid_light(0x25a5, 15), 0xf0a0);
+        assert_eq!(fluid_light(0xe030, 3), 0xe030);
+    }
+}
@@ -413,6 +413,12 @@ pub fn clear_distance_fog(fog: &mut FogData, input: &FogInputs) {
        (fog.environmental_start, fog.environmental_end) = (1e9, 2e9);
    }
 }
+/// What `AtmosphericFogEnvironment.updateRainFogState` eases the rain fog toward: the rain, where
+/// the sky reaches the eye, halved in a biome without precipitation.
+pub fn rain_fog_target(rain: f32, sky_light: u8, biome_rains: bool) -> f32 {
+    let sky = ((f32::from(sky_light) - 8.0) / 7.0).clamp(0.0, 1.0);
+    rain * sky * if biome_rains { 1.0 } else { 0.5 }
+}
 /// Whether the frame draws no sky, only the clear to the fog colour: `LevelRenderer.addSkyPass`
 /// leaves the sky out in lava and powder snow and while blindness or darkness is on (`Camera`'s
 /// `doesMobEffectBlockSky`), and `GameRenderer.renderLevel` gives `LevelRenderer.render`
@@ -428,10 +434,14 @@ pub fn update_rain_fog(
    biome_rains: bool,
    delta_ticks: f32,
 ) {
-    let sky = ((f32::from(sky_light) - 8.0) / 7.0).clamp(0.0, 1.0);
-    let target = rain * sky * if biome_rains { 1.0 } else { 0.5 };
+    let target = rain_fog_target(rain, sky_light, biome_rains);
    state.rain_fog_multiplier += (target - state.rain_fog_multiplier) * delta_ticks * 0.2;
 }
+/// The rain fog at its target at once: a frozen world under `HORIZON_STILL`, where the rain sits
+/// at its level and easing would wait for ticks that do not come.
+pub fn settle_rain_fog(state: &mut FogState, rain: f32, sky_light: u8, biome_rains: bool) {
+    state.rain_fog_multiplier = rain_fog_target(rain, sky_light, biome_rains);
+}
 fn rgb(c: u32) -> [f32; 3] {
    [
        (c >> 16 & 255) as f32 / 255.0,
@@ -726,6 +736,30 @@ mod tests {
        assert_eq!(clear.environmental_end, settled.environmental_end);
        assert_eq!(clear.color, settled.color);
    }
+    /// Settling puts the rain fog at its target exactly, where a tick of easing moves it a fifth
+    /// of the way, as before.
+    #[test]
+    fn settled_rain_fog_is_its_target_and_easing_is_unchanged() {
+        assert_eq!(
+            rain_fog_target(1.0, 15, false),
+            0.5,
+            "a dry biome halves it"
+        );
+        assert_eq!(rain_fog_target(1.0, 8, true), 0.0, "no sky, no rain fog");
+        let start = FogState {
+            rain_fog_multiplier: 0.1,
+            ..FogState::default()
+        };
+        let mut settled = start;
+        settle_rain_fog(&mut settled, 0.5, 15, true);
+        assert_eq!(settled.rain_fog_multiplier, 0.5);
+        let mut eased = start;
+        update_rain_fog(&mut eased, 0.5, 15, true, 1.0);
+        assert_eq!(
+            eased.rain_fog_multiplier.to_bits(),
+            (0.1f32 + (0.5f32 - 0.1) * 1.0 * 0.2).to_bits()
+        );
+    }
    #[test]
    fn rain_fog_pulls_fog_in() {
        let sky = Sky {
@@ -1040,7 +1040,14 @@ mod tests {
                cache: None,
            })
        };
-        let mut flat = flat::Flat::new(&device, &terrain_layout, 4 * GRAIN, 0, pipeline);
+        let pipeline = &pipeline;
+        let solid = |layout: &wgpu::PipelineLayout, label: &str, _: &str, _: &str| {
+            super::super::SolidPipeline {
+                plain: pipeline(layout, label, "", "", None, None, true),
+                hdr: None,
+            }
+        };
+        let mut flat = flat::Flat::new(&device, &terrain_layout, 4 * GRAIN, 0, 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;
@@ -199,6 +199,8 @@ pub struct FrameInputs {
    pub skybox: bool,
    pub end_sky: bool,
    pub end_sky_sprite: Option<[f32; 4]>,
+    #[serde(default)]
+    pub boss_world_fog: bool,
    pub environment_fog: Option<(f32, f32)>,
    pub water_fog: [f32; 3],
    pub fog: Option<FogData>,
@@ -414,6 +416,7 @@ impl Renderer {
                skybox: frame.skybox,
                end_sky: frame.end_sky,
                end_sky_sprite: frame.end_sky_sprite,
+                boss_world_fog: frame.boss_world_fog,
                environment_fog: frame.environment_fog,
                water_fog: frame.water_fog,
                fog: frame.fog,
@@ -510,6 +513,7 @@ impl Scene {
            skybox: f.skybox,
            end_sky: f.end_sky,
            end_sky_sprite: f.end_sky_sprite,
+            boss_world_fog: f.boss_world_fog,
            environment_fog: f.environment_fog,
            water_fog: f.water_fog,
            fog: f.fog,
@@ -530,6 +534,7 @@ impl Scene {
            visible_static_block_entity_sections: &[],
            static_block_entity_stats: Default::default(),
            entity_motion: &[],
+            entity_motion_posed: &[],
            entity_spans: &[],
            skin: None,
            glowing: &[],
@@ -0,0 +1,416 @@
+//! OptiFine custom sky layers on the GPU: one texture per layer, kept with the renderer (its pack),
+//! a static skybox mesh of the 3x2 grid's six faces, and one pipeline per blend mode. A frame
+//! uploads one small uniform per drawn layer ([`crate::custom_sky::Draw`]) and draws 36 vertices
+//! each, after the vanilla sky's disc and sunrise and before the sun, moon and stars.
+use glam::Mat4;
+use horizon_optifine::sky::{Blend, Face};
+use wgpu::util::DeviceExt;
+
+use crate::custom_sky::{CustomSky as Pack, Draw};
+
+/// The blend modes in the shader's `mode` order (custom_sky.wgsl).
+const MODES: [Blend; 9] = [
+    Blend::Add,
+    Blend::Subtract,
+    Blend::Multiply,
+    Blend::Dodge,
+    Blend::Burn,
+    Blend::Screen,
+    Blend::Replace,
+    Blend::Overlay,
+    Blend::Alpha,
+];
+
+/// Layers drawn in a frame at most; a pack's later ones wait for a frame with fewer.
+const MAX_DRAWS: usize = 32;
+/// Dynamic uniform offsets are 256-byte aligned on every backend.
+const STRIDE: u64 = 256;
+
+#[repr(C)]
+#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
+struct Uniform {
+    clip_from_sky: [[f32; 4]; 4],
+    brightness: f32,
+    mode: u32,
+    pad: [u32; 2],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
+struct Vertex {
+    position: [f32; 3],
+    uv: [f32; 2],
+    cell: [f32; 4],
+}
+
+pub(super) struct CustomSky {
+    pipelines: Vec<wgpu::RenderPipeline>,
+    layout: wgpu::BindGroupLayout,
+    sampler: wgpu::Sampler,
+    uniform: wgpu::Buffer,
+    vertices: wgpu::Buffer,
+    /// One bind group per layer texture of the pack.
+    groups: Vec<wgpu::BindGroup>,
+    /// This frame's layers: bind group and pipeline indices.
+    frame: Vec<(u16, u8)>,
+}
+
+/// The fragment's output for each mode is in custom_sky.wgsl; these factors finish it.
+fn blend(mode: Blend) -> wgpu::BlendComponent {
+    use wgpu::BlendFactor as F;
+    let (src_factor, dst_factor, operation) = match mode {
+        Blend::Add => (F::One, F::One, wgpu::BlendOperation::Add),
+        Blend::Subtract => (F::One, F::One, wgpu::BlendOperation::ReverseSubtract),
+        Blend::Multiply => (F::Zero, F::Src, wgpu::BlendOperation::Add),
+        // dst + dst * src: lightens.
+        Blend::Dodge => (F::Dst, F::One, wgpu::BlendOperation::Add),
+        // dst * (1 - src): darkens.
+        Blend::Burn => (F::Zero, F::OneMinusSrc, wgpu::BlendOperation::Add),
+        // src + dst * (1 - src) = 1 - (1 - src)(1 - dst).
+        Blend::Screen => (F::One, F::OneMinusSrc, wgpu::BlendOperation::Add),
+        Blend::Replace => (F::One, F::Zero, wgpu::BlendOperation::Add),
+        // dst * src + src * dst.
+        Blend::Overlay => (F::Dst, F::Src, wgpu::BlendOperation::Add),
+        Blend::Alpha => (F::SrcAlpha, F::OneMinusSrcAlpha, wgpu::BlendOperation::Add),
+    };
+    wgpu::BlendComponent {
+        src_factor,
+        dst_factor,
+        operation,
+    }
+}
+
+/// The skybox's 36 vertices: two triangles per face, each corner with its cell's UV.
+fn mesh() -> Vec<Vertex> {
+    let mut out = Vec::with_capacity(36);
+    for face in Face::ALL {
+        let cell = face.cell();
+        let [u0, v0, u1, v1] = cell;
+        let uv = [[u0, v0], [u1, v0], [u1, v1], [u0, v1]];
+        let corners = face.corners();
+        for i in [0, 1, 2, 0, 2, 3] {
+            out.push(Vertex {
+                position: corners[i],
+                uv: uv[i],
+                cell,
+            });
+        }
+    }
+    out
+}
+
+impl CustomSky {
+    pub(super) fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
+        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Custom sky bindings"),
+            entries: &[
+                wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
+                    ty: wgpu::BindingType::Buffer {
+                        ty: wgpu::BufferBindingType::Uniform,
+                        has_dynamic_offset: true,
+                        min_binding_size: wgpu::BufferSize::new(
+                            std::mem::size_of::<Uniform>() as u64
+                        ),
+                    },
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Texture {
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 2,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                    count: None,
+                },
+            ],
+        });
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Custom sky shader"),
+            source: wgpu::ShaderSource::Wgsl(include_str!("custom_sky.wgsl").into()),
+        });
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("Custom sky layout"),
+            bind_group_layouts: &[Some(&layout)],
+            ..Default::default()
+        });
+        let attributes = wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x2, 2 => Float32x4];
+        let pipelines = MODES
+            .iter()
+            .map(|&mode| {
+                device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                    label: Some("Custom sky layer"),
+                    layout: Some(&pipeline_layout),
+                    vertex: wgpu::VertexState {
+                        module: &shader,
+                        entry_point: Some("vs_custom_sky"),
+                        compilation_options: Default::default(),
+                        buffers: &[Some(wgpu::VertexBufferLayout {
+                            array_stride: std::mem::size_of::<Vertex>() as u64,
+                            step_mode: wgpu::VertexStepMode::Vertex,
+                            attributes: &attributes,
+                        })],
+                    },
+                    primitive: wgpu::PrimitiveState {
+                        cull_mode: None,
+                        ..Default::default()
+                    },
+                    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: &shader,
+                        entry_point: Some("fs_custom_sky"),
+                        compilation_options: Default::default(),
+                        targets: &[Some(wgpu::ColorTargetState {
+                            format,
+                            // The frame's alpha is HDR output's mark (hdr.wgsl): the sky
+                            // under the layers keeps its own.
+                            blend: Some(wgpu::BlendState {
+                                color: blend(mode),
+                                alpha: wgpu::BlendComponent {
+                                    src_factor: wgpu::BlendFactor::Zero,
+                                    dst_factor: wgpu::BlendFactor::One,
+                                    operation: wgpu::BlendOperation::Add,
+                                },
+                            }),
+                            write_mask: wgpu::ColorWrites::ALL,
+                        })],
+                    }),
+                    multiview_mask: None,
+                    cache: None,
+                })
+            })
+            .collect();
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            label: Some("Custom sky"),
+            min_filter: wgpu::FilterMode::Linear,
+            mag_filter: wgpu::FilterMode::Linear,
+            ..Default::default()
+        });
+        let uniform = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Custom sky layers"),
+            size: STRIDE * MAX_DRAWS as u64,
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        let vertices = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("Custom sky box"),
+            contents: bytemuck::cast_slice(&mesh()),
+            usage: wgpu::BufferUsages::VERTEX,
+        });
+        Self {
+            pipelines,
+            layout,
+            sampler,
+            uniform,
+            vertices,
+            groups: Vec::new(),
+            frame: Vec::new(),
+        }
+    }
+
+    /// The pack's layer textures, replacing any before.
+    pub(super) fn set_pack(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, pack: &Pack) {
+        let limit = device.limits().max_texture_dimension_2d;
+        self.groups = pack
+            .images
+            .iter()
+            .map(|image| {
+                // Too large for this GPU: a 1x1 transparent texel, so the layer draws nothing.
+                let (width, height, rgba) = if image.width <= limit && image.height <= limit {
+                    (image.width, image.height, &image.rgba[..])
+                } else {
+                    log::warn!(
+                        "custom sky texture of {}x{} too large",
+                        image.width,
+                        image.height
+                    );
+                    (1, 1, &[0u8; 4][..])
+                };
+                let texture = device.create_texture_with_data(
+                    queue,
+                    &wgpu::TextureDescriptor {
+                        label: Some("Custom sky layer"),
+                        size: wgpu::Extent3d {
+                            width,
+                            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 | wgpu::TextureUsages::COPY_DST,
+                        view_formats: &[],
+                    },
+                    wgpu::util::TextureDataOrder::LayerMajor,
+                    rgba,
+                );
+                let view = texture.create_view(&Default::default());
+                device.create_bind_group(&wgpu::BindGroupDescriptor {
+                    label: Some("Custom sky layer"),
+                    layout: &self.layout,
+                    entries: &[
+                        wgpu::BindGroupEntry {
+                            binding: 0,
+                            resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
+                                buffer: &self.uniform,
+                                offset: 0,
+                                size: wgpu::BufferSize::new(std::mem::size_of::<Uniform>() as u64),
+                            }),
+                        },
+                        wgpu::BindGroupEntry {
+                            binding: 1,
+                            resource: wgpu::BindingResource::TextureView(&view),
+                        },
+                        wgpu::BindGroupEntry {
+                            binding: 2,
+                            resource: wgpu::BindingResource::Sampler(&self.sampler),
+                        },
+                    ],
+                })
+            })
+            .collect();
+    }
+
+    /// Upload this frame's layers; `clip` is clip space from camera-relative world.
+    pub(super) fn prepare(
+        &mut self,
+        uploads: &mut super::upload::Uploads,
+        encoder: &mut wgpu::CommandEncoder,
+        clip: Mat4,
+        draws: &[Draw],
+    ) {
+        self.frame.clear();
+        for draw in draws.iter().take(MAX_DRAWS) {
+            if usize::from(draw.image) >= self.groups.len() {
+                continue;
+            }
+            let mode = MODES.iter().position(|m| *m == draw.blend).unwrap_or(0);
+            let uniform = Uniform {
+                clip_from_sky: (clip * draw.rotation).to_cols_array_2d(),
+                brightness: draw.brightness.clamp(0.0, 1.0),
+                mode: mode as u32,
+                pad: [0; 2],
+            };
+            let offset = STRIDE * self.frame.len() as u64;
+            uploads.buffer(encoder, &self.uniform, offset, bytemuck::bytes_of(&uniform));
+            self.frame.push((draw.image, mode as u8));
+        }
+    }
+
+    pub(super) fn is_drawing(&self) -> bool {
+        !self.frame.is_empty()
+    }
+
+    /// The layers [`CustomSky::prepare`] uploaded. Leaves the pass's pipeline and bind group 0
+    /// changed.
+    pub(super) fn draw(&self, pass: &mut wgpu::RenderPass<'_>) {
+        pass.set_vertex_buffer(0, self.vertices.slice(..));
+        for (i, &(image, mode)) in self.frame.iter().enumerate() {
+            pass.set_pipeline(&self.pipelines[usize::from(mode)]);
+            pass.set_bind_group(
+                0,
+                &self.groups[usize::from(image)],
+                &[(STRIDE * i as u64) as u32],
+            );
+            pass.draw(0..36, 0..1);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// What a blend leaves a sky texel of `dst` with when the shader outputs `src`
+    /// (custom_sky.wgsl) for a layer texel `t` at brightness `b`, per channel.
+    fn mix(mode: Blend, dst: f32, t: f32, a: f32, b: f32) -> f32 {
+        let k = a * b;
+        let src = match mode {
+            Blend::Multiply => 1.0 + (t - 1.0) * k,
+            Blend::Overlay => 0.5 + (t - 0.5) * k,
+            Blend::Replace | Blend::Alpha => t,
+            _ => t * k,
+        };
+        let c = blend(mode);
+        let f = |factor: wgpu::BlendFactor| match factor {
+            wgpu::BlendFactor::One => 1.0,
+            wgpu::BlendFactor::Zero => 0.0,
+            wgpu::BlendFactor::Src => src,
+            wgpu::BlendFactor::OneMinusSrc => 1.0 - src,
+            wgpu::BlendFactor::Dst => dst,
+            wgpu::BlendFactor::SrcAlpha => k,
+            wgpu::BlendFactor::OneMinusSrcAlpha => 1.0 - k,
+            other => panic!("{other:?}"),
+        };
+        let (s, d) = (src * f(c.src_factor), dst * f(c.dst_factor));
+        match c.operation {
+            wgpu::BlendOperation::Add => s + d,
+            wgpu::BlendOperation::ReverseSubtract => d - s,
+            other => panic!("{other:?}"),
+        }
+    }
+
+    #[test]
+    fn every_mode_gives_its_documented_result() {
+        let close = |a: f32, b: f32| assert!((a - b).abs() < 1e-6, "{a} != {b}");
+        // Full brightness and alpha, a sky texel of 0.4 under a layer texel of 0.8.
+        let (d, t) = (0.4, 0.8);
+        close(mix(Blend::Add, d, t, 1.0, 1.0), 1.2);
+        close(mix(Blend::Subtract, d, t, 1.0, 1.0), -0.4);
+        close(mix(Blend::Multiply, d, t, 1.0, 1.0), 0.32);
+        close(mix(Blend::Screen, d, t, 1.0, 1.0), 1.0 - 0.6 * 0.2);
+        close(mix(Blend::Replace, d, t, 1.0, 1.0), 0.8);
+        close(mix(Blend::Overlay, d, t, 1.0, 1.0), 0.64);
+        close(mix(Blend::Overlay, d, 0.2, 1.0, 1.0), 0.16);
+        close(mix(Blend::Alpha, d, t, 0.25, 1.0), 0.4 * 0.75 + 0.8 * 0.25);
+        assert!(mix(Blend::Dodge, d, t, 1.0, 1.0) > d);
+        assert!(mix(Blend::Burn, d, t, 1.0, 1.0) < d);
+        // Faded out, every mode but replace (drawn only when bright) leaves the sky alone.
+        for mode in MODES {
+            if mode != Blend::Replace {
+                close(mix(mode, d, t, 1.0, 0.0), d);
+            }
+        }
+        // Half faded: add adds half.
+        close(mix(Blend::Add, d, t, 1.0, 0.5), 0.8);
+    }
+
+    #[test]
+    fn the_shader_validates() {
+        let module = naga::front::wgsl::parse_str(include_str!("custom_sky.wgsl")).unwrap();
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::all(),
+        )
+        .validate(&module)
+        .unwrap();
+    }
+
+    #[test]
+    fn the_box_covers_every_face_with_its_cell() {
+        let mesh = mesh();
+        assert_eq!(mesh.len(), 36);
+        for v in &mesh {
+            let [u0, v0, u1, v1] = v.cell;
+            assert!((u0..=u1).contains(&v.uv[0]) && (v0..=v1).contains(&v.uv[1]));
+            assert_eq!(v.position.iter().filter(|c| c.abs() == 1.0).count(), 3);
+        }
+    }
+}
@@ -0,0 +1,61 @@
+// OptiFine custom sky layers (gfx/custom_sky.rs): one skybox per draw, its six faces cut from a
+// 3x2 texture, mixed with the sky under it by the pipeline's blend. The fragment's output is
+// chosen so that blend gives the layer's documented mode at its brightness, and a layer at
+// brightness 0 leaves the sky as it was.
+struct Layer {
+    // Projection * view (camera-relative) * the layer's rotation.
+    clip_from_sky: mat4x4<f32>,
+    brightness: f32,
+    // horizon_optifine::sky::Blend, in gfx/custom_sky.rs's MODES order.
+    mode: u32,
+}
+@group(0) @binding(0) var<uniform> layer: Layer;
+@group(0) @binding(1) var sky_texture: texture_2d<f32>;
+@group(0) @binding(2) var sky_sampler: sampler;
+
+struct Out {
+    @builtin(position) clip: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+    // The face's cell (u0, v0, u1, v1): sampling stays half a texel inside it.
+    @location(1) @interpolate(flat) cell: vec4<f32>,
+}
+
+@vertex fn vs_custom_sky(
+    @location(0) position: vec3<f32>,
+    @location(1) uv: vec2<f32>,
+    @location(2) cell: vec4<f32>,
+) -> Out {
+    var out: Out;
+    out.clip = layer.clip_from_sky * vec4(position * 100.0, 1.0);
+    out.uv = uv;
+    out.cell = cell;
+    return out;
+}
+
+const ADD: u32 = 0u;
+const SUBTRACT: u32 = 1u;
+const MULTIPLY: u32 = 2u;
+const DODGE: u32 = 3u;
+const BURN: u32 = 4u;
+const SCREEN: u32 = 5u;
+const REPLACE: u32 = 6u;
+const OVERLAY: u32 = 7u;
+const ALPHA: u32 = 8u;
+
+@fragment fn fs_custom_sky(in: Out) -> @location(0) vec4<f32> {
+    let half = 0.5 / vec2<f32>(textureDimensions(sky_texture));
+    let uv = clamp(in.uv, in.cell.xy + half, in.cell.zw - half);
+    let t = textureSample(sky_texture, sky_sampler, uv);
+    let k = t.a * layer.brightness;
+    switch layer.mode {
+        // dst * src: white leaves the sky alone.
+        case MULTIPLY: { return vec4(mix(vec3(1.0), t.rgb, k), 1.0); }
+        // 2 * dst * src: grey leaves it alone.
+        case OVERLAY: { return vec4(mix(vec3(0.5), t.rgb, k), 1.0); }
+        case REPLACE: { return vec4(t.rgb, 1.0); }
+        // mix(dst, src, alpha).
+        case ALPHA: { return vec4(t.rgb, k); }
+        // add, subtract, dodge, burn, screen: the layer premultiplied, black leaves it alone.
+        default: { return vec4(t.rgb * k, 1.0); }
+    }
+}
@@ -14,8 +14,24 @@ use super::Vertex;
 /// material at the end: the render types vanilla gives an `OitPipelineSet`
 /// (translucent, emissive, eyes and breeze wind entity models). Off, the tag is
 /// ignored and they stay in the first one, in their order.
-/// Two native world-canvas text materials follow it, NORMAL then POLYGON_OFFSET.
-const MATERIALS: usize = 12;
+/// Sorted still-fluid geometry follows, then the two native world-canvas text materials,
+/// NORMAL and POLYGON_OFFSET. Material storage order is independent of their draw stages.
+const MATERIALS: usize = 16;
+pub const TERRAIN_MODEL_SOLID_OVERLAY: u32 = 42;
+pub const TERRAIN_MODEL_CUTOUT_OVERLAY: u32 = 43;
+pub const TERRAIN_MODEL_CUTOUT_MIPPED_OVERLAY: u32 = 44;
+/// Native terrain-array UV/payloads must never enter a shared-atlas shader-pack pass.
+pub fn is_native_terrain(layer: u32) -> bool {
+    matches!(
+        layer & 0xffff,
+        FLUID_OVERLAY
+            | TERRAIN_MODEL_SOLID_OVERLAY
+            | TERRAIN_MODEL_CUTOUT_OVERLAY
+            | TERRAIN_MODEL_CUTOUT_MIPPED_OVERLAY
+    )
+}
+/// Sorted depth-writing still fluid, sampling terrain sprite arrays rather than the shared atlas.
+pub const FLUID_OVERLAY: u32 = 41;
 /// A bit of `Vertex::layer`, above the overlay (low 16 bits) and the HDR tier
 /// (bits 16 to 23): the quad's render type has an `OitPipelineSet`
 /// (`RenderTypes.entityTranslucent`, `entityTranslucentEmissive`, `eyes`,
@@ -31,7 +47,9 @@ pub const DISSOLVE_OVERLAY: u32 = 38;
 /// (`OIT_ENTITY`): improved transparency draws them in its stages.
 pub fn mark_oit(quads: &mut [Vertex]) {
    for vertex in quads {
-        vertex.layer |= OIT_ENTITY;
+        if !is_native_terrain(vertex.layer) {
+            vertex.layer |= OIT_ENTITY;
+        }
    }
 }
 /// The overlay of depth-only quads that hide water (`RenderTypes.waterMask`).
@@ -60,12 +78,21 @@ pub const WORLD_TEXT_POLYGON_OFFSET_OVERLAY: u32 = 40;
 /// The material of a quad by its overlay (`MATERIALS` order): the overlay is the layer's low 16
 /// bits, as entity.wgsl reads it; HDR output's tier rides in the high ones.
 fn material(layer: u32, oit: bool) -> usize {
+    match layer & 0xffff {
+        TERRAIN_MODEL_SOLID_OVERLAY => return 13,
+        TERRAIN_MODEL_CUTOUT_OVERLAY => return 14,
+        TERRAIN_MODEL_CUTOUT_MIPPED_OVERLAY => return 15,
+        _ => {}
+    }
+    if layer & 0xffff == FLUID_OVERLAY {
+        return 10;
+    }
    if oit && layer & OIT_ENTITY != 0 {
        return 9;
    }
    match layer & 0xffff {
-        WORLD_TEXT_OVERLAY => 10,
-        WORLD_TEXT_POLYGON_OFFSET_OVERLAY => 11,
+        WORLD_TEXT_OVERLAY => 11,
+        WORLD_TEXT_POLYGON_OFFSET_OVERLAY => 12,
        TEXT_POLYGON_OFFSET_OVERLAY => 1,
        11 => 2,
        12 => 3,
@@ -148,10 +175,10 @@ impl EntityBatch {
                }
            }
        }
-        // RenderType.text sorts alpha-blended quads from far to near. Keep
-        // both world-canvas layers after existing materials (including eyes
-        // moved out of additive); front text uses polygon offset.
-        for runs in &self.runs[10..] {
+        // Fluid and RenderType.text sort their own alpha-blended quads far to
+        // near. Fluid precedes both world-canvas layers, after existing materials
+        // (including eyes moved out of additive).
+        for runs in &self.runs[10..13] {
            let start = self.combined.len();
            for &(first, count) in runs {
                self.combined
@@ -169,6 +196,13 @@ impl EntityBatch {
                    distance(b).total_cmp(&distance(a))
                });
        }
+        // Native solid/cutout models are depth writing and keep their submission order.
+        for runs in &self.runs[13..] {
+            for &(first, count) in runs {
+                self.combined
+                    .extend_from_slice(&entities[first * 4..(first + count) * 4]);
+            }
+        }
        if self.moved_additive == 0 {
            self.combined.extend_from_slice(additive);
        } else {
@@ -189,7 +223,57 @@ mod tests {
    use super::*;
    use std::{hint::black_box, time::Instant};
    #[test]
-    fn world_canvas_sorts_after_oit_eyes_before_frame_tails() {
+    fn native_models_keep_opaque_order_and_do_not_move_existing_materials_or_tails() {
+        let quad = |layer, x| {
+            [Vertex {
+                layer,
+                pos: [x, 0.0, 0.0],
+                ..geometry(1, false)[0]
+            }; 4]
+        };
+        let entities: Vec<_> = [
+            (FLUID_OVERLAY, 10.0),
+            (WORLD_TEXT_OVERLAY, 11.0),
+            (TERRAIN_MODEL_SOLID_OVERLAY | 279 << 16, 3.0),
+            (TERRAIN_MODEL_SOLID_OVERLAY, 1.0),
+            (TERRAIN_MODEL_CUTOUT_OVERLAY, 4.0),
+            (TERRAIN_MODEL_CUTOUT_MIPPED_OVERLAY, 5.0),
+            (OIT_ENTITY, 6.0),
+            (0, 7.0),
+        ]
+        .into_iter()
+        .flat_map(|(layer, x)| quad(layer, x))
+        .collect();
+        let mut batch = EntityBatch::default();
+        let counts = batch.update(
+            &entities,
+            &quad(0, 8.0),
+            &quad(0, 9.0),
+            &quad(0, 12.0),
+            true,
+        );
+        assert_eq!(counts, [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 2, 1, 1]);
+        let xs: Vec<_> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
+        assert_eq!(
+            xs,
+            [7.0, 6.0, 10.0, 11.0, 3.0, 1.0, 4.0, 5.0, 8.0, 9.0, 12.0]
+        );
+        assert_eq!(
+            batch.combined[16].layer,
+            TERRAIN_MODEL_SOLID_OVERLAY | 279 << 16
+        );
+    }
+    #[test]
+    fn tagging_oit_does_not_corrupt_a_native_models_sprite_index() {
+        let mut vertices = [geometry(1, false)[0]; 2];
+        vertices[0].layer = TERRAIN_MODEL_CUTOUT_OVERLAY | 17 << 16;
+        vertices[1].layer = 3;
+        mark_oit(&mut vertices);
+        assert_eq!(vertices[0].layer, TERRAIN_MODEL_CUTOUT_OVERLAY | 17 << 16);
+        assert_eq!(vertices[1].layer, 3 | OIT_ENTITY);
+    }
+    #[test]
+    fn fluid_and_world_canvas_sort_after_oit_eyes_before_frame_tails() {
        let quad = |layer, x| {
            [Vertex {
                layer,
@@ -204,6 +288,8 @@ mod tests {
            (WORLD_TEXT_OVERLAY, 4.0),
            (WORLD_TEXT_OVERLAY, 5.0),
            (WORLD_TEXT_POLYGON_OFFSET_OVERLAY, 6.0),
+            (FLUID_OVERLAY, 11.0),
+            (FLUID_OVERLAY | OIT_ENTITY, 12.0),
        ]
        .into_iter()
        .flat_map(|(layer, x)| quad(layer, x))
@@ -215,12 +301,14 @@ mod tests {
        let mut batch = EntityBatch::default();
        assert_eq!(
            batch.update(&entities, &additive, &quad(0, 9.0), &quad(0, 10.0), true),
-            [1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 1]
+            [1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 1, 0, 0, 0]
        );
        let positions: Vec<_> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
        assert_eq!(
            positions,
-            [1.0, 2.0, 3.0, 7.0, 5.0, 4.0, 6.0, 8.0, 9.0, 10.0]
+            [
+                1.0, 2.0, 3.0, 7.0, 12.0, 11.0, 5.0, 4.0, 6.0, 8.0, 9.0, 10.0
+            ]
        );
    }

@@ -320,12 +408,12 @@ mod tests {
        let mut batch = EntityBatch::default();
        // Off: the tag changes nothing, the quads keep their place.
        let counts = batch.update(&entities, &[], &[], &[], false);
-        assert_eq!(counts, [4, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]);
+        assert_eq!(counts, [4, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
        let xs: Vec<f32> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
        assert_eq!(xs, [0.0, 1.0, 2.0, 4.0, 3.0]);
        // On: the tagged quads come last, in order.
        let counts = batch.update(&entities, &[], &[], &[], true);
-        assert_eq!(counts, [2, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0]);
+        assert_eq!(counts, [2, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0]);
        let xs: Vec<f32> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
        assert_eq!(xs, [0.0, 2.0, 3.0, 1.0, 4.0]);
    }
@@ -17,6 +17,7 @@
 //! copied after the test, which tells which ones it saw: each run of a page
 //! reserves room for all of its draws, the copy packs the seen ones at its
 //! start, and the run is drawn indirectly with the count the copy reached.
+use super::SolidPipeline;
 use super::arena::GRAIN;

 /// One section draw for `flatten.wgsl`: index count, first sorted index (or
@@ -86,12 +87,12 @@ pub struct Call {
 pub struct Flat {
    /// The solid draws in one pass (`fs_solid`), where the GPU doesn't hide pixels
    /// by tiles (`split_solid` in `Renderer::draw_frame`: elsewhere than Metal).
-    pub solid: wgpu::RenderPipeline,
+    pub solid: SolidPipeline,
    /// The solid draws in two passes, each over its own part of the draws (terrain.wgsl's
    /// `opaque_quad`): the quads with no cutout first, through a shader that never discards,
    /// then the rest.
-    pub solid_opaque: wgpu::RenderPipeline,
-    pub solid_cutout: wgpu::RenderPipeline,
+    pub solid_opaque: SolidPipeline,
+    pub solid_cutout: SolidPipeline,
    /// The solid draws as the water mirror's camera draws them (`fs_solid_mirror`).
    pub solid_mirror: wgpu::RenderPipeline,
    pub translucent: wgpu::RenderPipeline,
@@ -357,7 +358,8 @@ fn plan(
 impl Flat {
    /// `pipeline(layout, label, vertex entry, fragment entry, blend, cull, pulled)` builds a
    /// terrain pipeline as the per-section ones, without the origin buffer, and without
-    /// vertex buffers when `pulled` (its vertex shader reads the page, `ARENA_BINDING`).
+    /// vertex buffers when `pulled` (its vertex shader reads the page, `ARENA_BINDING`);
+    /// `solid(layout, label, vertex entry, fragment entry)` a pulled solid one.
    pub fn new(
        device: &wgpu::Device,
        terrain_layout: &wgpu::BindGroupLayout,
@@ -372,6 +374,7 @@ impl Flat {
            Option<wgpu::Face>,
            bool,
        ) -> wgpu::RenderPipeline,
+        solid: impl Fn(&wgpu::PipelineLayout, &str, &str, &str) -> SolidPipeline,
    ) -> Self {
        let vertex = wgpu::ShaderStages::VERTEX;
        let compute = wgpu::ShaderStages::COMPUTE;
@@ -432,32 +435,23 @@ impl Flat {
        Self {
            // The solid draws read either layout of the solid quads (`mesher::packed`) from
            // the page; translucent ones keep their vertex buffer.
-            solid: pipeline(
+            solid: solid(
                &layout,
                "Terrain solid (flat)",
                "vs_section_flat",
                "fs_solid",
-                None,
-                back,
-                true,
            ),
-            solid_opaque: pipeline(
+            solid_opaque: solid(
                &layout,
                "Terrain solid opaque (flat)",
                "vs_section_flat_opaque",
                "fs_opaque",
-                None,
-                back,
-                true,
            ),
-            solid_cutout: pipeline(
+            solid_cutout: solid(
                &layout,
                "Terrain solid cutout (flat)",
                "vs_section_flat_cutout",
                "fs_solid",
-                None,
-                back,
-                true,
            ),
            // The mirror flips the winding: its solid terrain culls the front.
            solid_mirror: pipeline(
@@ -0,0 +1,69 @@
+//! Sorted still-fluid material: ordinary back culling, alpha blend and color/depth writes.
+pub(super) const SAMPLER: wgpu::SamplerDescriptor<'static> = wgpu::SamplerDescriptor {
+    label: Some("Still fluid (nearest texels, linear mipmaps)"),
+    address_mode_u: wgpu::AddressMode::ClampToEdge,
+    address_mode_v: wgpu::AddressMode::ClampToEdge,
+    address_mode_w: wgpu::AddressMode::ClampToEdge,
+    mag_filter: wgpu::FilterMode::Nearest,
+    min_filter: wgpu::FilterMode::Nearest,
+    mipmap_filter: wgpu::MipmapFilterMode::Linear,
+    lod_min_clamp: 0.0,
+    lod_max_clamp: 32.0,
+    compare: None,
+    anisotropy_clamp: 1,
+    border_color: None,
+};
+
+pub(super) fn pipeline(
+    device: &wgpu::Device,
+    layout: Option<&wgpu::PipelineLayout>,
+    shader: &wgpu::ShaderModule,
+    format: wgpu::TextureFormat,
+    constants: &[(&str, f64)],
+) -> wgpu::RenderPipeline {
+    let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2];
+    device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: Some("Still fluid"),
+        layout,
+        vertex: wgpu::VertexState {
+            module: shader,
+            entry_point: Some("vs_native_fluid"),
+            compilation_options: wgpu::PipelineCompilationOptions {
+                constants,
+                ..Default::default()
+            },
+            buffers: &[Some(wgpu::VertexBufferLayout {
+                array_stride: std::mem::size_of::<super::Vertex>() as u64,
+                step_mode: wgpu::VertexStepMode::Vertex,
+                attributes: &attributes,
+            })],
+        },
+        primitive: wgpu::PrimitiveState {
+            cull_mode: Some(wgpu::Face::Back),
+            ..Default::default()
+        },
+        depth_stencil: Some(wgpu::DepthStencilState {
+            format: wgpu::TextureFormat::Depth32Float,
+            depth_write_enabled: Some(true),
+            depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
+            stencil: Default::default(),
+            bias: Default::default(),
+        }),
+        multisample: Default::default(),
+        fragment: Some(wgpu::FragmentState {
+            module: shader,
+            entry_point: Some("fs_native_fluid"),
+            compilation_options: wgpu::PipelineCompilationOptions {
+                constants,
+                ..Default::default()
+            },
+            targets: &[Some(wgpu::ColorTargetState {
+                format,
+                blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+                write_mask: wgpu::ColorWrites::ALL,
+            })],
+        }),
+        multiview_mask: None,
+        cache: None,
+    })
+}
@@ -162,11 +162,13 @@ fn horizon_material_color(in: HorizonMaterialOut, translucent: bool) -> vec4<f32
    horizon_material_face_normal = normal;
    horizon_surface = vec4<f32>(0.0);
    let tangent = horizon_material_tangent(in.base, in.uv, normal);
-    return material(MaterialInput(albedo, in.tint, in.light, in.lightmap, in.position, in.uv,
-        translucent, horizon_sprite_tags(in.layer & 0x7fffu),
+    let out = material(MaterialInput(vec4(horizon_line_in(albedo.rgb), albedo.a),
+        vec4(horizon_line_in(in.tint.rgb), in.tint.a), in.light, horizon_line_in(in.lightmap),
+        in.position, in.uv, translucent, horizon_sprite_tags(in.layer & 0x7fffu),
        horizon_sprite_material(in.layer & 0x7fffu), in.clip.xy / frame.resolution,
        in.face, fluid, in.emission, normal, tangent,
-        horizon_terrain_native_colored_light(in.position), in.displaced)).color;
+        horizon_line_in(horizon_terrain_native_colored_light(in.position)), in.displaced)).color;
+    return vec4(horizon_line_out(out.rgb), out.a);
 }
 var<private> horizon_material_face_normal: vec3<f32>;
 struct HorizonMaterialSolid {
@@ -332,7 +334,7 @@ fn horizon_material_displace(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: v
    let fluid = high >= 8u && (high & 7u) < 6u;
    let lit = min(vec2(f32(light.y), f32(light.x)) / 240.0, vec2(1.0));
    return vertex(VertexInput(pos, uv, horizon_sprite_material(layer & 0x7fffu), lit,
-        vec4(color.rgb, 1.0), select(0u, high & 7u, fluid), u32(fluid)));
+        vec4(horizon_line_in(color.rgb), 1.0), select(0u, high & 7u, fluid), u32(fluid)));
 }
 ";

@@ -349,12 +351,13 @@ fn shader_source(
    source: &str,
    tags: &[(u32, u32)],
    materials: &[(u32, u32)],
-    vertex: bool,
-    displaced: bool,
+    (vertex, displaced): (bool, bool),
+    api: horizon_shader_api::Api,
 ) -> String {
    format!(
-        "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{}{}{}{ENTRIES}{}{}",
+        "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{}{}{}{}{ENTRIES}{}{}",
        vanilla_terrain(),
+        super::native_post::line_helpers(api),
        if vertex {
            DISPLACE_PACK
        } else {
@@ -378,8 +381,9 @@ fn module(
    materials: &[(u32, u32)],
    vertex: bool,
    displaced: bool,
+    api: horizon_shader_api::Api,
 ) -> Result<naga::Module, String> {
-    let text = shader_source(&stage.source, tags, materials, vertex, displaced);
+    let text = shader_source(&stage.source, tags, materials, (vertex, displaced), api);
    naga::front::wgsl::parse_str(&text)
        .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))
 }
@@ -403,6 +407,7 @@ impl NativeMaterial {
            shape.sprite_materials,
            vertex,
            displaced.is_some(),
+            frame.api,
        )?;
        let mut constants = present_constants(&module, constants);
        let sprite_names = [
@@ -562,7 +567,7 @@ impl NativeMaterial {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use horizon_shader_api::{MANIFEST, Pack, StageKind, check};
+    use horizon_shader_api::{Api, MANIFEST, Pack, StageKind, check};

    fn stage(material: &str) -> CheckedStage {
        let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\
@@ -609,7 +614,7 @@ mod tests {
        let tags = [(7, 1), (3, 1), (9, 2)];
        let materials = [(5, 1000)];
        assert!(layer_table("t", &tags).contains("case 3u, 7u: { return 1u; }"));
-        let module = module(&stage, &tags, &materials, false, false).unwrap();
+        let module = module(&stage, &tags, &materials, false, false, Api::V0_1).unwrap();
        let info = naga::valid::Validator::new(
            naga::valid::ValidationFlags::all(),
            naga::valid::Capabilities::all(),
@@ -622,8 +627,8 @@ mod tests {
                    &stage.source,
                    &tags,
                    &materials,
-                    false,
-                    false
+                    (false, false),
+                    Api::V0_1
                ))
            )
        });
@@ -647,6 +652,33 @@ mod tests {
        );
    }

+    /// The terrain shader of a 0.2 pack with a vertex stage, whose tint the renderer decodes.
+    #[test]
+    fn the_terrain_validates_with_a_0_2_pack() {
+        let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.2\"\n\
+            [material]\nfile = \"material.wgsl\"\n[vertex]\nfile = \"vertex.wgsl\"\n";
+        let material = "fn material(input: MaterialInput) -> Surface {\n    \
+                return Surface(input.albedo * input.tint * vec4(input.colored_light, 1.0));\n}\n";
+        let vertex = "fn vertex(input: VertexInput) -> vec3<f32> {\n    \
+                return input.position + input.tint.rgb;\n}\n";
+        let files = [
+            (MANIFEST, manifest),
+            ("material.wgsl", material),
+            ("vertex.wgsl", vertex),
+        ]
+        .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec()))
+        .into();
+        let report = check(&Pack::from_files(files).unwrap()).unwrap();
+        let stage = report.stages.iter().find(|s| s.kind == StageKind::Material);
+        let module = module(stage.unwrap(), &[], &[], true, false, Api::V0_2).unwrap();
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::all(),
+        )
+        .validate(&module)
+        .unwrap();
+    }
+
    #[test]
    fn the_displaced_grid_validates_with_a_pack() {
        let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\
@@ -661,14 +693,14 @@ mod tests {
        let mut report = check(&Pack::from_files(files).unwrap()).unwrap();
        let stage = report.stages.remove(0);
        let materials = [(5, 1000)];
-        let module = module(&stage, &[], &materials, false, true).unwrap();
+        let module = module(&stage, &[], &materials, false, true, Api::V0_1).unwrap();
        naga::valid::Validator::new(
            naga::valid::ValidationFlags::all(),
            naga::valid::Capabilities::all(),
        )
        .validate(&module)
        .unwrap_or_else(|e| {
-            let text = shader_source(&stage.source, &[], &materials, false, true);
+            let text = shader_source(&stage.source, &[], &materials, (false, true), Api::V0_1);
            panic!("{}", e.emit_to_string(&text))
        });
        for entry in [
@@ -681,4 +713,116 @@ mod tests {
            );
        }
    }
+
+    /// An identity material (vanilla's own lighting, `albedo * tint * lightmap`) under 0.2,
+    /// its colours decoded on the way in and encoded on the way out as the entries do, draws
+    /// what 0.1's does (vanilla's) within an 8-bit step.
+    #[test]
+    fn an_identity_0_2_material_is_vanilla_s_within_an_8_bit_step() {
+        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;
+        };
+        // The entries' call of `material`, with a 16×16 grid of colours.
+        let entry = "@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
+    return vec4<f32>(vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u)) * 2.0 - 1.0, 0.0, 1.0);
+}
+@fragment fn fs(@builtin(position) p: vec4<f32>) -> @location(0) vec4<f32> {
+    let c = floor(p.xy) / 15.0;
+    let albedo = vec4(c.x, c.y, 1.0 - c.x, 1.0);
+    let tint = vec4(0.9, 1.0 - 0.5 * c.y, 0.7, 1.0);
+    let lightmap = vec3(c.y, 0.8, 1.0 - c.y);
+    let out = material(MaterialInput(vec4(horizon_line_in(albedo.rgb), albedo.a),
+        vec4(horizon_line_in(tint.rgb), tint.a), vec2(1.0), horizon_line_in(lightmap),
+        vec3(0.0), vec2(0.0), false, 0u, 0u, vec2(0.0), 0u, 0u, 0.0, vec3(0.0, 1.0, 0.0),
+        vec4(1.0, 0.0, 0.0, 1.0), horizon_line_in(vec3(0.0)), 0.0)).color;
+    return vec4(horizon_line_out(out.rgb), out.a);
+}
+";
+        let vanilla = "fn material(input: MaterialInput) -> Surface {\n    \
+            return Surface(input.albedo * input.tint * vec4(input.lightmap, 1.0));\n}\n";
+        let format = wgpu::TextureFormat::Rgba8Unorm;
+        let draw = |api: Api| {
+            let manifest = format!(
+                "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"{api}\"\n\
+                 [material]\nfile = \"material.wgsl\"\n"
+            );
+            let files = [(MANIFEST, manifest.as_str()), ("material.wgsl", vanilla)]
+                .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec()))
+                .into();
+            let report = check(&Pack::from_files(files).unwrap()).unwrap();
+            let source = report.stages[0].source.clone()
+                + horizon_shader_api::stages::PBR_STUB
+                + super::super::native_post::line_helpers(api)
+                + entry;
+            let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+                label: None,
+                source: wgpu::ShaderSource::Wgsl(source.into()),
+            });
+            let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                label: None,
+                layout: None,
+                vertex: wgpu::VertexState {
+                    module: &module,
+                    entry_point: Some("vs"),
+                    compilation_options: Default::default(),
+                    buffers: &[],
+                },
+                primitive: Default::default(),
+                depth_stencil: None,
+                multisample: Default::default(),
+                fragment: Some(wgpu::FragmentState {
+                    module: &module,
+                    entry_point: Some("fs"),
+                    compilation_options: Default::default(),
+                    targets: &[Some(format.into())],
+                }),
+                multiview_mask: None,
+                cache: None,
+            });
+            let size = wgpu::Extent3d {
+                width: 16,
+                height: 16,
+                depth_or_array_layers: 1,
+            };
+            let target = device.create_texture(&wgpu::TextureDescriptor {
+                label: None,
+                size,
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format,
+                usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+                view_formats: &[],
+            });
+            let view = target.create_view(&Default::default());
+            let mut encoder = device.create_command_encoder(&Default::default());
+            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &view,
+                    resolve_target: None,
+                    depth_slice: None,
+                    ops: Default::default(),
+                })],
+                ..Default::default()
+            });
+            pass.set_pipeline(&pipeline);
+            pass.draw(0..3, 0..1);
+            drop(pass);
+            let screenshot = crate::gfx::copy_frame(&device, &mut encoder, &target, [16, 16]);
+            queue.submit([encoder.finish()]);
+            screenshot
+                .slice(..)
+                .map_async(wgpu::MapMode::Read, |r| r.unwrap());
+            device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+            screenshot.slice(..).get_mapped_range().unwrap().to_vec()
+        };
+        let (old, new) = (draw(Api::V0_1), draw(Api::V0_2));
+        let worst = old.iter().zip(&new).map(|(a, b)| a.abs_diff(*b)).max();
+        assert!(worst.is_some_and(|w| w <= 1), "{worst:?}");
+    }
 }
@@ -101,7 +101,15 @@ impl NativePack {
        let settings = chosen
            .as_ref()
            .map(|settings| super::native_shadow::fitted(device, settings));
-        let mut frame = NativeFrame::new(device, settings.as_ref(), textures, lights, terrain.pbr);
+        let api = report.manifest.api;
+        let mut frame = NativeFrame::new(
+            device,
+            settings.as_ref(),
+            textures,
+            lights,
+            terrain.pbr,
+            api,
+        );
        // `[displacement]`, unless its option is off; nothing to displace without heights.
        let displacement = report
            .manifest
@@ -222,8 +230,13 @@ impl NativePack {
                )
            })
            .transpose()?;
-        let post = (!post.is_empty())
-            .then(|| NativePost::new(device, post, &report.manifest, constants, format, &frame))
+        // A 0.2 pack always has one: its decode and tonemap run without a chain too.
+        let tonemap = others.iter().find(|s| s.kind == StageKind::Tonemap);
+        let post = (!post.is_empty() || api == horizon_shader_api::Api::V0_2)
+            .then(|| {
+                let manifest = &report.manifest;
+                NativePost::new(device, post, manifest, constants, format, &frame, tonemap)
+            })
            .transpose()?;
        let mut labels: Vec<String> = sky.iter().map(|s| s.label.clone()).collect();
        labels.extend(
@@ -6,7 +6,7 @@
 //! draw lists (`ShadowView`) serve both; the map's texels are distorted toward the camera as the
 //! prelude's `shadow_position` undoes.

-use horizon_shader_api::{Frame as FrameInputs, manifest::Shadow as Settings, stages::GROUP};
+use horizon_shader_api::{Api, Frame as FrameInputs, manifest::Shadow as Settings, stages::GROUP};
 use horizon_shaders::Shadow;

 use super::native_material::TerrainShape;
@@ -75,7 +75,7 @@ fn horizon_shadow_cutout(in: HorizonShadowOut) {
@fragment fn horizon_shadow_fs_translucent(in: HorizonShadowOut) -> @location(0) vec4<f32> {
    let color = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu);
    if color.a < 0.01 { discard; }
-    return vec4(color.rgb * in.tint, select(min(color.a, 0.99), 1.0, in.fluid != 0u));
+    return vec4(horizon_line_in(color.rgb * in.tint), select(min(color.a, 0.99), 1.0, in.fluid != 0u));
 }
 ";

@@ -152,8 +152,13 @@ pub struct ShadowGrid<'a> {
    pub normals: &'a wgpu::TextureView,
 }

-/// `shadow_color`'s format.
-const SHADOW_COLOR: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
+/// `shadow_color`'s format: under 0.2 it holds linear light, which 8 bits would band.
+fn shadow_color(api: Api) -> wgpu::TextureFormat {
+    match api {
+        Api::V0_1 => wgpu::TextureFormat::Rgba8Unorm,
+        Api::V0_2 => super::native_post::INTERMEDIATE,
+    }
+}

 /// The shader pack's shadow camera for `settings`: orthographic over `distance` each side,
 /// staying put while the camera walks a `SNAP`-block cell. The map is distorted about its
@@ -218,7 +223,7 @@ pub struct ShadowMap {
 }

 impl ShadowMap {
-    pub fn new(device: &wgpu::Device, settings: Option<&Settings>) -> Self {
+    pub fn new(device: &wgpu::Device, settings: Option<&Settings>, api: Api) -> Self {
        let size = settings.map_or(1, |s| s.resolution);
        let texture = |label, format, usage| {
            device.create_texture(&wgpu::TextureDescriptor {
@@ -250,7 +255,7 @@ impl ShadowMap {
        );
        let color = texture(
            "Native shader pack shadow colour",
-            SHADOW_COLOR,
+            shadow_color(api),
            wgpu::TextureUsages::empty(),
        );
        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
@@ -474,6 +479,7 @@ fn shader_source(
    vertex: Option<&str>,
    materials: &[(u32, u32)],
    grid: Option<&str>,
+    api: Api,
 ) -> String {
    let table = super::native_material::layer_table("horizon_sprite_material", materials);
    let (head, displace) = match (grid, vertex) {
@@ -504,11 +510,12 @@ fn shader_source(
        ),
    };
    format!(
-        "{head}// Horizon's terrain (terrain.wgsl)\n{}{solid}{displace}{ENTRIES}",
+        "{head}// Horizon's terrain (terrain.wgsl)\n{}{solid}{}{displace}{ENTRIES}",
        prefixed(
            section(TERRAIN, "struct Globals {", "// Sky (SkyRenderer)"),
            PREFIX
-        )
+        ),
+        super::native_post::line_helpers(api)
    )
 }

@@ -527,6 +534,7 @@ impl NativeShadow {
            vertex.map(|s| s.source.as_str()),
            shape.sprite_materials,
            grid.as_ref().map(|g| g.material.source.as_str()),
+            frame.api,
        );
        let module = naga::front::wgsl::parse_str(&text)
            .map_err(|e| format!("shadow pass: {}", e.emit_to_string(&text)))?;
@@ -613,7 +621,7 @@ impl NativeShadow {
            attributes: &instance_attributes,
        };
        let color_target = [Some(wgpu::ColorTargetState {
-            format: SHADOW_COLOR,
+            format: shadow_color(frame.api),
            blend: None,
            write_mask: wgpu::ColorWrites::ALL,
        })];
@@ -731,8 +739,9 @@ mod tests {

    #[test]
    fn the_shadow_shader_validates() {
-        for materials in [&[][..], &[(3, 7), (4, 8), (9, 7)][..]] {
-            let text = shader_source(&shadow_solid(materials, &[7]), None, materials, None);
+        let lines = [Api::V0_1, Api::V0_2];
+        for (materials, api) in [&[][..], &[(3, 7), (4, 8), (9, 7)][..]].iter().zip(lines) {
+            let text = shader_source(&shadow_solid(materials, &[7]), None, materials, None, api);
            let module = naga::front::wgsl::parse_str(&text).unwrap();
            naga::valid::Validator::new(
                naga::valid::ValidationFlags::all(),
@@ -767,6 +776,7 @@ mod tests {
            None,
            &materials,
            Some(&stage.source),
+            Api::V0_1,
        );
        let module = naga::front::wgsl::parse_str(&text)
            .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
@@ -17,7 +17,8 @@ const PREFIX: &str = "horizon_sky_";
 const PACK_ENTRY: &str = "
@fragment fn horizon_sky_fs_pack(in: horizon_sky_SkyOut) -> @location(0) vec4<f32> {
    let d = horizon_sky_view_ray(in.ndc);
-    return vec4(sky(SkyInput(d, vec4(horizon_sky_sky_along_ray(d), 1.0))).rgb, 1.0);
+    let color = vec4(horizon_line_in(horizon_sky_sky_along_ray(d)), 1.0);
+    return vec4(horizon_line_out(sky(SkyInput(d, color)).rgb), 1.0);
 }
 ";

@@ -38,10 +39,11 @@ fn vanilla_sky() -> String {
 }

 /// The sky shader for the pack's sky stage `source`.
-fn shader_source(source: &str) -> String {
+fn shader_source(source: &str, api: horizon_shader_api::Api) -> String {
    format!(
-        "{source}\n// Horizon's sky (terrain.wgsl)\n{}{PACK_ENTRY}",
-        vanilla_sky()
+        "{source}\n// Horizon's sky (terrain.wgsl)\n{}{}{PACK_ENTRY}",
+        vanilla_sky(),
+        super::native_post::line_helpers(api)
    )
 }

@@ -99,7 +101,7 @@ fn build(
    frame: &NativeFrame,
    stage: &CheckedStage,
 ) -> Result<(naga::Module, wgpu::PipelineLayout), String> {
-    let text = shader_source(&stage.source);
+    let text = shader_source(&stage.source, frame.api);
    let module = naga::front::wgsl::parse_str(&text)
        .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))?;
    let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] = Default::default();
@@ -195,7 +197,7 @@ mod tests {
        // A pack may use the renderer's names for its own things.
        let own = "override gain: f32;\nconst PI: f32 = 3.0;\nfn view_ray() -> f32 { return PI; }\n\
            fn sky(input: SkyInput) -> vec4<f32> { return input.color * gain * view_ray(); }\n";
-        let text = shader_source(&stage(own).source);
+        let text = shader_source(&stage(own).source, horizon_shader_api::Api::V0_1);
        let module = naga::front::wgsl::parse_str(&text).unwrap_or_else(|e| {
            panic!("{}", e.emit_to_string(&text));
        });
@@ -252,7 +254,14 @@ mod tests {
                resource: globals_buffer.as_entire_binding(),
            }],
        });
-        let frame = NativeFrame::new(&device, None, Vec::new(), Default::default(), None);
+        let frame = NativeFrame::new(
+            &device,
+            None,
+            Vec::new(),
+            Default::default(),
+            None,
+            horizon_shader_api::Api::V0_1,
+        );
        queue.write_buffer(
            &frame.buffer,
            0,
@@ -217,6 +217,41 @@ impl CenterDepth {
        })
    }

+    /// Once the GPU has finished the frame (`screenshot-sequence`), the depth it copied, as
+    /// the next frame reads it: an error unless exactly that one sample was read back, never
+    /// an older one.
+    pub fn take_completed(&mut self, device: &wgpu::Device) -> Result<f32, String> {
+        device
+            .poll(wgpu::PollType::Poll)
+            .map_err(|e| e.to_string())?;
+        let state = |s: &Slot| s.state.load(Ordering::Acquire);
+        let mut mapped = self.slots.iter().filter(|s| state(s) == MAPPED);
+        let (Some(slot), None) = (mapped.next(), mapped.next()) else {
+            return Err("the frame's centre depth wasn't read back alone".into());
+        };
+        if self
+            .slots
+            .iter()
+            .any(|s| !matches!(state(s), FREE | MAPPED))
+        {
+            return Err("the frame's centre depth wasn't read back alone".into());
+        }
+        let depth = slot
+            .buffer
+            .slice(..4)
+            .get_mapped_range()
+            .map(|bytes| bytemuck::pod_read_unaligned::<f32>(&bytes[..4]))
+            .map_err(|e| e.to_string());
+        slot.buffer.unmap();
+        slot.state.store(FREE, Ordering::Release);
+        let depth = depth?;
+        if !depth.is_finite() {
+            return Err("the centre depth isn't finite".into());
+        }
+        self.latest = Some(depth.clamp(0.0, 1.0));
+        Ok(depth.clamp(0.0, 1.0))
+    }
+
    /// The newest depth read back so far, `None` before the first arrives.
    pub fn collect(&mut self, device: &wgpu::Device) -> Option<f32> {
        let _ = device.poll(wgpu::PollType::Poll);
@@ -265,6 +300,76 @@ mod tests {
        });
    }

+    /// Inline and on the submit thread: each finished frame's depth, then none left to
+    /// take; several outstanding samples are refused.
+    #[test]
+    #[ignore = "requires a host GPU"]
+    fn a_finished_frame_s_depth_is_taken_alone_never_an_older_one() {
+        let (device, raw) = test_device().expect("host GPU required");
+        let depth = device.create_texture(&wgpu::TextureDescriptor {
+            label: None,
+            size: wgpu::Extent3d {
+                width: 3,
+                height: 3,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: wgpu::TextureFormat::Depth32Float,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
+            view_formats: &[],
+        });
+        let view = depth.create_view(&Default::default());
+        for threaded in [false, true] {
+            let queue = super::super::submit::Queue::new(raw.clone(), threaded);
+            if threaded {
+                assert!(queue.threaded(), "deferred submit unavailable");
+            }
+            let mut center = CenterDepth::new(&device);
+            assert!(center.take_completed(&device).is_err());
+            for value in [0.125, 0.75, 0.25] {
+                let mut encoder = device.create_command_encoder(&Default::default());
+                clear(&mut encoder, &view, value);
+                center.copy(&device, &mut encoder, &depth);
+                let after = center.submitted().expect("one copied sample");
+                if threaded {
+                    let job = super::super::submit::Job {
+                        encoder,
+                        surface: None,
+                        after: Some(Box::new(after)),
+                    };
+                    assert!(queue.submit_later(job).is_ok());
+                    queue.wait();
+                } else {
+                    queue.submit([encoder.finish()]);
+                    after();
+                }
+                device
+                    .poll(wgpu::PollType::Wait {
+                        submission_index: None,
+                        timeout: Some(std::time::Duration::from_secs(30)),
+                    })
+                    .unwrap();
+                assert_eq!(center.take_completed(&device).unwrap(), value);
+                assert_eq!(center.collect(&device), Some(value));
+                assert!(
+                    center.take_completed(&device).is_err(),
+                    "no stale latest fallback"
+                );
+            }
+            // Several outstanding copies are ambiguous, even after they all map.
+            let mut encoder = device.create_command_encoder(&Default::default());
+            for _ in 0..SLOTS {
+                center.copy(&device, &mut encoder, &depth);
+            }
+            queue.submit([encoder.finish()]);
+            center.submitted().unwrap()();
+            device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+            assert!(center.take_completed(&device).is_err());
+        }
+    }
+
    /// Frames that go to the submit thread start their readback there: the centre depth
    /// follows the frames instead of keeping the first ones' depth.
    #[test]
@@ -32,13 +32,28 @@ pub fn buffers() -> [Option<wgpu::VertexBufferLayout<'static>>; 1] {
 /// 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.
 pub fn inputs() -> horizon_shaders::GbuffersInputs {
-    let declarations = "layout(location = 0) in vec3 hz_v_pos;\nlayout(location = 1) in vec2 hz_v_uv;\n\
+    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\
         layout(location = 2) in uint hz_v_overlay;\nlayout(location = 3) in vec4 hz_v_color;\n\
         layout(location = 4) in uvec4 hz_v_light;\nlayout(location = 5) in vec4 hz_v_normal;\n\
         layout(set = 1, binding = 0) readonly buffer HzEntityVertices { uint hz_entity_vertices[]; };\n\
         vec4 hz_tangent; vec2 hz_mid;\n"
        .to_owned();
-    let words = std::mem::size_of::<Vertex>() / 4;
+    // `at_velocity`: the vertex's offset from last frame in view space, this frame's view
+    // position less last frame's. Last frame's vertices stay at binding 2, relative to last
+    // frame's camera, and binding 3 gives each vertex its index there (none: no velocity).
+    declarations.push_str(&format!(
+        "layout(set = 1, binding = 2) readonly buffer HzEntityPrevious {{ uint hz_entity_previous[]; }};\n\
+         layout(set = 1, binding = 3) readonly buffer HzEntityPreviousIndex {{ uint hz_previous_index[]; }};\n\
+         uint hz_vi;\n\
+         vec3 hz_velocity(mat4 view, mat4 previous_view) {{\n    \
+             uint p = hz_previous_index[hz_vi];\n    \
+             if (p == 0xffffffffu) return vec3(0.0);\n    \
+             uint w = p * {words}u;\n    \
+             vec3 then = uintBitsToFloat(uvec3(hz_entity_previous[w], hz_entity_previous[w + 1u], hz_entity_previous[w + 2u]));\n    \
+             return (view * vec4(hz_v_pos, 1.0)).xyz - (previous_view * vec4(then, 1.0)).xyz;\n\
+         }}\n"
+    ));
    let corner = |k: usize, field: &str| {
        let at = |o: usize| format!("hz_entity_vertices[hz_q + {}u]", k * words + o);
        match field {
@@ -47,7 +62,8 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
        }
    };
    let body = format!(
-        "    uint hz_q = (uint(gl_VertexIndex) & ~3u) * {words}u;\n    \
+        "    hz_vi = uint(gl_VertexIndex);\n    \
+         uint hz_q = (uint(gl_VertexIndex) & ~3u) * {words}u;\n    \
         vec3 hz_e1 = {p1} - {p0};\n    \
         vec3 hz_e2 = {p2} - {p0};\n    \
         vec2 hz_t0 = {t0};\n    \
@@ -87,6 +103,10 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
        ("vaUV2", "ivec2(hz_MultiTexCoord1.xy)"),
        ("vaColor", "hz_Color"),
        ("vaNormal", "hz_Normal"),
+        (
+            "at_velocity",
+            "hz_velocity(gbufferModelView, gbufferPreviousModelView)",
+        ),
    ];
    horizon_shaders::GbuffersInputs {
        declarations,
@@ -229,7 +249,15 @@ impl Casters {
 /// The vertices and per-draw uniforms of the runs a pack draws, rebuilt each frame.
 pub(super) struct PackEntities {
    vertices: wgpu::Buffer,
-    /// Set 1: the vertices again, for the quads' corners.
+    /// Last frame's `vertices` (the two swap each frame), for `at_velocity`.
+    previous: wgpu::Buffer,
+    /// For each of `vertices`, its index in `previous` (`NO_PREVIOUS`: none).
+    previous_index: wgpu::Buffer,
+    /// This frame's entities (`Frame::entity_motion`) and last frame's.
+    motion: Motion,
+    previous_motion: Motion,
+    index_scratch: Vec<u32>,
+    /// Set 1: the vertices again, for the quads' corners; last frame's and the indices into them.
    pub table: wgpu::BindGroupLayout,
    pub table_group: wgpu::BindGroup,
    slots: wgpu::Buffer,
@@ -248,23 +276,32 @@ impl PackEntities {
        let stride = SLOT.max(u64::from(
            device.limits().min_uniform_buffer_offset_alignment,
        ));
+        let entry = |binding| wgpu::BindGroupLayoutEntry {
+            binding,
+            visibility: wgpu::ShaderStages::VERTEX,
+            ty: wgpu::BindingType::Buffer {
+                ty: wgpu::BufferBindingType::Storage { read_only: true },
+                has_dynamic_offset: false,
+                min_binding_size: None,
+            },
+            count: None,
+        };
        let table = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
            label: Some("Shader pack entity vertices"),
-            entries: &[wgpu::BindGroupLayoutEntry {
-                binding: 0,
-                visibility: wgpu::ShaderStages::VERTEX,
-                ty: wgpu::BindingType::Buffer {
-                    ty: wgpu::BufferBindingType::Storage { read_only: true },
-                    has_dynamic_offset: false,
-                    min_binding_size: None,
-                },
-                count: None,
-            }],
+            entries: &[entry(0), entry(2), entry(3)],
        });
-        let (vertices, table_group) = Self::vertex_buffer(device, &table, 4096);
+        let vertices = Self::vertex_buffer(device, 4096);
+        let previous = Self::vertex_buffer(device, 4096);
+        let previous_index = Self::index_buffer(device, 4096);
+        let table_group = Self::table_group(device, &table, &vertices, &previous, &previous_index);
        let (slots, group) = Self::slot_buffer(device, layout, 64, stride);
        Self {
            vertices,
+            previous,
+            previous_index,
+            motion: Motion::default(),
+            previous_motion: Motion::default(),
+            index_scratch: Vec::new(),
            table,
            table_group,
            slots,
@@ -278,28 +315,51 @@ impl PackEntities {
        }
    }

-    fn vertex_buffer(
-        device: &wgpu::Device,
-        table: &wgpu::BindGroupLayout,
-        vertices: u64,
-    ) -> (wgpu::Buffer, wgpu::BindGroup) {
-        let buffer = device.create_buffer(&wgpu::BufferDescriptor {
+    fn vertex_buffer(device: &wgpu::Device, vertices: u64) -> wgpu::Buffer {
+        device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Shader pack entity vertices"),
            size: vertices * std::mem::size_of::<Vertex>() as u64,
            usage: wgpu::BufferUsages::VERTEX
                | wgpu::BufferUsages::STORAGE
                | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
-        });
-        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+        })
+    }
+
+    fn index_buffer(device: &wgpu::Device, vertices: u64) -> wgpu::Buffer {
+        device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Shader pack entity previous indices"),
+            size: vertices * 4,
+            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        })
+    }
+
+    fn table_group(
+        device: &wgpu::Device,
+        table: &wgpu::BindGroupLayout,
+        vertices: &wgpu::Buffer,
+        previous: &wgpu::Buffer,
+        index: &wgpu::Buffer,
+    ) -> wgpu::BindGroup {
+        device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("Shader pack entity vertices"),
            layout: table,
-            entries: &[wgpu::BindGroupEntry {
-                binding: 0,
-                resource: buffer.as_entire_binding(),
-            }],
-        });
-        (buffer, group)
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: vertices.as_entire_binding(),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 2,
+                    resource: previous.as_entire_binding(),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 3,
+                    resource: index.as_entire_binding(),
+                },
+            ],
+        })
    }

    fn slot_buffer(
@@ -359,11 +419,17 @@ impl PackEntities {
        shadow: Casters,
        rest: &mut Vec<Vertex>,
        skin: Option<&super::entity_skin::SkinFrame>,
+        motion: (&[(u32, u64)], &[u32]),
    ) {
        self.draws.clear();
        self.scratch.clear();
        self.uniforms.clear();
        rest.clear();
+        // Last frame's vertices stay for `at_velocity`; this frame's go to the other buffer.
+        std::mem::swap(&mut self.vertices, &mut self.previous);
+        std::mem::swap(&mut self.motion, &mut self.previous_motion);
+        self.motion.clear();
+        let mut copied = Vec::new();
        let posed = skin.map_or(0, |s| s.vertices);
        if let Some(skin) = skin {
            for (span, range, overlay) in skin_runs(skin) {
@@ -388,8 +454,31 @@ impl PackEntities {
        let first = spans.first().map_or(entities.len(), |s| s.start as usize);
        extend_without_portals(rest, &entities[..first.min(entities.len())]);
        let (mut other, mut portal_faces, mut beam_faces) = (Vec::new(), Vec::new(), Vec::new());
+        let mut without_fluids = Vec::new();
        for (span, range) in runs(entities.len(), spans) {
+            let run_start = range.start as u32;
            let whole = &entities[range];
+            // A native fluid carries sprite-array UVs, not shared-atlas UVs.
+            // Keep it in its own material even when a shader pack draws the
+            // model in the same block-entity run. Do not corrupt either UV space.
+            let whole: &[Vertex] = if whole
+                .chunks(4)
+                .any(|q| super::is_native_terrain(q[0].layer))
+            {
+                without_fluids.clear();
+                for quad in whole.chunks(4) {
+                    if super::is_native_terrain(quad[0].layer) {
+                        if !span.hidden {
+                            rest.extend_from_slice(quad);
+                        }
+                    } else {
+                        without_fluids.extend_from_slice(quad);
+                    }
+                }
+                &without_fluids
+            } else {
+                whole
+            };
            // A block entity's run can hold End portal faces and beams beside plain parts (an End
            // gateway: its cube and its beam): each goes to its own program.
            // Beacon beams come in a run of their own, at stage NONE (game.rs: no stage of 5.4
@@ -444,6 +533,10 @@ impl PackEntities {
                    Part::Beam => beam_segments(run, &mut self.scratch),
                    _ => self.scratch.extend_from_slice(run),
                }
+                // A run copied whole: its vertices keep their order, for `at_velocity`.
+                if !split {
+                    copied.push((run_start, posed + start, run.len() as u32));
+                }
                if program == DESTROY {
                    project_cracks(&mut self.scratch[start as usize..], crack.0, crack.1);
                }
@@ -468,6 +561,14 @@ impl PackEntities {
        if self.draws.is_empty() && posed == 0 {
            return;
        }
+        let total = posed + self.scratch.len() as u32;
+        let posed_marks = if skin.is_some() { motion.1 } else { &[] };
+        self.motion
+            .collect(motion.0, posed_marks, entities.len() as u32, posed, &copied);
+        self.index_scratch.clear();
+        self.index_scratch.resize(total as usize, NO_PREVIOUS);
+        self.motion
+            .link(&self.previous_motion, &mut self.index_scratch);
        let vertex_size = std::mem::size_of::<Vertex>() as u64;
        let (need_vertices, need_slots) = (
            u64::from(posed) + self.scratch.len() as u64,
@@ -476,9 +577,23 @@ impl PackEntities {
        let have_vertices = self.vertices.size() / vertex_size;
        let have_slots = self.slots.size() / self.stride;
        if need_vertices > have_vertices {
-            (self.vertices, self.table_group) =
-                Self::vertex_buffer(device, &self.table, need_vertices.next_power_of_two());
+            self.vertices = Self::vertex_buffer(device, need_vertices.next_power_of_two());
        }
+        if need_vertices * 4 > self.previous_index.size() {
+            self.previous_index = Self::index_buffer(device, need_vertices.next_power_of_two());
+        }
+        queue.write_buffer(
+            &self.previous_index,
+            0,
+            bytemuck::cast_slice(&self.index_scratch),
+        );
+        self.table_group = Self::table_group(
+            device,
+            &self.table,
+            &self.vertices,
+            &self.previous,
+            &self.previous_index,
+        );
        if need_slots > have_slots {
            (self.slots, self.group) =
                Self::slot_buffer(device, layout, need_slots.next_power_of_two(), self.stride);
@@ -670,6 +785,87 @@ fn drawn_by_pack(span: &EntitySpan, drawn: [bool; PROGRAMS]) -> Option<usize> {
 }

 /// The kind of program that draws `span`'s run, when a pack may.
+/// A vertex with no copy last frame: `at_velocity` reads zero.
+const NO_PREVIOUS: u32 = u32::MAX;
+
+/// Where each entity's vertices are in a frame's pack buffer, to match them with last frame's
+/// (`at_velocity`): the indices of each one's GPU-posed vertices, then of its CPU ones.
+#[derive(Default)]
+struct Motion {
+    /// Entity id (`Frame::entity_motion`) → (first index in `indices`, posed count, CPU count).
+    entities: std::collections::HashMap<u64, (u32, u32, u32)>,
+    indices: Vec<u32>,
+}
+
+impl Motion {
+    fn clear(&mut self) {
+        self.entities.clear();
+        self.indices.clear();
+    }
+
+    /// Records each marked entity (`marks`: first CPU vertex and id, each run up to the next;
+    /// `posed_marks`: the posed count at each mark, empty without posing). A CPU vertex is in
+    /// the pack buffer where `copied` (first vertex in `Frame::entities`, first index in the
+    /// buffer, count, in order) has it, else `NO_PREVIOUS`.
+    fn collect(
+        &mut self,
+        marks: &[(u32, u64)],
+        posed_marks: &[u32],
+        cpu_total: u32,
+        posed_total: u32,
+        copied: &[(u32, u32, u32)],
+    ) {
+        let at = |e: u32| {
+            let i = copied.partition_point(|c| c.0 <= e);
+            match i.checked_sub(1).map(|i| copied[i]) {
+                Some((first, index, n)) if e < first + n => index + (e - first),
+                _ => NO_PREVIOUS,
+            }
+        };
+        for (i, &(cpu, id)) in marks.iter().enumerate() {
+            if id == 0 {
+                continue;
+            }
+            let cpu_end = marks.get(i + 1).map_or(cpu_total, |m| m.0).max(cpu);
+            let posed = posed_marks.get(i).copied().unwrap_or(0).min(posed_total);
+            let posed_end = posed_marks
+                .get(i + 1)
+                .copied()
+                .unwrap_or(posed_total)
+                .clamp(posed, posed_total);
+            let first = self.indices.len() as u32;
+            self.indices.extend(posed..posed_end);
+            self.indices.extend((cpu..cpu_end).map(at));
+            self.entities
+                .insert(id, (first, posed_end - posed, cpu_end - cpu));
+        }
+    }
+
+    /// For each entity drawn last frame with the same posed and CPU counts, each vertex's index
+    /// last frame, written into `out` (indexed by this frame's buffer).
+    fn link(&self, previous: &Motion, out: &mut [u32]) {
+        for (id, &(first, posed, cpu)) in &self.entities {
+            let Some(&(then, p, c)) = previous.entities.get(id) else {
+                continue;
+            };
+            if (p, c) != (posed, cpu) {
+                continue;
+            }
+            let n = (posed + cpu) as usize;
+            let now = &self.indices[first as usize..][..n];
+            let before = &previous.indices[then as usize..][..n];
+            for (&now, &before) in now.iter().zip(before) {
+                if now != NO_PREVIOUS
+                    && before != NO_PREVIOUS
+                    && let Some(slot) = out.get_mut(now as usize)
+                {
+                    *slot = before;
+                }
+            }
+        }
+    }
+}
+
 pub fn program_of(span: &EntitySpan) -> Option<usize> {
    Some(if span.stage == render_stage("ENTITIES") {
        if span.translucent {
@@ -967,6 +1163,83 @@ fn skin_runs(skin: &super::entity_skin::SkinFrame) -> Vec<(EntitySpan, Range<u32
 mod gpu_span_tests {
    use super::*;
    use crate::gfx::entity_skin::{SkinFrame, SkinJob};
+    #[test]
+    #[ignore = "requires a Vulkan/Metal/DX12 adapter"]
+    fn native_fluid_stays_native_while_model_uses_pack() {
+        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(&Default::default())).unwrap();
+        let layout = super::super::pack_draw::DrawUniforms::new(&device);
+        let mut geometry = PackEntities::new(&device, &layout.layout);
+        for overlay in [
+            super::super::FLUID_OVERLAY,
+            super::super::TERRAIN_MODEL_SOLID_OVERLAY,
+            super::super::TERRAIN_MODEL_CUTOUT_OVERLAY,
+            super::super::TERRAIN_MODEL_CUTOUT_MIPPED_OVERLAY,
+        ] {
+            let mut mixed = vec![
+                Vertex {
+                    layer: 0,
+                    ..bytemuck::Zeroable::zeroed()
+                };
+                8
+            ];
+            for v in &mut mixed[4..] {
+                v.layer = overlay | 279 << 16;
+                v.uv = [0.25, 0.75];
+                v.glint_uv = [17.0, 0.0];
+            }
+            let mut rest = Vec::new();
+            for hidden in [false, true] {
+                geometry.prepare(
+                    &device,
+                    &queue,
+                    &layout.layout,
+                    &mixed,
+                    &[EntitySpan {
+                        start: 0,
+                        id: 77,
+                        stage: render_stage("BLOCK_ENTITIES"),
+                        hidden,
+                        ..Default::default()
+                    }],
+                    [true; PROGRAMS],
+                    ([0.; 4], [1; 2]),
+                    Casters {
+                        blocks: true,
+                        ..Default::default()
+                    },
+                    &mut rest,
+                    None,
+                    (&[], &[]),
+                );
+                assert_eq!(
+                    geometry.scratch.len(),
+                    4,
+                    "the model still uses the shader pack"
+                );
+                assert_eq!(geometry.draws.len(), 1);
+                assert_eq!(
+                    (geometry.draws[0].pack, geometry.draws[0].shadow),
+                    (!hidden, true)
+                );
+                if hidden {
+                    assert!(
+                        rest.is_empty(),
+                        "hidden native fluid must not leak into the visible pass"
+                    );
+                } else {
+                    assert_eq!(
+                        bytemuck::cast_slice::<_, u8>(&rest),
+                        bytemuck::cast_slice::<_, u8>(&mixed[4..]),
+                        "fluid UV/layer payload cannot be sampled from the entity atlas"
+                    );
+                }
+            }
+        }
+    }
+
    #[test]
    fn posed_draws_preserve_subject_ids_overlays_and_hidden_shadow_casters() {
        let mut skin = SkinFrame {
@@ -1079,6 +1352,7 @@ mod gpu_span_tests {
            },
            &mut rest,
            None,
+            (&[], &[]),
        );
        assert_eq!(
            (geometry.draws.iter())
@@ -1160,6 +1434,7 @@ mod gpu_span_tests {
            shadows,
            &mut rest,
            Some(&skin),
+            (&[], &[]),
        );
        assert_eq!(rest.len(), 4, "untagged CPU prefix stays in Horizon's draw");
        assert_eq!(geometry.scratch.len(), 4, "only CPU geometry is uploaded");
@@ -1203,6 +1478,7 @@ mod gpu_span_tests {
            shadows,
            &mut rest,
            None,
+            (&[], &[]),
        );
        assert!(geometry.draws.is_empty());
        assert_eq!(
@@ -1230,8 +1506,125 @@ mod gpu_span_tests {
            Casters::default(),
            &mut rest,
            Some(&skin),
+            (&[], &[]),
        );
        assert!(geometry.draws.is_empty());
        assert!(geometry.skin_target().size() >= 5000 * 44);
    }
 }
+
+#[cfg(test)]
+mod velocity_tests {
+    use super::{Motion, NO_PREVIOUS};
+
+    /// Two mobs (ids 7 and 9) and a run of unmarked geometry (id 0); `copied` places CPU
+    /// vertices `first..first + n` at buffer index `at`.
+    fn frame(order: [(u64, u32); 2], copied: &[(u32, u32, u32)]) -> Motion {
+        let mut marks = Vec::new();
+        let mut cpu = 0;
+        for (id, n) in order {
+            marks.push((cpu, id));
+            cpu += n;
+        }
+        marks.push((cpu, 0));
+        let mut m = Motion::default();
+        m.collect(&marks, &[], cpu + 2, 0, copied);
+        m
+    }
+
+    /// The same mob's vertices find themselves however the frame's order and the buffer's
+    /// layout moved between frames; geometry of no entity, and vertices not in the buffer,
+    /// find nothing.
+    #[test]
+    fn each_vertex_finds_its_copy_from_last_frame() {
+        // Last frame: mob 7 (4 vertices) then mob 9 (2), copied whole from buffer index 10.
+        let before = frame([(7, 4), (9, 2)], &[(0, 10, 8)]);
+        // This frame: mob 9 first, then mob 7, at buffer index 0; 9's last vertex not drawn.
+        let now = frame([(9, 2), (7, 4)], &[(0, 0, 1), (2, 1, 6)]);
+        let mut out = vec![NO_PREVIOUS; 8];
+        now.link(&before, &mut out);
+        // 9's first vertex (buffer 0) was 10 + 4; 7's four (buffer 1..5) were 10..14.
+        assert_eq!(
+            out,
+            [14, 10, 11, 12, 13, NO_PREVIOUS, NO_PREVIOUS, NO_PREVIOUS]
+        );
+    }
+
+    /// A mob whose vertex count changed (armor put on, an item picked up) gets no velocity
+    /// this frame rather than the wrong vertices'.
+    #[test]
+    fn a_changed_model_gets_none() {
+        let before = frame([(7, 4), (9, 2)], &[(0, 0, 8)]);
+        let now = frame([(7, 6), (9, 2)], &[(0, 0, 10)]);
+        let mut out = vec![NO_PREVIOUS; 10];
+        now.link(&before, &mut out);
+        assert!(out[..6].iter().all(|&i| i == NO_PREVIOUS));
+        assert_eq!(out[6..8], [4, 5]);
+    }
+
+    /// GPU-posed vertices come first in the buffer: each mob's posed part is matched by its
+    /// own posed count, then its CPU part.
+    #[test]
+    fn posed_and_cpu_parts_match_separately() {
+        let marks = [(0, 7), (2, 9), (2, 0)];
+        let mut before = Motion::default();
+        // Mob 7: 3 posed (0..3) and 2 CPU; mob 9: 1 posed (3), no CPU.
+        before.collect(&marks, &[0, 3, 4], 2, 4, &[(0, 4, 2)]);
+        let mut now = Motion::default();
+        // Mob 9 posed first this frame (0), then mob 7 (1..4).
+        now.collect(&[(0, 9), (0, 7), (2, 0)], &[0, 1, 4], 2, 4, &[(0, 4, 2)]);
+        let mut out = vec![NO_PREVIOUS; 6];
+        now.link(&before, &mut out);
+        assert_eq!(out, [3, 0, 1, 2, 4, 5]);
+    }
+}
+
+#[cfg(test)]
+mod velocity_translate_tests {
+    /// A pack that reads `at_velocity` translates with the entity inputs (which read the
+    /// previous view and last frame's vertices) and with the hand's (which read zero).
+    #[test]
+    fn a_pack_reading_at_velocity_translates_for_entities_and_the_hand() {
+        let dir = std::env::temp_dir().join(format!("hz-at-velocity-{}", 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 vec3 at_velocity;\nvarying vec3 v;\n\
+             void main() {\n    gl_Position = ftransform();\n    v = at_velocity;\n}\n",
+        )
+        .unwrap();
+        std::fs::write(
+            shaders.join("gbuffers_entities.fsh"),
+            "#version 120\nvarying vec3 v;\nvoid main() {\n    gl_FragData[0] = vec4(v, 1.0);\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 p = horizon_shaders::translate_gbuffers(
+                &vsh,
+                &fsh,
+                horizon_shaders::Target::Buffers,
+                &inputs,
+            )
+            .unwrap_or_else(|e| panic!("{who}: {e:?}"));
+            let previous = p
+                .interface
+                .uniforms
+                .iter()
+                .any(|u| u.name == "gbufferPreviousModelView");
+            assert_eq!(
+                previous,
+                who == "entities",
+                "{who}: previous view in the block"
+            );
+        }
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}
@@ -19,6 +19,13 @@ const SLOT: u64 = 32;
 /// What `gbuffers_hand` reads: the entity inputs, and the hand's projection from set 1.
 pub fn inputs() -> horizon_shaders::GbuffersInputs {
    let mut inputs = super::pack_entities::inputs();
+    // No last frame's hand to measure from: the hand's `at_velocity` reads zero (and its set 1
+    // has no previous vertices).
+    for (name, value) in &mut inputs.attributes {
+        if name == "at_velocity" {
+            *value = "vec3(0.0)".to_owned();
+        }
+    }
    // Iris 1.11.7 declares `currentRenderedItemId` in the hand's programs (observed).
    inputs.item_id_declared = true;
    inputs.declarations.push_str(
@@ -23,6 +23,13 @@ pub(super) struct PackImage {
 }

 impl PackImage {
+    pub(super) fn reset_history(&mut self) {
+        self.view = None;
+        self.copy = None;
+        self.before = None;
+        self.made_for = [0; 2];
+    }
+
    pub(super) fn sample_type(&self, features: wgpu::Features) -> wgpu::TextureSampleType {
        self.format
            .sample_type(None, Some(features))
@@ -316,6 +323,11 @@ impl StandIn {
    }
 }

+pub(super) fn reset_stand_ins(device: &wgpu::Device, images: &mut Vec<StandIn>) {
+    let wanted = images.iter().map(|i| (i.format, i.dimension)).collect();
+    *images = stand_ins(device, wanted);
+}
+
 /// One stand-in for each format and dimension of `wanted`.
 pub(super) fn stand_ins(
    device: &wgpu::Device,
@@ -392,6 +404,12 @@ pub(super) struct Buffers {
 }

 impl Buffers {
+    pub(super) fn reset_history(&mut self) {
+        self.group = None;
+        self.buffers.clear();
+        self.made_for = [0; 2];
+    }
+
    /// The layout of `objects`, bound in `stages`; each buffer is at least its entry in
    /// `minimums` long.
    pub(super) fn new(
@@ -31,6 +31,9 @@ const BUFFERS: usize = horizon_shaders::BUFFERS;

 mod packed;

+#[cfg(test)]
+mod history_reset_tests;
+
 #[cfg(test)]
 mod world_target_tests;

@@ -43,6 +46,9 @@ mod higher_shadowcolor_tests;
 #[cfg(test)]
 mod single_side_tests;

+#[cfg(test)]
+mod mixed_size_tests;
+
 #[cfg(test)]
 mod sky_disc_blend_tests;

@@ -70,6 +76,9 @@ mod custom_type_tests;
 #[cfg(test)]
 mod sky_depth_tests;

+#[cfg(test)]
+mod end_fan_tests;
+
 #[cfg(test)]
 mod runtime_length_tests;

@@ -396,6 +405,8 @@ struct Pass {
    layout: wgpu::BindGroupLayout,
    ubo: wgpu::Buffer,
    block: Vec<u8>,
+    /// Shader-declared defaults must survive a reset of the mutable upload block.
+    initial_block: Vec<u8>,
    /// (index into `pack_uniforms::NAMES`, declared type, offset).
    uniforms: Vec<(Option<usize>, String, u32)>,
    samplers: Vec<Binding>,
@@ -449,6 +460,16 @@ struct Pass {
 }

 impl Pass {
+    /// Back to the uniform values the pass was made with, and no bind groups.
+    fn reset_history(&mut self) {
+        self.block.clone_from(&self.initial_block);
+        self.groups.clear();
+        self.portal_groups.clear();
+        for compute in &mut self.compute {
+            compute.reset_history();
+        }
+    }
+
    fn render(&self) -> &wgpu::RenderPipeline {
        match &self.pipeline {
            Pipeline::Render(p) => p,
@@ -1970,6 +1991,7 @@ fn build_pass(
            mapped_at_creation: false,
        }),
        block: interface.initial_values.clone(),
+        initial_block: interface.initial_values.clone(),
        uniforms: interface
            .uniforms
            .iter()
@@ -2105,6 +2127,7 @@ fn build_compute(
            mapped_at_creation: false,
        }),
        block: interface.initial_values.clone(),
+        initial_block: interface.initial_values.clone(),
        uniforms: interface
            .uniforms
            .iter()
@@ -2376,7 +2399,16 @@ impl PackPost {
            } else {
                written.next()
            };
-            if !in_shadow && group != Group::Final && written.any(|s| Some(s) != first) {
+            // Sizes of one kind that differ never meet. A size relative to the render size and
+            // one in pixels can: the pass then draws while they resolve to one size
+            // (`PackPost::sizes_differ`). Iris 1.11.7 drew a composite program writing
+            // colortex2 at `0.25 0.25` and colortex3 at `320 180` at 1280×720 (#10454).
+            let apart = |s: horizon_shaders::BufferSize| {
+                first.is_some_and(|f| {
+                    f != s && (depth || std::mem::discriminant(&f) == std::mem::discriminant(&s))
+                })
+            };
+            if !in_shadow && group != Group::Final && written.any(apart) {
                notes.push(format!(
                    "{}: writes buffers of different sizes (size.buffer); skipped",
                    pass.name
@@ -3112,23 +3144,7 @@ impl PackPost {
                .create_view(&Default::default()),
            textures,
            shadow: (
-                device
-                    .create_texture(&wgpu::TextureDescriptor {
-                        label: Some("Shader pack shadow stand-in"),
-                        size: wgpu::Extent3d {
-                            width: 1,
-                            height: 1,
-                            depth_or_array_layers: 1,
-                        },
-                        mip_level_count: 1,
-                        sample_count: 1,
-                        dimension: wgpu::TextureDimension::D2,
-                        format: wgpu::TextureFormat::Depth32Float,
-                        usage: wgpu::TextureUsages::TEXTURE_BINDING
-                            | wgpu::TextureUsages::RENDER_ATTACHMENT,
-                        view_formats: &[],
-                    })
-                    .create_view(&Default::default()),
+                super::pack_shadow::stand_in(device),
                device.create_sampler(&wgpu::SamplerDescriptor {
                    label: Some("Shader pack shadow"),
                    compare: Some(wgpu::CompareFunction::LessEqual),
@@ -3177,6 +3193,74 @@ impl PackPost {
        })
    }

+    /// `Renderer::finish_sequence_frame`: the centre depth the finished frame copied.
+    pub fn take_center_depth(&mut self, device: &wgpu::Device) -> Result<(), String> {
+        self.center_depth
+            .as_mut()
+            .ok_or("the shader pack copied no centre depth")?
+            .take_completed(device)
+            .map(|_| ())
+    }
+
+    /// Forgets what the pack kept from earlier frames, so the next frame draws as a freshly
+    /// loaded pack's first: buffers, images, storage buffers and shadow maps start over (made
+    /// again at their sizes when next drawn), the frame uniforms' history, the custom uniforms
+    /// and the centre depth too. Compiled programs and the pack's textures stay.
+    pub fn reset_history(&mut self, device: &wgpu::Device) {
+        self.uniforms.reset_history();
+        // A parsed pack's custom uniforms start at tick 0's seed, before any frame of the world.
+        self.custom.restart_at(0);
+        self.custom.forget_world();
+        self.center_depth = None;
+        self.targets = None;
+        self.main = 0;
+        self.mips_valid = 0;
+        self.rgb_unset = true;
+        self.final_target = None;
+        self.blit_group = None;
+        self.page_groups.clear();
+        for image in &mut self.images {
+            image.reset_history();
+        }
+        self.buffers.reset_history();
+        pack_images::reset_stand_ins(device, &mut self.stand_ins);
+        if let Some(shadow) = &mut self.shadow_targets {
+            shadow.reset_history(device, &self.uniforms.shadow);
+        }
+        self.shadow.0 = super::pack_shadow::stand_in(device);
+        self.shadow_cleared = false;
+        self.shadow_cache = Default::default();
+        self.setup_pending = true;
+        self.portal_texture = None;
+        self.portal_rect = [0.0; 4];
+        let sky = self
+            .sky
+            .iter_mut()
+            .flat_map(|s| s.basic.iter_mut().chain(&mut s.textured));
+        let entities = self
+            .entities
+            .iter_mut()
+            .flat_map(|e| e.passes.iter_mut().chain(&mut e.shadow).flatten());
+        for pass in self
+            .passes
+            .iter_mut()
+            .chain(&mut self.terrain)
+            .chain(&mut self.terrain_cutout)
+            .chain(&mut self.water)
+            .chain(sky)
+            .chain(entities)
+            .chain(&mut self.clouds)
+            .chain(&mut self.lines)
+            .chain(self.weather.iter_mut().flatten())
+            .chain(self.hand.iter_mut().map(|h| &mut h.0))
+            .chain(&mut self.shadow_terrain)
+            .chain(&mut self.shadow_water)
+            .chain(&mut self.shadow_comp)
+        {
+            pass.reset_history();
+        }
+    }
+
    /// Writes `pass`'s uniforms for a target of `out` pixels; its bind group for the buffers'
    /// current mapping. The buffers it both samples and stores to are copied first, and it
    /// samples the copies.
@@ -3853,6 +3937,7 @@ impl PackPost {
        portal: [f32; 4],
        rest: &mut Vec<super::Vertex>,
        skin: Option<&super::entity_skin::SkinFrame>,
+        motion: (&[(u32, u64)], &[u32]),
    ) {
        self.portal_rect = portal;
        let shadow = self.shadow_casters();
@@ -3873,6 +3958,7 @@ impl PackPost {
            shadow,
            rest,
            skin,
+            motion,
        );
    }

@@ -3926,7 +4012,7 @@ impl PackPost {
        frame: &super::Frame,
        terrain: &mut TerrainDraw<'_>,
    ) {
-        if super::sky_visible(frame) {
+        if super::sky_visible(frame) || super::end_fog_sky(frame) {
            self.draw_sky(device, queue, encoder, size, frame);
        }
        self.draw_terrain(device, queue, encoder, size, TerrainList::Solid, terrain);
@@ -4286,6 +4372,18 @@ impl PackPost {
        })
    }

+    /// Whether the buffers `pass` writes have different sizes at the current render size: then
+    /// it is skipped, as one whose `size.buffer` sizes never meet is when the pack loads. Only
+    /// a pass writing buffers sized relative to the render size and in pixels can.
+    fn sizes_differ(&self, pass: &Pass) -> bool {
+        let Some(targets) = &self.targets else {
+            return false;
+        };
+        let mut sizes = pass.writes.iter().map(|&(_, b)| targets.sizes[b]);
+        let first = sizes.next();
+        !pass.group.shadow() && pass.group != Group::Final && sizes.any(|s| Some(s) != first)
+    }
+
    /// Whether the pack draws terrain itself, or has nothing draw it.
    pub fn has_terrain(&self) -> bool {
        self.terrain.is_some() || self.terrain_cutout.is_some() || self.terrain_undrawn
@@ -4527,6 +4625,14 @@ impl PackPost {
            mips,
        });
        self.forget_groups();
+        for pass in self.passes.iter().filter(|p| self.sizes_differ(p)) {
+            log::info!(
+                "shader pack: {}: writes buffers of different sizes at {}x{} (size.buffer); skipped",
+                pass.name,
+                size[0],
+                size[1]
+            );
+        }
    }

    /// The shadow pass (2.1, passes 2 and 3): the shadow buffers cleared, then the `shadowcomp`
@@ -5073,6 +5179,10 @@ impl PackPost {
                terrain_drawn = true;
                self.draw_opaque(device, queue, encoder, size, frame, terrain);
            }
+            // As if the pack didn't have it: no compute stages, flips or stage changes.
+            if self.sizes_differ(pass) {
+                continue;
+            }
            if !water_drawn && matches!(pass.group, Group::Composite | Group::Final) {
                water_drawn = true;
                self.draw_translucent(device, queue, encoder, size, terrain);
@@ -593,6 +593,7 @@ pub(super) fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        skybox: false,
        end_sky: false,
        end_sky_sprite: None,
+        boss_world_fog: false,
        environment_fog: None,
        water_fog: [0.0; 3],
        fog: None,
@@ -613,6 +614,7 @@ pub(super) fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        visible_static_block_entity_sections: &[],
        static_block_entity_stats: crate::block_entity_render::StaticCacheFrameStats::default(),
        entity_motion: &[],
+        entity_motion_posed: &[],
        colored_lights: &[],
        emissive_layers: &[],
        shadow_only: &[],
@@ -431,6 +431,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        skybox: false,
        end_sky: false,
        end_sky_sprite: None,
+        boss_world_fog: false,
        environment_fog: None,
        water_fog: [0.0; 3],
        fog: None,
@@ -451,6 +452,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        visible_static_block_entity_sections: &[],
        static_block_entity_stats: crate::block_entity_render::StaticCacheFrameStats::default(),
        entity_motion: &[],
+        entity_motion_posed: &[],
        colored_lights: &[],
        emissive_layers: &[],
        shadow_only: &[],
@@ -0,0 +1,151 @@
+//! In the End, while the dragon fight's world fog leaves out vanilla's sky, a pack's
+//! `gbuffers_skybasic` draws a fan in the fog colour, as our probe packs read it in Iris 1.11.7.
+//! Original fixture, no pack files.
+use super::depth_test::{Gpu, SIZE, VERTEX, fixture_frame};
+use super::*;
+use crate::hud::HudBatch;
+use wgpu::TextureFormat as T;
+
+/// `gbuffers_skybasic` writes its vertex colour into colortex0 and `gl_Vertex` into colortex1
+/// (32-bit floats). final shows, on the picture's top half, `gl_Vertex.y` of the view's lower
+/// half as a 24-bit integer ((y + 64) * 65536), and on its bottom half colortex0 of the view's
+/// upper half.
+fn files() -> Vec<(String, String)> {
+    vec![
+        ("shaders.properties".into(), "blend.gbuffers_skybasic=off\n".into()),
+        (
+            "gbuffers_skybasic.vsh".into(),
+            "#version 120\nvarying vec4 color;\nvarying vec3 at;\nvoid main() {\n\
+             \x20   gl_Position = ftransform();\n    color = gl_Color;\n    at = gl_Vertex.xyz;\n}\n"
+                .into(),
+        ),
+        (
+            "gbuffers_skybasic.fsh".into(),
+            "#version 120\nvarying vec4 color;\nvarying vec3 at;\n/* DRAWBUFFERS:01 */\n\
+             void main() {\n    gl_FragData[0] = color;\n    gl_FragData[1] = vec4(at, 1.0);\n}\n"
+                .into(),
+        ),
+        ("final.vsh".into(), VERTEX.into()),
+        (
+            "final.fsh".into(),
+            "#version 130\n/*\nconst int colortex1Format = RGBA32F;\n*/\n\
+             uniform sampler2D colortex0;\nuniform sampler2D colortex1;\nvarying vec2 uv;\n\
+             void main() {\n\
+             \x20   float y = texelFetch(colortex1, ivec2(gl_FragCoord.xy) - ivec2(0, 8), 0).y;\n\
+             \x20   uint n = min(uint((y + 64.0) * 65536.0 + 0.5), 16777215u);\n\
+             \x20   vec4 at = vec4(uvec4(n >> 16u, (n >> 8u) & 255u, n & 255u, 255u)) / 255.0;\n\
+             \x20   gl_FragColor = uv.y > 0.5 ? at : texelFetch(colortex0, ivec2(gl_FragCoord.xy) + ivec2(0, 8), 0);\n}\n"
+                .into(),
+        ),
+    ]
+}
+
+/// The pack's picture of the fixture's frame (16 pixels square, 90° field of view, looking level
+/// toward +Z) in the End, the world having left the far plane everywhere.
+fn picture(gpu: &Gpu, boss_world_fog: bool) -> Vec<[u8; 4]> {
+    let color = gpu.texture(T::Rgba8Unorm);
+    let depth = gpu.texture(T::Depth32Float);
+    gpu.clear(&color, &depth, 0.0);
+    let mut post = gpu.load(
+        files(),
+        World {
+            atlas: None,
+            material_maps: None,
+            lightmap: color.clone(),
+            terrain: None,
+            block_ids: &[],
+            sprite_rects: &[],
+            celestial: None,
+            gui_size: SIZE,
+            clouds: None,
+            weather: false,
+            hand: false,
+        },
+        horizon_shaders::GameInputs {
+            sky: Some(super::super::pack_sky::inputs()),
+            ..Default::default()
+        },
+    );
+    assert!(post.sky.is_some(), "{:?}", post.notes);
+    let hud = HudBatch::new(SIZE);
+    let mut frame = fixture_frame(&hud);
+    frame.title = false;
+    frame.end_sky = true;
+    frame.boss_world_fog = boss_world_fog;
+    frame.detail_distance = 192.0;
+    frame.fog = Some(crate::fog::FogData {
+        color: [0.2, 0.4, 0.6, 1.0],
+        environmental_start: 0.0,
+        environmental_end: 96.0,
+        render_distance_start: 172.8,
+        render_distance_end: 192.0,
+        sky_end: 96.0,
+        cloud_end: 96.0,
+    });
+    gpu.render(&mut post, &color, &depth, &frame, &mut |_, _, _, _| {})
+}
+
+/// Where the view ray through pixel (`column`, `row`) meets the fan: from (0, -16, 0) to eight
+/// points 16 above the eye at radius 192, every 45° from +Z. None when it passes above the rim.
+fn fan_height(column: usize, row: usize) -> Option<f64> {
+    let side = |i: usize| (i as f64 + 0.5) / 8.0 - 1.0;
+    // The fan is mirrored across x = 0, so either sign of the view's x does.
+    let ray = glam::DVec3::new(side(column), -side(row), 1.0);
+    let azimuth = ray.x.atan2(ray.z).to_degrees();
+    let edge = (azimuth / 45.0).floor();
+    let rim = |k: f64| {
+        let a = (k * 45.0).to_radians();
+        glam::DVec3::new(192.0 * a.sin(), 16.0, 192.0 * a.cos())
+    };
+    let apex = glam::DVec3::new(0.0, -16.0, 0.0);
+    let normal = (rim(edge) - apex).cross(rim(edge + 1.0) - apex);
+    let along = apex.dot(normal) / ray.dot(normal);
+    let hit = ray * along;
+    (along > 0.0 && hit.y <= 16.0).then_some(hit.y)
+}
+
+#[test]
+fn the_end_under_the_dragons_fog_has_the_packs_fan() {
+    let Some(gpu) = Gpu::new() else { return };
+    let pixels = picture(&gpu, true);
+    let width = SIZE[0] as usize;
+    // Below the horizon: every pixel sees the fan, at the height the planes give (to 0.02:
+    // the GPU interpolates `gl_Vertex` across triangles 192 blocks wide; it came within 0.008).
+    for row in 8..16 {
+        for column in 0..width {
+            let p = pixels[(row - 8) * width + column];
+            let got = f64::from(u32::from(p[0]) << 16 | u32::from(p[1]) << 8 | u32::from(p[2]))
+                / 65536.0
+                - 64.0;
+            let expected = fan_height(column, row).expect("below the horizon");
+            assert!(
+                (got - expected).abs() < 0.02,
+                "row {row}, column {column}: gl_Vertex.y {got}, expected {expected}"
+            );
+        }
+    }
+    // Above it: only the row just over the horizon reaches the fan (the rim stands 4.8° up),
+    // drawn in the fog colour; above that, the world's grey stays.
+    for row in 0..8 {
+        for column in 0..width {
+            let p = pixels[(row + 8) * width + column];
+            let expected = match fan_height(column, row) {
+                Some(_) => [51, 102, 153, 255],
+                None => [16, 16, 16, 255],
+            };
+            assert_eq!(p, expected, "row {row}, column {column}");
+        }
+        assert_eq!(fan_height(0, row).is_some(), row == 7, "row {row}");
+    }
+}
+
+/// The End without the fog: vanilla's End sky, which no `gbuffers_skybasic` draws.
+#[test]
+fn the_end_without_the_fog_has_no_fan() {
+    let Some(gpu) = Gpu::new() else { return };
+    let pixels = picture(&gpu, false);
+    let width = SIZE[0] as usize;
+    for (i, p) in pixels[8 * width..].iter().enumerate() {
+        assert_eq!(*p, [16, 16, 16, 255], "pixel {i}");
+    }
+}
@@ -0,0 +1,109 @@
+//! `PackPost::reset_history`: a pack reset after some frames draws as a freshly loaded one.
+use super::destination_tests::Fixture;
+use std::io::{Cursor, Write};
+
+#[test]
+#[ignore = "requires a host GPU with compute and fragment storage"]
+fn a_reset_pack_draws_its_buffers_images_storage_and_shadow_from_the_start() {
+    let gpu = Fixture::new().expect("a GPU is required for this reset regression");
+    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();
+    };
+    let vertex = "#version 120\nvarying vec2 uv;\nvoid main(){uv=gl_MultiTexCoord0.xy;gl_Position=ftransform();}\n";
+    let state = "layout(std430,binding=0) buffer State { uint setups; uint frames; } state;\n";
+    let compute = "#version 430\nlayout(local_size_x=1) in;\nconst ivec3 workGroups=ivec3(1);\n";
+    add(
+        "setup.csh",
+        &format!("{compute}{state}void main(){{state.setups+=1u;}}\n"),
+    );
+    add(
+        "begin.csh",
+        &format!(
+            "{compute}{state}layout(r32ui) uniform uimage2D imgCounter;\n\
+        void main(){{state.frames+=1u;imageStore(imgCounter,ivec2(0),uvec4(imageLoad(imgCounter,ivec2(0)).r+1u));}}\n"
+        ),
+    );
+    for name in ["composite", "shadowcomp"] {
+        add(&format!("{name}.vsh"), vertex);
+        let target = if name == "composite" { 2 } else { 0 };
+        let (declarations, value) = if name == "composite" {
+            ("", "vec4(0.125)")
+        } else {
+            (
+                "uniform sampler2D shadowcolor0;varying vec2 uv;",
+                "texture2D(shadowcolor0,uv)+vec4(0.125)",
+            )
+        };
+        add(
+            &format!("{name}.fsh"),
+            &format!(
+                "#version 120\n/* RENDERTARGETS:{target} */\n\
+            {declarations}\nvoid main(){{gl_FragData[0]={value};}}\n"
+            ),
+        );
+    }
+    add("final.vsh", vertex);
+    add(
+        "final.fsh",
+        &format!(
+            "#version 430 compatibility\n{state}\
+        uniform sampler2D colortex2;uniform sampler2D shadowcolor0;uniform usampler2D texCounter;\n\
+        const bool colortex2Clear=false;const bool shadowcolor0Clear=false;\n\
+        const int shadowMapResolution=16;uniform float baseline=0.375;varying vec2 uv;\n\
+        void main(){{gl_FragColor=gl_FragCoord.x<8.0?\
+        vec4(texture(colortex2,uv).r,float(texelFetch(texCounter,ivec2(0),0).r)/8.0,float(state.frames)/8.0,1):\
+        vec4(texture(shadowcolor0,uv).r,float(state.setups)/8.0,baseline,1);}}\n"
+        ),
+    );
+    add(
+        "shaders.properties",
+        "shadow.enabled=true\nbufferObject.0=8\n\
+        image.imgCounter=texCounter RED_INTEGER R32UI UNSIGNED_INT false false 1 1\n\
+        blend.composite=ONE ONE ONE ONE\n",
+    );
+    let pack =
+        horizon_shaders::Pack::from_zip_bytes("original-reset", zip.finish().unwrap().into_inner())
+            .unwrap();
+    let mut macros = horizon_shaders::Macros::standard();
+    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
+    let load = || horizon_shaders::load_post(&pack, "", &properties, &macros, &Default::default());
+    let mut post = gpu.try_build(load()).expect("reset fixture compiles");
+    let mut fresh = gpu.try_build(load()).expect("fresh control compiles");
+    let check = |pixels: &[[u8; 4]], frame: u8| {
+        let counter = 32 * frame;
+        for (i, pixel) in pixels.iter().enumerate() {
+            let expected = if i % 16 < 8 {
+                [counter, counter, counter, 255]
+            } else {
+                [counter, 32, 96, 255]
+            };
+            assert!(
+                pixel.iter().zip(expected).all(|(a, b)| a.abs_diff(b) <= 1),
+                "frame {frame}, pixel {i}: {pixel:?} != {expected:?}"
+            );
+        }
+    };
+    for frame in 1..=3 {
+        check(&gpu.render(&mut post, [16, 16]), frame);
+    }
+    // At the same size too: the retained colortex2 and shadowcolor0, the image and
+    // the storage buffer start over, and setup runs once again. The control is a pack never
+    // reset.
+    for _ in 0..2 {
+        post.reset_history(&gpu.device);
+        for frame in 1..=2 {
+            let pixels = gpu.render(&mut post, [16, 16]);
+            check(&pixels, frame);
+            if frame == 1 {
+                assert_eq!(pixels, gpu.render(&mut fresh, [16, 16]));
+            }
+        }
+        fresh.reset_history(&gpu.device);
+    }
+}
@@ -0,0 +1,89 @@
+//! A composite program writing two buffers whose `size.buffer` lines declare one relative to the
+//! render size and one in pixels (#10454). Iris 1.11.7 drew such a program where both came to
+//! the same size (our probe pack: `0.25 0.25` and `320 180` at 1280×720). The programs here are
+//! original and cut down.
+use super::destination_tests::Fixture;
+use super::*;
+use std::io::{Cursor, Write};
+
+const VERTEX: &str = "#version 120\nvarying vec2 uv;\nvoid main() { uv=gl_MultiTexCoord0.xy; gl_Position=ftransform(); }\n";
+
+/// `composite` writes (0.25, 0.5, 0.75) into colortex2, sized `0.25 0.25`, and colortex3, sized
+/// `colortex3` (`size.buffer` words); `final` shows colortex2's red and green and colortex3's
+/// blue.
+fn pack(colortex3: &str) -> 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();
+    };
+    add(
+        "shaders.properties",
+        &format!("size.buffer.colortex2 = 0.25 0.25\nsize.buffer.colortex3 = {colortex3}\n"),
+    );
+    add("composite.vsh", VERTEX);
+    add(
+        "composite.fsh",
+        "#version 120\n/* RENDERTARGETS: 2,3 */\nvoid main() {\n\
+         gl_FragData[0] = vec4(0.25, 0.5, 0.75, 1.0);\ngl_FragData[1] = vec4(0.25, 0.5, 0.75, 1.0);\n}\n",
+    );
+    add("final.vsh", VERTEX);
+    add(
+        "final.fsh",
+        "#version 120\nuniform sampler2D colortex2;\nuniform sampler2D colortex3;\nvarying vec2 uv;\n\
+         void main() {\ngl_FragColor = vec4(texture2D(colortex2, uv).rg, texture2D(colortex3, uv).b, 1.0);\n}\n",
+    );
+    let pack =
+        horizon_shaders::Pack::from_zip_bytes("mixed-sizes", 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())
+}
+
+/// Every pixel's colour, with how many pixels differ from it by more than one step.
+fn one_colour(pixels: &[[u8; 4]]) -> ([u8; 4], usize) {
+    let first = pixels[0];
+    let off = pixels
+        .iter()
+        .filter(|p| p.iter().zip(first).any(|(a, b)| a.abs_diff(b) > 1))
+        .count();
+    (first, off)
+}
+
+/// At 16×16 both buffers are 4×4: the program draws. At 32×32 colortex2 is 8×8 and colortex3
+/// still 4×4: the program is skipped there, as one whose sizes never meet is (Iris refused
+/// the whole pack in that case; Horizon skips only the program).
+#[test]
+fn a_program_writing_buffers_that_come_to_one_size_draws() {
+    let Some(gpu) = Fixture::new() else { return };
+    let mut post = gpu.build(pack("4 4"));
+    let (colour, off) = one_colour(&gpu.render(&mut post, [16, 16]));
+    assert_eq!(off, 0, "{colour:?}");
+    for (got, want) in colour.iter().zip([64, 128, 191, 255]) {
+        assert!(got.abs_diff(want) <= 1, "{colour:?}");
+    }
+    let (colour, off) = one_colour(&gpu.render(&mut post, [32, 32]));
+    assert_eq!((colour, off), ([0, 0, 0, 255], 0));
+}
+
+/// Sizes of one kind that differ never meet: the program is skipped as the pack loads.
+#[test]
+fn a_program_writing_buffers_of_different_relative_sizes_is_skipped() {
+    let Some(gpu) = Fixture::new() else { return };
+    let post = pack("0.5 0.5");
+    let post = gpu
+        .try_build(post)
+        .unwrap_or_else(|_| panic!("the pack runs"));
+    assert!(
+        post.notes
+            .iter()
+            .any(|n| n == "composite: writes buffers of different sizes (size.buffer); skipped"),
+        "{:?}",
+        post.notes
+    );
+}
@@ -400,6 +400,7 @@ fn frame(hud: &HudBatch) -> Frame<'_> {
        skybox: false,
        end_sky: false,
        end_sky_sprite: None,
+        boss_world_fog: false,
        environment_fog: None,
        water_fog: [0.0; 3],
        fog: None,
@@ -420,6 +421,7 @@ fn frame(hud: &HudBatch) -> Frame<'_> {
        visible_static_block_entity_sections: &[],
        static_block_entity_stats: crate::block_entity_render::StaticCacheFrameStats::default(),
        entity_motion: &[],
+        entity_motion_posed: &[],
        colored_lights: &[],
        emissive_layers: &[],
        shadow_only: &[],
@@ -76,7 +76,50 @@ fn target(
    (texture, view)
 }

+/// The depth stand-in is initialized to no shadow on the next pack render.
+pub(super) fn stand_in(device: &wgpu::Device) -> wgpu::TextureView {
+    device
+        .create_texture(&wgpu::TextureDescriptor {
+            label: Some("Shader pack shadow stand-in"),
+            size: wgpu::Extent3d {
+                width: 1,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: wgpu::TextureFormat::Depth32Float,
+            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT,
+            view_formats: &[],
+        })
+        .create_view(&Default::default())
+}
+
 impl ShadowTargets {
+    pub fn reset_history(&mut self, device: &wgpu::Device, shadow: &horizon_shaders::Shadow) {
+        let mut colors = 0;
+        let mut doubled = 0;
+        let formats = std::array::from_fn(|n| match &self.color[n] {
+            Some([a, b]) => {
+                colors |= 1 << n;
+                if a.texture() != b.texture() {
+                    doubled |= 1 << n;
+                }
+                a.texture().format()
+            }
+            None => wgpu::TextureFormat::Rgba8Unorm,
+        });
+        *self = Self::new(
+            device,
+            shadow,
+            formats,
+            colors,
+            doubled,
+            self.depth1.is_some(),
+        );
+    }
+
    /// The buffers of `shadow` the pack uses: `colors` (bit n: shadowcolor n), `depth1` when
    /// some program reads `shadowtex1`, `doubled` (bit n: shadowcolor n needs a B texture). The
    /// resolution is kept within the device's limit.
@@ -22,6 +22,8 @@ const SUNSET_APEX: u32 = 1;
 const SUNSET_RIM: u32 = 2;
 const STAR: u32 = 3;
 const VOID: u32 = 4;
+/// The End's fan (`fan`): `pos.xz` of a rim vertex is its direction, scaled by the radius.
+const FAN: u32 = 5;

 /// The frame's sky (std140).
 #[repr(C)]
@@ -33,7 +35,7 @@ struct Uniform {
    color: [f32; 4],
    /// Sunset colour and alpha.
    sunrise: [f32; 4],
-    /// cos and sin of the sunset fan's turn, star brightness.
+    /// cos and sin of the sunset fan's turn, star brightness, the End fan's radius.
    sun: [f32; 4],
 }

@@ -77,6 +79,8 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
         }} else if (hz_v_kind == {STAR}u) {{\n        \
             hz_p = (hz_sky_stars * vec4(hz_v_pos, 1.0)).xyz;\n        \
             hz_Color = vec4(hz_sky_sun.z);\n    \
+         }} else if (hz_v_kind == {FAN}u) {{\n        \
+             hz_p = vec3(hz_v_pos.x * hz_sky_sun.w, hz_v_pos.y, hz_v_pos.z * hz_sky_sun.w);\n    \
         }} else if (hz_v_kind == {VOID}u) {{\n        \
             hz_Color = vec4(0.0, 0.0, 0.0, 1.0);\n    \
         }}\n    \
@@ -188,14 +192,37 @@ fn horizon(out: &mut Vec<Vertex>) {
    }
 }

+/// The fan a pack's `gbuffers_skybasic` draws in the End while the dragon fight's fog leaves out
+/// vanilla's sky (`super::end_fog_sky`): from (0, -16, 0) under the eye to eight rim vertices 16
+/// above it, every 45° from +Z, at the render distance (the `far` uniform; scaled in the vertex
+/// stage). Fitted to the `gl_Vertex` our probe packs' fragments read in Iris 1.11.7 at render
+/// distances 12 and 8: 289 of 291 samples lie within 0.05 block of these eight planes (one of
+/// the other two, checked, sat on a terrain edge), and nothing drew above the rim.
+fn fan(out: &mut Vec<Vertex>) {
+    let rim = |i: i32| {
+        let a = (i as f32 * 45.0).to_radians();
+        Vertex {
+            pos: [a.sin(), 16.0, a.cos()],
+            kind: FAN,
+        }
+    };
+    let apex = Vertex {
+        pos: [0.0, -16.0, 0.0],
+        kind: FAN,
+    };
+    for i in 0..8 {
+        out.extend([apex, rim(i), rim(i + 1)]);
+    }
+}
+
 pub(super) struct PackSky {
    vertices: wgpu::Buffer,
    celestial: wgpu::Buffer,
    uniform: wgpu::Buffer,
    pub layout: wgpu::BindGroupLayout,
    group: wgpu::BindGroup,
-    /// Vertex ranges of the sky disc, the sunset fan, the stars and the void.
-    ranges: [Range<u32>; 4],
+    /// Vertex ranges of the sky disc, the sunset fan, the stars, the void and the End's fan.
+    ranges: [Range<u32>; 5],
 }

 impl PackSky {
@@ -227,6 +254,8 @@ impl PackSky {
        let stars = sunset.end..v.len() as u32;
        disc(-4.0, VOID, &mut v);
        let void = stars.end..v.len() as u32;
+        fan(&mut v);
+        let end_fan = void.end..v.len() as u32;
        let vertices = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("Shader pack sky"),
            contents: bytemuck::cast_slice(&v),
@@ -271,7 +300,7 @@ impl PackSky {
            uniform,
            layout,
            group,
-            ranges: [sky, sunset, stars, void],
+            ranges: [sky, sunset, stars, void, end_fan],
        }
    }

@@ -294,7 +323,8 @@ impl PackSky {
    /// Writes the frame's sky and returns its draws in vanilla's order: the disc, the sunset
    /// fan while the sun is near the horizon, the sun and the moon, the stars and, with the
    /// camera low, the void. `tilt` is the pack's `sunPathRotation` (degrees): the sun, moon
-    /// and stars turn with it (7.1).
+    /// and stars turn with it (7.1). In the End under the dragon fight's fog, only the End's fan,
+    /// in the fog colour (`fogColor`), as stage SKY.
    pub fn prepare(&self, queue: &wgpu::Queue, frame: &super::Frame, tilt: f32) -> Vec<Part> {
        let turn = super::pack_uniforms::tilt_matrix(tilt);
        let sun_angle = frame.sky.sun_angle.to_radians();
@@ -302,12 +332,22 @@ impl PackSky {
        let flip = if sun_angle.sin() < 0.0 { 180f32 } else { 0.0 };
        let theta = (flip + 90.0).to_radians();
        let (rotation, brightness) = frame.stars.unwrap_or_default();
-        let [r, g, b] = frame.sky.sky_color;
+        let end_fan = super::end_fog_sky(frame);
+        let [r, g, b] = match &frame.fog {
+            Some(f) if end_fan => [f.color[0], f.color[1], f.color[2]],
+            None if end_fan => frame.sky.fog_color,
+            _ => frame.sky.sky_color,
+        };
        let uniform = Uniform {
            stars: (turn * rotation).to_cols_array_2d(),
            color: [r, g, b, 1.0],
            sunrise: frame.sky.sunrise_color,
-            sun: [theta.cos(), theta.sin(), brightness.clamp(0.0, 1.0), 0.0],
+            sun: [
+                theta.cos(),
+                theta.sin(),
+                brightness.clamp(0.0, 1.0),
+                frame.detail_distance,
+            ],
        };
        queue.write_buffer(&self.uniform, 0, bytemuck::bytes_of(&uniform));
        // The sun's quad, then the moon's (Game::celestial_geometry), as triangles.
@@ -327,12 +367,15 @@ impl PackSky {
            })
            .collect();
        queue.write_buffer(&self.celestial, 0, bytemuck::cast_slice(&triangles));
-        let [sky, sunset, stars, void] = self.ranges.clone();
+        let [sky, sunset, stars, void, fan] = self.ranges.clone();
        let part = |stage, textured, range| Part {
            stage,
            textured,
            range,
        };
+        if end_fan {
+            return vec![part("SKY", false, fan)];
+        }
        let mut parts = vec![part("SKY", false, sky)];
        if frame.sky.sunrise_color[3] > 0.001 {
            parts.push(part("SUNSET", false, sunset));
@@ -3,13 +3,15 @@
 //! `HORIZON_SHADER_PACK_TIMING=1`. One frame
 //! at a time is timed, and the CPU never waits for it: its timestamps are resolved in a later
 //! frame, once the GPU has finished it (Metal resolves them without waiting for the passes that
-//! write them), then read back when mapped. The next frame after that is timed again.
+//! write them), then read back when mapped. The next frame after that is timed again, once `gap`
+//! has passed since the last.

 use std::collections::VecDeque;
 use std::sync::{
    Arc,
    atomic::{AtomicBool, Ordering},
 };
+use std::time::{Duration, Instant};

 const REPORT: usize = 30;
 /// Passes timed per frame at most (two timestamps each).
@@ -43,6 +45,10 @@ pub struct PassTiming {
    /// `mark`'s pipeline, for the target format it was made for.
    marker: Option<(wgpu::TextureFormat, wgpu::RenderPipeline)>,
    reports: usize,
+    /// Least time between timed frames.
+    pub gap: Duration,
+    /// When the last timed frame began.
+    timed_at: Option<Instant>,
 }

 impl PassTiming {
@@ -81,6 +87,8 @@ impl PassTiming {
            log: Self::logging(),
            marker: None,
            reports: 0,
+            gap: Duration::ZERO,
+            timed_at: None,
        })
    }

@@ -123,9 +131,12 @@ impl PassTiming {
            }
            _ => {}
        }
-        if matches!(self.stage, Stage::Idle) {
+        if matches!(self.stage, Stage::Idle)
+            && self.timed_at.is_none_or(|at| at.elapsed() >= self.gap)
+        {
            self.names.clear();
            self.stage = Stage::Recording;
+            self.timed_at = Some(Instant::now());
        }
    }

@@ -709,6 +709,16 @@ fn smooth(value: f32, target: f32, half_life: f32, dt: f32) -> f32 {
 }

 impl FrameUniforms {
+    /// Forgets the frames before (the previous camera, smoothed values, the clock and the
+    /// centre depth), keeping the pack's atlas size and shadow settings.
+    pub(super) fn reset_history(&mut self) {
+        *self = Self {
+            atlas: self.atlas,
+            shadow: std::mem::take(&mut self.shadow),
+            ..Self::default()
+        };
+    }
+
    /// This frame's values for a render size of `size` pixels.
    pub fn update(&mut self, frame: &Frame, inputs: &PackInputs, size: [u32; 2]) {
        let now = std::time::Instant::now();
@@ -2367,6 +2377,61 @@ pub(super) mod initial_history_tests {
        assert_eq!((sixty.elapsed, sixty.delta), (1.0, 1.0 / 60.0));
    }

+    /// A reset pack draws its next frame as its first: no previous camera, smoothed values
+    /// at their targets, the clock from 0; the atlas size it was given stays.
+    #[test]
+    fn a_reset_forgets_the_uniforms_history_and_keeps_the_pack_s_settings() {
+        let hud = HudBatch::new([16, 16]);
+        let mut f = frame(&hud);
+        let mut uniforms = FrameUniforms {
+            atlas: [256, 128],
+            ..Default::default()
+        };
+        let mut inputs = PackInputs {
+            rain: 1.0,
+            eye_light: [15, 15],
+            frame_timing: Some(FrameTiming {
+                counter: 800,
+                elapsed: 99.0,
+                delta: 1.0,
+            }),
+            ..Default::default()
+        };
+        uniforms.center_depth_raw = Some(0.25);
+        uniforms.update(&f, &inputs, [16, 16]);
+        f.camera = glam::DVec3::new(7.0, 12.0, -30.0);
+        f.yaw = 77.0;
+        inputs.rain = 0.25;
+        inputs.eye_light = [3, 8];
+        inputs.frame_timing = None;
+        uniforms.reset_history();
+        uniforms.update(&f, &inputs, [16, 16]);
+        let float = |name| match uniforms.values[index(name).unwrap()] {
+            Value::F(v) => v,
+            _ => panic!("float uniform expected"),
+        };
+        let int = |name| match uniforms.values[index(name).unwrap()] {
+            Value::I(v) => v,
+            _ => panic!("integer uniform expected"),
+        };
+        assert_eq!(int("frameCounter")[0], 0);
+        assert_eq!(float("frameTime")[0], 0.0);
+        assert_eq!(int("atlasSize")[..2], [256, 128]);
+        assert_eq!(float("wetness")[0], 0.25);
+        assert_eq!(int("eyeBrightnessSmooth")[..2], [48, 128]);
+        assert_eq!(float("centerDepthSmooth")[0], 1.0);
+        for (previous, current) in [
+            ("previousCameraPosition", "cameraPosition"),
+            ("gbufferPreviousModelView", "gbufferModelView"),
+            ("gbufferPreviousProjection", "gbufferProjection"),
+        ] {
+            assert_eq!(
+                float(previous).map(f32::to_bits),
+                float(current).map(f32::to_bits)
+            );
+        }
+    }
+
    /// Iris 1.11.7 (probe pack): `ambientLight` is the dimension type's (0.1 in the Nether,
    /// 0.25 in the End), and `playerMood` and `constantMood` both the cave mood.
    #[test]
@@ -2411,6 +2476,7 @@ pub(super) mod initial_history_tests {
            skybox: false,
            end_sky: false,
            end_sky_sprite: None,
+            boss_world_fog: false,
            environment_fog: None,
            water_fog: [0.0; 3],
            fog: None,
@@ -2431,6 +2497,7 @@ pub(super) mod initial_history_tests {
            visible_static_block_entity_sections: &[],
            static_block_entity_stats: crate::block_entity_render::StaticCacheFrameStats::default(),
            entity_motion: &[],
+            entity_motion_posed: &[],
            colored_lights: &[],
            emissive_layers: &[],
            shadow_only: &[],
@@ -323,4 +323,27 @@ mod tests {
        let unorm = wgpu::TextureFormat::Rgba16Unorm;
        reaches_an_8_bit_swapchain(&device, &queue, unorm, color, [0, 51, 255, 255]);
    }
+
+    /// `Rgba16Float`, the frame of a shader API 0.2 pack, or of HDR on without a pack, under
+    /// `HORIZON_HDR_FRAME=float` (`Renderer::frame_format`): what is left over 1 is clipped on
+    /// the way.
+    #[test]
+    fn a_float_frame_reaches_an_8_bit_swapchain() {
+        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;
+        };
+        let color = wgpu::Color {
+            r: 1.5,
+            g: 0.2,
+            b: -0.5,
+            a: 1.0,
+        };
+        let float = wgpu::TextureFormat::Rgba16Float;
+        reaches_an_8_bit_swapchain(&device, &queue, float, color, [0, 51, 255, 255]);
+    }
 }
@@ -0,0 +1,66 @@
+//! Opaque/cutout terrain-sheet native models, with ordinary culling and depth writes.
+pub(super) fn pipelines(
+    device: &wgpu::Device,
+    layout: Option<&wgpu::PipelineLayout>,
+    shader: &wgpu::ShaderModule,
+    format: wgpu::TextureFormat,
+    sprite_constants: &[(&str, f64)],
+) -> [wgpu::RenderPipeline; 3] {
+    std::array::from_fn(|i| {
+        let mut constants = sprite_constants.to_vec();
+        constants.push(("NATIVE_MODEL_ALPHA_CUTOFF", [0.0, 0.1, 0.5][i]));
+        // The ordinary Vertex ABI is unchanged. This material's private payload uses
+        // normal's four bytes for a float z, and glint UV for float normal x/y.
+        let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Uint32,6=>Float32x2];
+        device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some(
+                [
+                    "Native model solid",
+                    "Native model cutout",
+                    "Native model cutout mipmapped",
+                ][i],
+            ),
+            layout,
+            vertex: wgpu::VertexState {
+                module: shader,
+                entry_point: Some("vs_native_model"),
+                compilation_options: wgpu::PipelineCompilationOptions {
+                    constants: &constants,
+                    ..Default::default()
+                },
+                buffers: &[Some(wgpu::VertexBufferLayout {
+                    array_stride: std::mem::size_of::<super::Vertex>() as u64,
+                    step_mode: wgpu::VertexStepMode::Vertex,
+                    attributes: &attributes,
+                })],
+            },
+            primitive: wgpu::PrimitiveState {
+                cull_mode: Some(wgpu::Face::Back),
+                ..Default::default()
+            },
+            depth_stencil: Some(wgpu::DepthStencilState {
+                format: wgpu::TextureFormat::Depth32Float,
+                depth_write_enabled: Some(true),
+                depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
+                stencil: Default::default(),
+                bias: Default::default(),
+            }),
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: shader,
+                entry_point: Some("fs_native_model"),
+                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,
+        })
+    })
+}
@@ -217,15 +217,19 @@ struct HorizonWeatherOut {
        textureDimensions(horizon_entity_atlas));
    let color = textureLoad(horizon_entity_atlas, texel, 0) * in.color;
    if color.a < 0.1 { discard; }
-    return weather(WeatherInput(color, in.light, in.position, in.snow != 0u));
+    let input = WeatherInput(vec4(horizon_line_in(color.rgb), color.a), in.light, in.position,
+        in.snow != 0u);
+    let out = weather(input);
+    return vec4(horizon_line_out(out.rgb), out.a);
 }
 ";

 /// The shader of a native pack's weather stage `source`.
-fn native_source(source: &str) -> String {
+fn native_source(source: &str, api: horizon_shader_api::Api) -> String {
    format!(
-        "{source}\n// Horizon's weather (entity.wgsl)\n{}{NATIVE_ENTRIES}",
-        super::wgsl_prefix::prefixed(&super::entity_shader(), "horizon_entity_")
+        "{source}\n// Horizon's weather (entity.wgsl)\n{}{}{NATIVE_ENTRIES}",
+        super::wgsl_prefix::prefixed(&super::entity_shader(), "horizon_entity_"),
+        super::native_post::line_helpers(api)
    )
 }

@@ -242,7 +246,7 @@ pub(super) fn native_pipeline(
    constants: &[(String, f64)],
 ) -> Result<wgpu::RenderPipeline, String> {
    use horizon_shader_api::stages::GROUP;
-    let text = native_source(&stage.source);
+    let text = native_source(&stage.source, frame.api);
    let module = naga::front::wgsl::parse_str(&text)
        .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))?;
    let present = super::native_post::present_constants(&module, constants);
@@ -318,19 +322,21 @@ mod tests {

    #[test]
    fn a_native_weather_stage_validates() {
-        use horizon_shader_api::stages::StageKind;
-        let source = StageKind::Weather.prelude(horizon_shader_api::Api::V0_1)
-            + "fn weather(input: WeatherInput) -> vec4<f32> {\n    \
-               return input.color * vec4(input.light, input.position.x, f32(input.snow));\n}\n";
-        let text = native_source(&source);
-        let module = naga::front::wgsl::parse_str(&text)
+        use horizon_shader_api::{Api, stages::StageKind};
+        for api in [Api::V0_1, Api::V0_2] {
+            let source = StageKind::Weather.prelude(api)
+                + "fn weather(input: WeatherInput) -> vec4<f32> {\n    \
+                   return input.color * vec4(input.light, input.position.x, f32(input.snow));\n}\n";
+            let text = native_source(&source, api);
+            let module = naga::front::wgsl::parse_str(&text)
+                .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
+            naga::valid::Validator::new(
+                naga::valid::ValidationFlags::all(),
+                naga::valid::Capabilities::all(),
+            )
+            .validate(&module)
            .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
-        naga::valid::Validator::new(
-            naga::valid::ValidationFlags::all(),
-            naga::valid::Capabilities::all(),
-        )
-        .validate(&module)
-        .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
+        }
    }
    use crate::weather::{Parameters, Time};
    use wgpu::util::DeviceExt;
@@ -257,14 +257,23 @@ impl Post {

    /// The world's rendered size and the size it is shown at (TAA's history).
    fn sizes(&self, window: [u32; 2]) -> ([u32; 2], [u32; 2]) {
-        let output = window.map(|v| ((v as f32 * self.scale).round() as u32).clamp(1, 8192));
        let upscale = if self.taa_on { self.upscale } else { 1.0 };
+        self.sizes_with_upscale(window, upscale)
+    }
+
+    fn sizes_with_upscale(&self, window: [u32; 2], upscale: f32) -> ([u32; 2], [u32; 2]) {
+        let output = window.map(|v| ((v as f32 * self.scale).round() as u32).clamp(1, 8192));
        (
            output.map(|v| ((v as f32 / upscale).round() as u32).max(1)),
            output,
        )
    }

+    /// The next TAA frame's input size, even before its first jitter or resize.
+    pub(super) fn taa_render_size(&self, window: [u32; 2]) -> [u32; 2] {
+        self.sizes_with_upscale(window, self.upscale).0
+    }
+
    /// TAA's sub-pixel jitter this frame, as a clip-space matrix to multiply into the
    /// world's projection (identity while `on` is false); `view_proj` is the unjittered
    /// projection, relative to `camera`. Call it before `prepare`, once per frame.
@@ -604,7 +613,7 @@ mod tests {

    #[test]
    fn jitter_stays_inside_the_pixel() {
-        for i in 1..=8 {
+        for i in 1..=128 {
            let (x, y) = (halton(i, 2), halton(i, 3));
            assert!((0.0..1.0).contains(&x) && (0.0..1.0).contains(&y));
        }
@@ -614,6 +623,30 @@ mod tests {
        );
    }

+    #[test]
+    fn culling_uses_the_next_taa_size_before_the_first_jitter_or_resize() {
+        let Some((device, _)) = test_device() else {
+            return;
+        };
+        let mut post = Post::new(&device, wgpu::TextureFormat::Rgba8Unorm);
+        assert!(!post.taa_on);
+        assert!(post.size().is_none());
+        for (window, scale, upscale, expected) in [
+            ([1280, 720], 1.0, 1.0, [1280, 720]),
+            ([1281, 721], 0.5, 2.0, [321, 181]),
+            ([3840, 2160], 0.25, 4.0, [240, 135]),
+            ([10000, 10000], 2.0, 4.0, [2048, 2048]),
+            ([0, 0], 0.5, 4.0, [1, 1]),
+        ] {
+            post.scale = scale;
+            post.upscale = upscale;
+            post.taa_on = false;
+            assert_eq!(post.taa_render_size(window), expected);
+            post.taa_on = true;
+            assert_eq!(post.sizes(window).0, expected);
+        }
+    }
+
    fn test_device() -> Option<(wgpu::Device, wgpu::Queue)> {
        let instance = crate::gfx::test_gpu::instance();
        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
@@ -771,7 +771,7 @@ pub struct Graphics {
    /// is made (start, resource-pack reload), like `translucent_batching`, where it is offered
    /// (`smooth_gradients_offered`).
    pub hdr_smooth_gradients: bool,
-    /// The shader pack picked in `shaderpacks/` (`shader_pack_list`); empty: none. Its key is
+    /// The native `horizon:<manifest-id>` or classic filename picked in `shaderpacks/`; empty: none. Its key is
    /// not `shaderPack`, which versions before the clean-room rewrite saved and which stays
    /// ignored.
    pub shader_pack: String,
@@ -1092,8 +1092,9 @@ impl Graphics {
        // (horizon_threads: niced on Linux; on macOS and Windows the server
        // and render threads are raised above four cores, where vanilla
        // raises its server thread). Leaving two idled a core of a 4-thread
-        // laptop while a world loaded: a teleport there took ~15% longer.
-        let auto = horizon_threads::worker_count().saturating_sub(1).max(1);
+        // laptop while a world loaded: a teleport there took ~15% longer. On Apple
+        // silicon only the performance cores count (horizon_threads::default_workers).
+        let auto = horizon_threads::jobs::default_threads();
        if self.battery { auto.div_ceil(2) } else { auto }
    }
    /// The frame cap battery mode adds: 60 in a world, 30 in menus without a
@@ -1476,7 +1477,10 @@ mod tests {
        let g = Graphics::default();
        assert_eq!(g.workers, 0);
        let cores = horizon_threads::worker_count();
-        assert_eq!(g.worker_threads(), cores.saturating_sub(1).max(1));
+        assert!((1..=cores.saturating_sub(1).max(1)).contains(&g.worker_threads()));
+        if !cfg!(target_vendor = "apple") {
+            assert_eq!(g.worker_threads(), cores.saturating_sub(1).max(1));
+        }
        // A manual count is the player's own choice, kept as asked.
        let manual = Graphics { workers: 3, ..g };
        assert_eq!(manual.worker_threads(), 3);
@@ -639,12 +639,20 @@ pub fn rows() -> Vec<(Page, Vec<(&'static str, Vec<Setting>)>)> {
 /// BlueMap download radii, in chunks.
 const BLUE_MAP_RADII: [u32; 5] = [16, 32, 64, 128, 256];
 const UPLOAD_STEPS: [u32; 8] = [0, 256, 512, 1024, 2048, 4096, 8192, 16384];
-/// What the LOD Distance slider stops at, in chunks: off, then each doubling
+/// What the LOD Distance slider stops at, in chunks: off, fine steps up to 256
+/// for a short ring of far terrain past a small render distance (a phone or an
+/// integrated GPU at 8 chunks wants LOD to 12 or 16, not 64), then each doubling
 /// up to the whole world.
-const LOD_STEPS: [u32; 18] = [
+const LOD_STEPS: [u32; 24] = [
    0,
+    16,
+    24,
+    32,
+    48,
    64,
+    96,
    128,
+    192,
    256,
    512,
    1024,
@@ -2692,12 +2700,21 @@ mod tests {
            item.label(&s).plain(),
            format!("LOD Distance: {} chunks", crate::lod::MAX_CHUNKS)
        );
-        item.set_slider(&mut s, 5.0 / 17.0);
+        item.set_slider(&mut s, 11.0 / 23.0);
        assert_eq!(s.horizon.lod_distance, 1024);
        assert_eq!(item.label(&s).plain(), "LOD Distance: 1024 chunks");
+        // The fine stops: a ring of far terrain just past a small render
+        // distance, which the doubling steps skipped (#9694).
+        item.set_slider(&mut s, 1.0 / 23.0);
+        assert_eq!(s.horizon.lod_distance, 16);
+        assert_eq!(item.label(&s).plain(), "LOD Distance: 16 chunks");
+        item.set_slider(&mut s, 2.0 / 23.0);
+        assert_eq!(s.horizon.lod_distance, 24);
        // A distance between stops (from the file) sits on the next one.
        s.horizon.lod_distance = 3000;
-        assert_eq!(item.slider(&s), Some(7.0 / 17.0));
+        assert_eq!(item.slider(&s), Some(13.0 / 23.0));
+        s.horizon.lod_distance = 12;
+        assert_eq!(item.slider(&s), Some(1.0 / 23.0));
        assert_eq!(
            Item::Vanilla(Opt::RenderDistance).label(&s).plain(),
            format!("Full Detail Distance: {near} chunks")
@@ -61,9 +61,10 @@ fn shows_world(c: vec3<f32>, w: vec3<f32>) -> bool {
 // A texel with its alpha as an 8-bit frame holds it. A 16-bit frame
 // (Renderer::frame_format) keeps alpha between 8-bit steps, where the marks below
 // would read differently (an alpha of 0.001 would count as the hand); its colour
-// keeps the gradients 8 bits would band. On an 8-bit frame nothing changes.
+// keeps the gradients 8 bits would band, and a float frame's (LINEAR_FRAME) the
+// light over 1 that blends added past white. On an 8-bit frame nothing changes.
 fn frame_texel(v: vec4<f32>) -> vec4<f32> {
-    return vec4(saturate(v.rgb), round(saturate(v.a) * 255.0) / 255.0);
+    return vec4(max(v.rgb, vec3(0.0)), round(saturate(v.a) * 255.0) / 255.0);
 }

 // Linear BT.709 to BT.2020 (ITU-R BT.2087), columns first.
@@ -161,15 +162,12 @@ fn calibration_nits(p: vec2<f32>, size: vec2<f32>) -> f32 {
        return vec4(nits / 80.0, 1.0);
    }
    let f = frame_texel(textureLoad(frame, at, 0));
-    let c = f.rgb;
    // 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);
-    // Gamma 2.2, as SDR displays and the compositors' SDR paths decode it.
-    var light = pow(max(c, vec3(0.0)), vec3(2.2));
    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
@@ -179,11 +177,19 @@ fn calibration_nits(p: vec2<f32>, size: vec2<f32>) -> f32 {
    // writes its own alpha there (Hdr::hand_light_view): 1, or a light source it holds.
    var lifted = false;
    let shows = params.world > 0.5 && params.peak > 1.0
-        && (hand || (!covered && shows_world(c, w.rgb)));
+        && (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);
+    // 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.
-    if shows && w.a >= 0.75 {
+    // 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 {
        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 v = top * gain;
@@ -214,6 +220,7 @@ 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);
    let scrgb = light * params.paper;
@@ -1354,6 +1354,11 @@ impl HudAtlas {
                bordered.insert(image.0.clone());
            }
        }
+        if full {
+            let (width, height, rgba) =
+                decode_bytes(include_bytes!("jei_recipes/config_button.png"))?;
+            images.push(("horizon/recipes/settings".to_owned(), width, height, rgba));
+        }
        images.sort_by(|a, b| b.2.cmp(&a.2).then(b.1.cmp(&a.1)));
        let (width, placements, glyph_region) =
            Self::layout_leaving_out(&mut images, &mut animated, &cit_names, MAX_ATLAS_SIZE)?;
@@ -485,11 +485,6 @@ pub struct HealthHud {
    /// `Util.getMillis()` of the last health change.
    pub last_health_time: i64,
    pub health_blink_time: i64,
-    /// `Hud.leftHeight` and `rightHeight` once the health, armor, food, mount
-    /// and air layers have run; the selected item name and the action bar sit
-    /// above them.
-    pub left_height: i32,
-    pub right_height: i32,
    /// `Hud.lastBubblePopSoundPlayed`.
    pub last_bubble_pop_sound: i32,
    /// The `ui.hud.bubble_pop` volume and pitch `playAirBubblePoppedSound`
@@ -655,9 +650,6 @@ impl HealthHud {
        let rows = ceil((max_health + absorption as f32) / 2.0 / 10.0);
        let row_height = (10 - (rows - 2)).max(3);
        let mut y_air = y_base - 10;
-        self.left_height = 39 + (rows - 1) * row_height + 10 + if i.armor > 0 { 10 } else { 0 };
-        // The mount's heart rows (`extractVehicleHealth`); food adds its row below.
-        self.right_height = 39 + 10 * ((i.vehicle_hearts + 9) / 10);
        let offset_index = if i.regeneration {
            i.tick % ceil(max_health + 5.0)
        } else {
@@ -752,13 +744,11 @@ impl HealthHud {
                }
            }
            y_air -= 10;
-            self.right_height += 10;
        }
        // Hud.extractAirBubbles.
        let max_air = i.max_air.max(1);
        let air = i.air.clamp(0, max_air);
        if i.under_water || air < max_air {
-            self.right_height += 10;
            let rows = (f64::from(i.vehicle_hearts) / 10.0).ceil() as i32;
            let y = y_air - (rows - 1) * 10;
            let bubble = |offset: i32| ceil(((air + offset) * 10) as f32 / max_air as f32);
@@ -115,8 +115,7 @@ impl From<&crate::effects::EffectInstance> for EffectIcon {
            color: def.map_or(0, |d| d.color as i32),
            ambient: effect.ambient,
            duration: effect.duration,
-            // Horizon keeps no showIcon flag: every effect shows its icon.
-            show_icon: true,
+            show_icon: effect.show_icon,
        }
    }
 }
@@ -323,13 +322,12 @@ impl Titles {
            }
        }
    }
-    /// `Hud.extractOverlayMessage`; `bar_height` is
-    /// `max(leftHeight, rightHeight)`.
+    /// `Hud.extractOverlayMessage`: the action bar keeps its place however
+    /// tall the health, food, air and mount rows above the hotbar are.
    pub fn overlay_message(
        &self,
        w: i32,
        h: i32,
-        bar_height: i32,
        partial: f32,
        font: &Font,
        background: u32,
@@ -345,12 +343,11 @@ impl Titles {
        let alpha = ((t * 255.0 / 20.0) as i32).min(255);
        if alpha > 0 {
            let message = message.resolve_legacy();
-            // The bars' height plus the gap between the item name (59) and the
-            // overlay (68), at least the default level.
-            let y_shift = bar_height + (68 - 59);
+            // `Hud.extractOverlayMessage` translates to `guiHeight - 68`, a
+            // constant the bars above the hotbar never move.
            out.push(GuiDraw::Push(vec![PoseOp::Translate(
                (w / 2) as f32,
-                (h - y_shift.max(68)) as f32,
+                (h - 68) as f32,
            )]));
            let color = if self.overlay_animated {
                hsv_to_argb(t / 50.0, 0.7, 0.6, alpha as u32)
@@ -468,13 +465,13 @@ impl ToolHighlight {
        self.last = selected;
    }
    /// `Hud.extractSelectedItemName`; `can_hurt` is
-    /// `gameMode.canHurtPlayer()` (survival and adventure) and `bar_height`
-    /// is `max(leftHeight, rightHeight)`.
+    /// `gameMode.canHurtPlayer()` (survival and adventure). The name sits 59
+    /// pixels above the bottom edge whatever the bars above the hotbar do,
+    /// and 14 lower when the mode cannot hurt the player.
    pub fn draw(
        &self,
        w: i32,
        h: i32,
-        bar_height: i32,
        can_hurt: bool,
        font: &Font,
        background: u32,
@@ -495,7 +492,7 @@ impl ToolHighlight {
        }
        let str_width = width(font, &name);
        let x = (w - str_width) / 2;
-        let mut y = h - bar_height.max(59);
+        let mut y = h - 59;
        if !can_hurt {
            y += 14;
        }
@@ -1295,3 +1292,92 @@ mod subtitle_tests {
        assert!(!o.listening());
    }
 }
+
+#[cfg(test)]
+mod text_position_tests {
+    use super::*;
+    use crate::{font::Font, hud::Rect};
+    use std::{collections::HashMap, path::Path};
+
+    /// The missing-glyph metrics let these tests run without game assets.
+    fn font() -> Font {
+        Font::load(
+            Path::new("/nonexistent-horizon-hud-test-resources"),
+            &HashMap::new(),
+            &[],
+            (1, 1),
+            (0, 0),
+            Rect {
+                u0: 0.0,
+                v0: 0.0,
+                u1: 1.0,
+                v1: 1.0,
+                w: 1,
+                h: 1,
+            },
+        )
+    }
+
+    fn held() -> HeldName {
+        HeldName {
+            item: "minecraft:stone".into(),
+            hover_name: Text::literal("Stone"),
+            rarity_color: 0xFFFF_FFFF,
+            custom_name: false,
+        }
+    }
+
+    fn text_top(draws: &[GuiDraw]) -> Option<i32> {
+        draws.iter().find_map(|d| match d {
+            GuiDraw::Text { y, .. } => Some(*y),
+            _ => None,
+        })
+    }
+
+    /// `Hud.extractSelectedItemName`: `guiHeight - 59`, then `+ 14` when the
+    /// game mode cannot hurt the player. The health, food, air and mount rows
+    /// above the hotbar never move it: with armor and a second row of hearts
+    /// they reach 69 pixels, and the name stays where vanilla draws it.
+    #[test]
+    fn the_selected_item_name_sits_fifty_nine_above_the_bottom_edge() {
+        let mut highlight = ToolHighlight {
+            last: Some(held()),
+            timer: 40,
+        };
+        let f = font();
+        let draws = highlight.draw(320, 240, true, &f, 0);
+        assert_eq!(text_top(&draws), Some(240 - 59));
+        // Creative and spectator add the fourteen pixels the experience bar
+        // and the food row would have taken.
+        let draws = highlight.draw(320, 240, false, &f, 0);
+        assert_eq!(text_top(&draws), Some(240 - 59 + 14));
+        // No timer, no name.
+        highlight.timer = 0;
+        assert!(highlight.draw(320, 240, true, &f, 0).is_empty());
+    }
+
+    /// `Hud.extractOverlayMessage`: the action bar and its text translate to
+    /// `guiHeight - 68` and `-4`, again wherever the bars above the hotbar
+    /// reach.
+    #[test]
+    fn the_action_bar_sits_sixty_eight_above_the_bottom_edge() {
+        let mut titles = Titles::default();
+        titles.set_overlay(Text::literal("Action bar"), false);
+        let f = font();
+        let draws = titles.overlay_message(320, 240, 0.0, &f, 0);
+        let translate = draws.iter().find_map(|d| match d {
+            GuiDraw::Push(ops) => ops.iter().find_map(|op| match op {
+                PoseOp::Translate(_, y) => Some(*y),
+                _ => None,
+            }),
+            _ => None,
+        });
+        assert_eq!(translate, Some((240 - 68) as f32));
+        // The text is drawn four pixels below that origin, as vanilla's is.
+        let relative = draws.iter().find_map(|d| match d {
+            GuiDraw::Text { y, .. } => Some(*y),
+            _ => None,
+        });
+        assert_eq!(relative, Some(-4));
+    }
+}
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 mezz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND 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.
@@ -14,6 +14,7 @@ pub mod block_entity_anim;
 pub mod block_entity_cem;
 pub mod block_entity_render;
 pub mod block_sprites;
+pub mod block_states;
 pub mod bluemap;
 pub mod bluemap_detect;
 pub mod border_render;
@@ -27,6 +28,7 @@ pub mod cit;
 pub mod cit_armor;
 pub mod cit_assets;
 pub mod cit_glint;
+pub mod client_resources;
 pub mod clouds;
 pub mod collisions;
 pub mod command_block;
@@ -34,12 +36,14 @@ pub mod connected;
 pub mod containers;
 pub mod controller_ui;
 pub mod crash;
+pub mod custom_sky;
 pub mod datapack;
 pub mod dynamic_light;
 pub mod effects;
 pub mod environment;
 pub mod extras;
 pub mod fast_hash;
+pub mod fluid_render;
 pub mod fog;
 pub mod font;
 pub mod fusion;
@@ -54,6 +58,7 @@ pub mod hud_overlays;
 pub mod inventory_effects;
 pub mod java_text;
 pub mod jigsaw_block;
+pub mod terrain_model;
 pub use horizon_world::json_folder;
 pub mod level_loading;
 pub mod light;
@@ -274,6 +274,8 @@ enum Out {
        date: NaiveDate,
        lines: Vec<String>,
        stderr: Option<String>,
+        /// The message's level, thread and text, for the [`set_line_hook`] callback.
+        record: (log::Level, String, String),
    },
    /// Answer once everything before is written.
    Flush(mpsc::SyncSender<()>),
@@ -293,12 +295,14 @@ struct Writer {
 impl Writer {
    fn run(mut self, out: mpsc::Receiver<Out>) {
        let stderr = io::stderr();
+        let mut hook_alive = true;
        for msg in out {
            match msg {
                Out::Write {
                    date,
                    lines,
                    stderr: message,
+                    record: (level, thread, text),
                } => {
                    if let Some(message) = message {
                        let _ = writeln!(stderr.lock(), "{message}");
@@ -319,6 +323,12 @@ impl Writer {
                        text.push('\n');
                        let _ = latest.file.write_all(text.as_bytes());
                    }
+                    // After the file has it. A callback that panics is not called again: the
+                    // panic's own log line would reach it next.
+                    if let Some(hook) = LINE_HOOK.get().filter(|_| hook_alive) {
+                        let call = || hook(level.as_str(), &thread, &text, &lines.join("\n"));
+                        hook_alive = std::panic::catch_unwind(call).is_ok();
+                    }
                }
                Out::Flush(done) => {
                    if let Some(latest) = &mut self.file {
@@ -395,6 +405,18 @@ impl Floods {

 static LOGGER: std::sync::OnceLock<Logger> = std::sync::OnceLock::new();

+/// What [`set_line_hook`] installed: level (`INFO`, `WARN`, `ERROR`), thread, message, and the
+/// lines as `latest.log` got them.
+type LineHook = fn(&str, &str, &str, &str);
+static LINE_HOOK: std::sync::OnceLock<LineHook> = std::sync::OnceLock::new();
+
+/// Calls `hook` on the log's writer thread for each message written to the log, once the file
+/// has it, so the thread that logged never waits on it. Once per process; a second call keeps
+/// the first.
+pub fn set_line_hook(hook: LineHook) {
+    let _ = LINE_HOOK.set(hook);
+}
+
 fn ours(target: &str) -> bool {
    target.starts_with("horizon")
 }
@@ -490,6 +512,7 @@ impl Logger {
            date: now.date_naive(),
            lines,
            stderr,
+            record: (level, thread.to_owned(), message.to_owned()),
        };
        if let Err(mpsc::SendError(Out::Write {
            stderr: Some(message),
@@ -502,12 +525,25 @@ impl Logger {
    }
 }

+/// The `latest.log` this run writes, once `init` opened it.
+static LATEST_PATH: std::sync::OnceLock<PathBuf> = std::sync::OnceLock::new();
+
+/// The `latest.log` this run writes, absolute; None before `init` and when it logs to the
+/// terminal only.
+pub fn latest_path() -> Option<PathBuf> {
+    LATEST_PATH.get().cloned()
+}
+
 /// Starts the log in `home/logs`. The main thread shows as `main_thread` in it. Messages are
 /// still printed when the file cannot be opened.
 pub fn init(home: &Path, main_thread: &'static str) {
    let dir = logs_dir(home);
    let file = match open_latest(&dir) {
-        Ok(Some(latest)) => Some(latest),
+        Ok(Some(latest)) => {
+            let path = dir.join("latest.log");
+            let _ = LATEST_PATH.set(std::path::absolute(&path).unwrap_or(path));
+            Some(latest)
+        }
        Ok(None) => {
            eprintln!(
                "Horizon: another game is writing {}; this one logs to the terminal only",
@@ -90,6 +90,11 @@ fn round_to_u16(v: f32) -> u16 {
 }
 /// Fixed-point steps per unit of `TerrainVertex` UVs, which span `[0, 2)`.
 pub const UV_STEPS: f32 = 32768.0;
+/// A model quad's own UVs in `TerrainVertex` fixed point, the packing
+/// `TerrainVertex::new` does, baked once per face (`BakedFace::uv_fixed`).
+pub(crate) fn baked_uv(uv: [[f32; 2]; 4]) -> [[u16; 2]; 4] {
+    uv.map(|uv| uv.map(|v| round_to_u16(v * UV_STEPS)))
+}
 /// Fixed-point steps per block of distant-terrain UVs (`TerrainVertex::tiled`),
 /// which span `[0, 2048)`: merged faces repeat their sprite once per block.
 pub const TILED_UV_STEPS: f32 = 32.0;
@@ -103,6 +108,23 @@ impl TerrainVertex {
            color,
        }
    }
+    /// A vertex whose UV is already in `UV_STEPS` fixed point (a model face's
+    /// own UVs, baked in `BakedFace::uv_fixed`).
+    pub(crate) fn packed_uv(
+        pos: [f32; 3],
+        uv: [u16; 2],
+        layer: u16,
+        color: u32,
+        light: u16,
+    ) -> Self {
+        Self {
+            pos,
+            uv,
+            layer,
+            light,
+            color,
+        }
+    }
    /// A vertex of a merged distant-terrain face, its UV in blocks from the
    /// face's corner. Drawn with an instance UV scale of `1 / TILED_UV_STEPS`.
    pub fn tiled(pos: [f32; 3], uv: [f32; 2], layer: u16, color: u32, light: u16) -> Self {
@@ -122,6 +144,63 @@ impl TerrainVertex {
 #[cfg(test)]
 mod vertex_tests {
    use super::TerrainVertex;
+
+    #[test]
+    fn baked_face_keeps_shape_bounds_and_fixed_point_uvs() {
+        use crate::models::catalog::BakedFace;
+        use horizon_assets::{
+            bake::ModelQuad,
+            model::{Direction, Material},
+        };
+
+        let face = BakedFace::new(
+            ModelQuad {
+                positions: [
+                    [-0.25, 0.5, 0.125],
+                    [-0.25, 0.5, 0.875],
+                    [0.625, 0.5, 0.875],
+                    [0.625, 0.5, 0.125],
+                ],
+                uv: [
+                    [-0.25, f32::NAN],
+                    [1.0 / 65536.0, 3.0 / 65536.0],
+                    [1.5, 2.0],
+                    [f32::INFINITY, f32::NEG_INFINITY],
+                ],
+                facing: Direction::Up,
+                cull: None,
+                material: Material {
+                    sprite: "test:face".into(),
+                    force_translucent: false,
+                },
+                tint_index: -1,
+                shade_direction_override: None,
+                light_emission: 0,
+                light: [0; 2],
+                color: None,
+                ambient_occlusion: None,
+                render_type: None,
+                shade: true,
+            },
+            0,
+            true,
+            false,
+            None,
+        );
+        // Literal expectations: axis-ordered extrema and complements, plus
+        // clamping and half-step rounding in 1/32768 UV units.
+        let bounds: [f32; 12] = [
+            0.5, 0.5, 0.125, 0.875, -0.25, 0.625, 0.5, 0.5, 0.875, 0.125, 1.25, 0.375,
+        ];
+        for shape in face.shapes {
+            assert_eq!(shape.bounds.map(f32::to_bits), bounds.map(f32::to_bits));
+            assert!(shape.partial);
+        }
+        assert!(!face.shapes[0].cubic);
+        assert!(face.shapes[1].cubic);
+        assert_eq!(face.uv_fixed, [[0, 0], [1, 2], [49152, 65535], [65535, 0]]);
+    }
+
    #[test]
    fn model_uvs_pack_exactly() {
        for i in 0..=32 {
@@ -957,6 +1036,12 @@ const P: usize = 16 + 2 * B as usize;
 fn pi(x: i32, y: i32, z: i32) -> usize {
    ((y + B) as usize * P + (z + B) as usize) * P + (x + B) as usize
 }
+/// `pi`'s index offset of a step `n`: `pi(p + n) - pi(p)`, so the samples
+/// around a cell are `base + step_index(n)` rather than another `pi`.
+#[inline]
+const fn step_index(n: [i32; 3]) -> isize {
+    (n[0] + P as i32 * n[2] + (P * P) as i32 * n[1]) as isize
+}
 /// Blocks and light of one section plus a `B`-block border.
 #[derive(Default)]
 struct Padded {
@@ -1079,6 +1164,17 @@ const DIRECTIONS: [(Direction, [i32; 3], u8); 6] = [
 const fn direction_info(d: Direction) -> (Direction, [i32; 3], u8) {
    (d, d.normal(), d.opposite() as u8)
 }
+/// `step_index` of each direction's normal, indexed like `DIRECTIONS`: the
+/// padded index of a block's neighbour is its own plus one of these.
+const OFFSETS: [isize; 6] = {
+    let mut out = [0isize; 6];
+    let mut i = 0;
+    while i < 6 {
+        out[i] = step_index(DIRECTIONS[i].1);
+        i += 1;
+    }
+    out
+};
 /// Per-worker temporary arrays. They never hold resource-pack references or
 /// geometry still owned by the renderer, and total about 150 KiB per worker
 /// (the leaf mask adds 8,000 cells, depths and a queue).
@@ -1540,8 +1636,12 @@ impl Mesher<'_> {
        let mut models = Vec::new();
        for y in 0..16 {
            for z in 0..16 {
+                // The padded index of the row's x = 0 cell: `pi(x, y, z)` is
+                // `row + x` and a neighbour adds `OFFSETS[d]`.
+                let row = pi(0, y, z);
                for x in 0..16 {
-                    let id = pad.blocks[pi(x, y, z)];
+                    let cell = row + x as usize;
+                    let id = pad.blocks[cell];
                    if id == 0 {
                        continue;
                    }
@@ -1596,7 +1696,7 @@ impl Mesher<'_> {
                        && self.leaf_culling.is_interior()
                        && scratch.leaf.interior(self.leaf_culling, x, y, z);
                    for (d, [dx, dy, dz], opposite) in DIRECTIONS {
-                        let neighbor = pad.blocks[pi(x + dx, y + dy, z + dz)];
+                        let neighbor = pad.blocks[(cell as isize + OFFSETS[d as usize]) as usize];
                        // `should_render_face`'s first test, without its lookups: a
                        // full occlusion face toward this block hides the face.
                        if full_faces[neighbor as usize] >> opposite & 1 != 0 {
@@ -1656,7 +1756,8 @@ impl Mesher<'_> {
                                let on_edge = p.iter().all(|v| (v[1] - plane).abs() < 1e-4);
                                let centre =
                                    [0, 2].map(|k| p.iter().map(|v| v[k]).sum::<f32>() / 4.0);
-                                let other = pad.blocks[pi(x, y + dy, z)];
+                                let other =
+                                    pad.blocks[(cell as isize + step_index([0, dy, 0])) as usize];
                                if on_edge && connected.stacked_pane_hides(id, other, centre) {
                                    continue;
                                }
@@ -1666,6 +1767,7 @@ impl Mesher<'_> {
                                &mut tints,
                                &mut out,
                                [x, y, z],
+                                cell,
                                origin,
                                face,
                                ao,
@@ -1706,6 +1808,7 @@ impl Mesher<'_> {
        tints: &mut Tints,
        out: &mut SectionMesh,
        pos: [i32; 3],
+        cell: usize,
        origin: [f32; 3],
        face: &BakedFace,
        ao: bool,
@@ -1730,11 +1833,14 @@ impl Mesher<'_> {
        } else {
            lighting::cardinal(self.nether_shading, shade_face)
        };
+        // The quad's shape (bounds, partial, cubic), baked per face for full and
+        // non-full blocks: a pure function of the quad and the block's `full`.
+        let shape = &face.shapes[usize::from(state.full)];
        // Grey level per vertex before tinting, vanilla light coords, and ambient occlusion factor.
        let (gray, coords, ao_factor) = if ao {
            let info = &self.tables.info;
            let (brightness, coords) =
-                lighting::ambient_occlusion(pad, info, state, pos, &q.positions, q.facing);
+                lighting::ambient_occlusion(pad, info, state, pos, shape, q.facing);
            let gray = if self.separate_ao {
                [lighting::gray(directional); 4]
            } else {
@@ -1744,7 +1850,7 @@ impl Mesher<'_> {
        } else {
            let coords = match q.cull {
                Some(d) => lighting::coords(pad, state, lighting::step(pos, d)),
-                None => lighting::flat(pad, state, pos, &q.positions, q.facing),
+                None => lighting::flat_shaped(pad, state, pos, q.facing, shape),
            };
            ([lighting::gray(directional); 4], [coords; 4], [1.0f32; 4])
        };
@@ -1768,8 +1874,7 @@ impl Mesher<'_> {
                count += 1;
            }
        };
-        let neighbour =
-            |[dx, dy, dz]: [i32; 3]| pad.blocks[pi(pos[0] + dx, pos[1] + dy, pos[2] + dz)];
+        let neighbour = |n: [i32; 3]| pad.blocks[(cell as isize + step_index(n)) as usize];
        let fused = face.fusion.and_then(|rule| {
            fusion.pick(
                rule,
@@ -1810,44 +1915,41 @@ impl Mesher<'_> {
                &mut push,
            )
        };
+        let vertex = |tint: Option<u32>, i: usize, uv: [u16; 2]| {
+            let g = gray[i] as u32;
+            let rgb = match tint {
+                Some(t) => [16, 8, 0].map(|shift| g * (t >> shift & 255) / 255),
+                None => [g; 3],
+            };
+            let p = q.positions[i];
+            let color = if self.separate_ao {
+                let ao_byte = (ao_factor[i] * 255.0).round().clamp(0.0, 255.0) as u32;
+                ao_byte << 24 | (pack_rgb(rgb) & 0x00FF_FFFF)
+            } else {
+                emitting(pack_rgb(rgb), tier)
+            };
+            TerrainVertex::packed_uv(
+                [p[0] + origin[0], p[1] + origin[1], p[2] + origin[2]],
+                uv,
+                0,
+                color,
+                pack_coords(lighting::with_min(coords[i], q.light)),
+            )
+        };
        let vertices = |tint: Option<u32>, uv: [[f32; 2]; 4]| {
-            std::array::from_fn::<_, 4, _>(|i| {
-                let g = gray[i] as u32;
-                let rgb = match tint {
-                    Some(t) => [16, 8, 0].map(|shift| g * (t >> shift & 255) / 255),
-                    None => [g; 3],
-                };
-                let p = q.positions[i];
-                let color = if self.separate_ao {
-                    let ao_byte = (ao_factor[i] * 255.0).round().clamp(0.0, 255.0) as u32;
-                    ao_byte << 24 | (pack_rgb(rgb) & 0x00FF_FFFF)
-                } else {
-                    emitting(pack_rgb(rgb), tier)
-                };
-                (
-                    TerrainVertex::new(
-                        [p[0] + origin[0], p[1] + origin[1], p[2] + origin[2]],
-                        uv[i],
-                        0,
-                        color,
-                        pack_coords(lighting::with_min(coords[i], q.light)),
-                    ),
-                    uv[i],
-                )
-            })
+            let fixed = uv.map(|uv| uv.map(|v| round_to_u16(v * UV_STEPS)));
+            std::array::from_fn::<_, 4, _>(|i| (vertex(tint, i, fixed[i]), uv[i]))
        };
        // Vanilla's pane models mirror some faces' textures; OptiFine's don't, so a tile's borders
        // land where the neighbours are: on a pane, tiles take the cube's own UVs.
        let standard = || q.positions.map(|p| standard_uv(q.facing, p));
        let tiled = !matches!(pick, Pick::Keep);
-        let corners = vertices(
-            tint,
-            if state.pane && tiled {
-                standard()
-            } else {
-                q.uv
-            },
-        );
+        let corners = if state.pane && tiled {
+            vertices(tint, standard())
+        } else {
+            // The face's own UVs, already packed: no per-vertex rounding.
+            std::array::from_fn(|i| (vertex(tint, i, face.uv_fixed[i]), q.uv[i]))
+        };
        // Opaque leaves (forceOpaque) and leaves a leaf-culling mode proved internal draw in the
        // solid layer whatever their sprite.
        let solid_leaves = !self.cutout_leaves && state.leaves || interior_leaf;
@@ -19,6 +19,11 @@ use std::{convert::Infallible, sync::OnceLock};
 /// `FluidRenderer.MAX_FLUID_HEIGHT`.
 const MAX_HEIGHT: f32 = 0.888_888_9;
 const EPSILON: f32 = 0.001;
+/// `super::step_index` of the unit steps of the padded index: one block east
+/// (+x), one south (+z), one up (+y).
+const X_STEP: isize = 1;
+const P_STEP: isize = super::P as isize;
+const UP: isize = super::step_index([0, 1, 0]);

 /// For the occlusion face toward `direction`: the height from the bottom over
 /// which its slice flush with the `direction` side covers the whole width
@@ -224,14 +229,14 @@ pub(super) fn tesselate(
        }
    };
    let info = &tables.info;
-    let at = |p: [i32; 3]| &info[pad.blocks[pi(p[0], p[1], p[2])] as usize];
-    let me = at([x, y, z]);
+    // The cell's own padded index: every other cell sampled here is a constant
+    // step from it (`super::step_index`), so no `pi` per sample.
+    let cell = pi(x, y, z) as isize;
+    let at = |step: isize| &info[pad.blocks[(cell + step) as usize] as usize];
+    let me = at(0);
    let kind = me.fluid.kind();
    let same = |s: &Info| s.fluid.kind().same_family(kind);
-    let neighbor = |d: Direction| {
-        let [dx, dy, dz] = super::DIRECTIONS[d as usize].1;
-        at([x + dx, y + dy, z + dz])
-    };
+    let neighbor = |d: Direction| at(super::OFFSETS[d as usize]);
    let (down, up) = (neighbor(Direction::Down), neighbor(Direction::Up));
    let should_render = |d: Direction| !same(neighbor(d)) && !occluded_by_self(me, d);
    let render_up = !same(up);
@@ -265,10 +270,10 @@ pub(super) fn tesselate(
            crate::mesher::emitting(pack_rgb(rgb), emission)
        }
    };
-    let height = |p: [i32; 3]| -> f32 {
-        let s = at(p);
+    let height = |step: isize| -> f32 {
+        let s = at(step);
        if same(s) {
-            if same(at([p[0], p[1] + 1, p[2]])) {
+            if same(at(step + UP)) {
                1.0
            } else {
                s.fluid.own_height()
@@ -279,15 +284,15 @@ pub(super) fn tesselate(
            -1.0
        }
    };
-    let own = height([x, y, z]);
+    let own = height(0);
    let (mut ne, mut nw, mut se, mut sw) = (1.0f32, 1.0f32, 1.0f32, 1.0f32);
    if own < 1.0 {
-        let n = height([x, y, z - 1]);
-        let s = height([x, y, z + 1]);
-        let e = height([x + 1, y, z]);
-        let w = height([x - 1, y, z]);
+        let n = height(-P_STEP);
+        let s = height(P_STEP);
+        let e = height(X_STEP);
+        let w = height(-X_STEP);
        // calculateAverageHeight(self, height2, height1, corner)
-        let average = |h2: f32, h1: f32, corner: [i32; 3]| -> f32 {
+        let average = |h2: f32, h1: f32, corner: isize| -> f32 {
            if h1 >= 1.0 || h2 >= 1.0 {
                return 1.0;
            }
@@ -313,16 +318,17 @@ pub(super) fn tesselate(
            add(h2);
            sum[0] / sum[1]
        };
-        ne = average(n, e, [x + 1, y, z - 1]);
-        nw = average(n, w, [x - 1, y, z - 1]);
-        se = average(s, e, [x + 1, y, z + 1]);
-        sw = average(s, w, [x - 1, y, z + 1]);
+        ne = average(n, e, X_STEP - P_STEP);
+        nw = average(n, w, -X_STEP - P_STEP);
+        se = average(s, e, X_STEP + P_STEP);
+        sw = average(s, w, -X_STEP + P_STEP);
    }
-    let light = |p: [i32; 3]| {
-        let above = [p[0], p[1] + 1, p[2]];
+    let light = |step: isize| {
+        let i = (cell + step) as usize;
+        let above = (cell + step + UP) as usize;
        pack_coords(lighting::max_coords(
-            lighting::coords(pad, at(p), p),
-            lighting::coords(pad, at(above), above),
+            lighting::coords_at(pad, lighting::state_at(pad, info, i), i),
+            lighting::coords_at(pad, lighting::state_at(pad, info, above), above),
        ))
    };
    let (still, flow, overlay) = if water {
@@ -393,7 +399,7 @@ pub(super) fn tesselate(
        // FluidState.shouldRenderBackwardUpFace over the 3x3 cells above.
        let backward = (-1..=1).any(|ox| {
            (-1..=1).any(|oz| {
-                let s = at([x + ox, y + 1, z + oz]);
+                let s = at(UP + ox as isize * X_STEP + oz as isize * P_STEP);
                !same(s) && !s.solid
            })
        });
@@ -412,7 +418,7 @@ pub(super) fn tesselate(
            corners,
            layer,
            color(cardinal(D::Up)),
-            light([x, y, z]),
+            light(0),
            backward,
            Direction::Up as usize,
        );
@@ -428,12 +434,12 @@ pub(super) fn tesselate(
            ],
            still,
            color(cardinal(D::Down)),
-            light([x, y - 1, z]),
+            light(-UP),
            false,
            Direction::Down as usize,
        );
    }
-    let side_light = light([x, y, z]);
+    let side_light = light(0);
    let up_shade = cardinal(D::Up);
    for (i, d) in [
        Direction::North,
@@ -3,6 +3,7 @@
 //! and `ModelBlockRenderer`'s integer colour arithmetic (`ARGB.gray`,
 //! `scaleRGB`, `multiply`).
 use super::{Info, Padded, pi};
+use crate::models::catalog::QuadShape;
 use horizon_assets::model::Direction as D;

 /// `LightCoordsUtil.FULL_BRIGHT`.
@@ -25,28 +26,37 @@ pub(super) fn cardinal(nether: bool, face: D) -> f32 {
 pub(super) fn pack_flat(nether: bool) -> f32 {
    cardinal(nether, D::Up)
 }
+/// The normals of `D`'s variants, in the order [`ADJACENCY`] is indexed by.
+const NORMALS: [[i32; 3]; 6] = [
+    [0, -1, 0],
+    [0, 1, 0],
+    [0, 0, -1],
+    [0, 0, 1],
+    [-1, 0, 0],
+    [1, 0, 0],
+];
 fn normal(face: D) -> [i32; 3] {
-    match face {
-        D::Down => [0, -1, 0],
-        D::Up => [0, 1, 0],
-        D::North => [0, 0, -1],
-        D::South => [0, 0, 1],
-        D::West => [-1, 0, 0],
-        D::East => [1, 0, 0],
-    }
+    NORMALS[face as usize]
 }
 pub(super) fn step(p: [i32; 3], face: D) -> [i32; 3] {
    let n = normal(face);
    [p[0] + n[0], p[1] + n[1], p[2] + n[2]]
 }
-fn state<'a>(pad: &Padded, info: &'a [Info], p: [i32; 3]) -> &'a Info {
-    &info[pad.blocks[pi(p[0], p[1], p[2])] as usize]
+/// The block state of the padded cell at index `i` (see `pi`, `step_index`).
+#[inline]
+pub(super) fn state_at<'a>(pad: &Padded, info: &'a [Info], i: usize) -> &'a Info {
+    &info[pad.blocks[i] as usize]
 }
 /// `LightCoordsUtil.getLightCoords`: light at `p` as seen through `state`
 /// (block level << 4 | sky level << 20).
 pub(super) fn coords(pad: &Padded, state: &Info, p: [i32; 3]) -> u32 {
    packed_coords(state, pad.light[pi(p[0], p[1], p[2])])
 }
+/// `coords` of the cell at index `i`, as seen through `state`.
+#[inline]
+pub(super) fn coords_at(pad: &Padded, state: &Info, i: usize) -> u32 {
+    packed_coords(state, pad.light[i])
+}
 /// `coords` of a stored light byte (sky level << 4 | block level).
 pub(super) fn packed_coords(state: &Info, packed: u8) -> u32 {
    if state.emissive {
@@ -238,64 +248,21 @@ const ADJACENCY: [Adjacency; 6] = [
    adjacency(D::West),
    adjacency(D::East),
 ];
-/// `prepareQuadShape`: the quad's bounds, whether it is partial (smaller than
-/// the block face) and whether it is cubic (flush with the block boundary, or
-/// flat on a full collision shape).
-struct Shape {
-    bounds: [f32; 12],
-    partial: bool,
-    cubic: bool,
-}
-fn shape(positions: &[[f32; 3]; 4], face: D, full: bool) -> Shape {
-    let (mut min, mut max) = ([32f32; 3], [-32f32; 3]);
-    for p in positions {
-        for i in 0..3 {
-            min[i] = min[i].min(p[i]);
-            max[i] = max[i].max(p[i]);
-        }
-    }
-    let mut bounds = [0f32; 12];
-    for (index, value) in [
-        (WEST, min[0]),
-        (EAST, max[0]),
-        (DOWN, min[1]),
-        (UP, max[1]),
-        (NORTH, min[2]),
-        (SOUTH, max[2]),
-    ] {
-        bounds[index as usize] = value;
-        bounds[index as usize + 6] = 1.0 - value;
-    }
-    let (lo, hi) = (1.0e-4f32, 0.9999f32);
-    let partial = |a: usize, b: usize| min[a] >= lo || min[b] >= lo || max[a] <= hi || max[b] <= hi;
-    let (partial, cubic) = match face {
-        D::Down => (partial(0, 2), min[1] == max[1] && (min[1] < lo || full)),
-        D::Up => (partial(0, 2), min[1] == max[1] && (max[1] > hi || full)),
-        D::North => (partial(0, 1), min[2] == max[2] && (min[2] < lo || full)),
-        D::South => (partial(0, 1), min[2] == max[2] && (max[2] > hi || full)),
-        D::West => (partial(1, 2), min[0] == max[0] && (min[0] < lo || full)),
-        D::East => (partial(1, 2), min[0] == max[0] && (max[0] > hi || full)),
-    };
-    Shape {
-        bounds,
-        partial,
-        cubic,
-    }
+fn shape(positions: &[[f32; 3]; 4], face: D, full: bool) -> QuadShape {
+    QuadShape::new(positions, face, full)
 }
 /// `prepareQuadFlat` for a quad without a cull face: light from the
-/// neighbour when the quad is flush with the face, else from the block itself.
-pub(super) fn flat(
+/// neighbour when the quad is flush with the face (cubic), else from the block
+/// itself. `shape` is the quad's baked [`QuadShape`].
+pub(super) fn flat_shaped(
    pad: &Padded,
    own: &Info,
    pos: [i32; 3],
-    positions: &[[f32; 3]; 4],
    face: D,
+    shape: &QuadShape,
 ) -> u32 {
-    coords(
-        pad,
-        own,
-        flat_position(pos, positions, face, None, own.full),
-    )
+    let at = if shape.cubic { step(pos, face) } else { pos };
+    coords(pad, own, at)
 }
 /// Where `tesselateFlat` reads the light of a quad of a block at `pos`: the
 /// neighbour on its cull face, else `prepareQuadFlat`'s choice (the neighbour
@@ -314,6 +281,51 @@ pub(super) fn flat_position(
        None => pos,
    }
 }
+/// A face's AO sample offsets from the sample base, in `pi` index space, so a
+/// sample is `base + offset` rather than a `pi` per coordinate triple.
+struct Samples {
+    /// The four corners (`adjacency`'s).
+    corners: [isize; 4],
+    /// Each corner stepped out of the face (the permeability sample).
+    out: [isize; 4],
+    /// Corner `a` stepped toward corner `b`.
+    diagonal: [[isize; 4]; 4],
+    /// `step(pos, face)` from the block's own cell.
+    step: isize,
+}
+const fn samples(face: D) -> Samples {
+    let mut corners = [0isize; 4];
+    let mut out = [0isize; 4];
+    let mut diagonal = [[0isize; 4]; 4];
+    let step = super::step_index(NORMALS[face as usize]);
+    let mut i = 0;
+    while i < 4 {
+        let c = super::step_index(NORMALS[ADJACENCY[face as usize].corners[i] as usize]);
+        corners[i] = c;
+        out[i] = c + step;
+        let mut j = 0;
+        while j < 4 {
+            diagonal[i][j] =
+                c + super::step_index(NORMALS[ADJACENCY[face as usize].corners[j] as usize]);
+            j += 1;
+        }
+        i += 1;
+    }
+    Samples {
+        corners,
+        out,
+        diagonal,
+        step,
+    }
+}
+const SAMPLES: [Samples; 6] = [
+    samples(D::Down),
+    samples(D::Up),
+    samples(D::North),
+    samples(D::South),
+    samples(D::West),
+    samples(D::East),
+];
 /// `prepareQuadAmbientOcclusion`: per-vertex AO brightness (before `ARGB.gray`)
 /// and smooth light coords, by vertex index.
 pub(super) fn ambient_occlusion(
@@ -321,26 +333,34 @@ pub(super) fn ambient_occlusion(
    info: &[Info],
    own: &Info,
    pos: [i32; 3],
-    positions: &[[f32; 3]; 4],
+    shape: &QuadShape,
    face: D,
 ) -> ([f32; 4], [u32; 4]) {
-    let shape = shape(positions, face, own.full);
-    let base = if shape.cubic { step(pos, face) } else { pos };
+    let samples = &SAMPLES[face as usize];
+    // The block's own cell and the sample base (the neighbour when the quad is
+    // cubic): every corner and diagonal is a constant step from it.
+    let cell = pi(pos[0], pos[1], pos[2]) as isize;
+    let base = if shape.cubic {
+        cell + samples.step
+    } else {
+        cell
+    };
    let adjacency = &ADJACENCY[face as usize];
-    let corner = |i: usize| step(base, adjacency.corners[i]);
-    let sample = |p: [i32; 3]| {
-        let s = state(pad, info, p);
-        (coords(pad, s, p), s.shade)
+    let corner = |i: usize| base + samples.corners[i];
+    let sample = |i: isize| {
+        let i = i as usize;
+        let s = state_at(pad, info, i);
+        (coords_at(pad, s, i), s.shade)
    };
    let (light0, shade0) = sample(corner(0));
    let (light1, shade1) = sample(corner(1));
    let (light2, shade2) = sample(corner(2));
    let (light3, shade3) = sample(corner(3));
-    let permeable = |i: usize| state(pad, info, step(corner(i), face)).permeable;
+    let permeable = |i: usize| state_at(pad, info, (base + samples.out[i]) as usize).permeable;
    let (p0, p1, p2, p3) = (permeable(0), permeable(1), permeable(2), permeable(3));
    let diagonal = |a: usize, b: usize, open: bool| {
        if open {
-            sample(step(corner(a), adjacency.corners[b]))
+            sample(base + samples.diagonal[a][b])
        } else {
            (light0, shade0)
        }
@@ -349,15 +369,15 @@ pub(super) fn ambient_occlusion(
    let (light03, shade03) = diagonal(0, 3, p3 || p0);
    let (light12, shade12) = diagonal(1, 2, p2 || p1);
    let (light13, shade13) = diagonal(1, 3, p3 || p1);
-    let next = step(pos, face);
-    let next_state = state(pad, info, next);
+    let next = (cell + samples.step) as usize;
+    let next_state = state_at(pad, info, next);
    let light_center = if shape.cubic || !next_state.solid {
-        coords(pad, next_state, next)
+        coords_at(pad, next_state, next)
    } else {
-        coords(pad, own, pos)
+        coords_at(pad, own, cell as usize)
    };
    let shade_center = if shape.cubic {
-        state(pad, info, base).shade
+        state_at(pad, info, base as usize).shade
    } else {
        own.shade
    };
@@ -393,6 +413,57 @@ pub(super) fn ambient_occlusion(
 #[cfg(test)]
 mod tests {
    use super::*;
+
+    #[test]
+    fn ao_offsets_match_coordinate_samples_at_section_edges() {
+        // Explicit coordinate directions, without NORMALS, ADJACENCY or step_index.
+        let (down, up, north, south, west, east) = (
+            [0, -1, 0],
+            [0, 1, 0],
+            [0, 0, -1],
+            [0, 0, 1],
+            [-1, 0, 0],
+            [1, 0, 0],
+        );
+        let faces = [
+            (D::Down, down, [west, east, north, south]),
+            (D::Up, up, [east, west, north, south]),
+            (D::North, north, [up, down, east, west]),
+            (D::South, south, [west, east, down, up]),
+            (D::West, west, [up, down, north, south]),
+            (D::East, east, [down, up, north, south]),
+        ];
+        let add = |a: [i32; 3], b: [i32; 3]| std::array::from_fn(|i| a[i] + b[i]);
+        let index = |p: [i32; 3]| pi(p[0], p[1], p[2]);
+        for x in [0, 1, 14, 15] {
+            for y in [0, 1, 14, 15] {
+                for z in [0, 1, 14, 15] {
+                    let pos = [x, y, z];
+                    for (face, normal, corners) in faces {
+                        let samples = &SAMPLES[face as usize];
+                        let cell = index(pos) as isize;
+                        assert_eq!((cell + samples.step) as usize, index(add(pos, normal)));
+                        for cubic in [false, true] {
+                            let base_pos = if cubic { add(pos, normal) } else { pos };
+                            let base = if cubic { cell + samples.step } else { cell };
+                            for (i, corner) in corners.into_iter().enumerate() {
+                                let p = add(base_pos, corner);
+                                assert_eq!((base + samples.corners[i]) as usize, index(p));
+                                assert_eq!((base + samples.out[i]) as usize, index(add(p, normal)));
+                            }
+                            for (a, b) in [(0, 2), (0, 3), (1, 2), (1, 3)] {
+                                assert_eq!(
+                                    (base + samples.diagonal[a][b]) as usize,
+                                    index(add(add(base_pos, corners[a]), corners[b]))
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
    const fn packed(block: u32, sky: u32) -> u32 {
        block << 4 | sky << 20
    }
@@ -1,6 +1,44 @@
 use super::*;
 use crate::chunk::Light;

+#[test]
+fn padded_steps_match_coordinate_lookup_through_the_border() {
+    // Coordinate lookup is the old addressing path, independent of step_index
+    // and the direction table. Include every cell and the full two-cell halo.
+    let neighbors = [
+        (Direction::Down, [0, -1, 0]),
+        (Direction::Up, [0, 1, 0]),
+        (Direction::North, [0, 0, -1]),
+        (Direction::South, [0, 0, 1]),
+        (Direction::West, [-1, 0, 0]),
+        (Direction::East, [1, 0, 0]),
+    ];
+    for y in 0..16 {
+        for z in 0..16 {
+            for x in 0..16 {
+                let cell = (pi(0, y, z) + x as usize) as isize;
+                assert_eq!(cell as usize, pi(x, y, z));
+                for (face, [dx, dy, dz]) in neighbors {
+                    assert_eq!(
+                        (cell + OFFSETS[face as usize]) as usize,
+                        pi(x + dx, y + dy, z + dz)
+                    );
+                }
+                for dy in -2..=2 {
+                    for dz in -2..=2 {
+                        for dx in -2..=2 {
+                            assert_eq!(
+                                (cell + step_index([dx, dy, dz])) as usize,
+                                pi(x + dx, y + dy, z + dz)
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
 #[test]
 fn padded_reuse_resets_missing_neighbors_and_matches_chunk_reads_across_layouts() {
    let mut pad = Padded::default();
@@ -9,6 +9,7 @@ use horizon_assets::{
        bind::{Properties, PropertySchema, PropertyValues, SelectedModels},
        choice::CompiledChoices,
    },
+    model::Direction,
 };
 use horizon_core::{
    position::BlockPos,
@@ -26,6 +27,65 @@ use std::{
    sync::OnceLock,
 };

+/// `prepareQuadShape`: the quad's bounds, whether it is partial (smaller than
+/// the block face) and whether it is cubic (flush with the block boundary, or
+/// flat on a full collision shape). A function of the quad's positions and the
+/// block's `isCollisionShapeFullBlock` only, so it is baked per face, once for
+/// each.
+#[derive(Clone, Copy)]
+pub struct QuadShape {
+    /// The quad's bounds by face index (`mesher::lighting`'s `SizeInfo`
+    /// order: down, up, north, south, west, east), and `1.0 - the bound`.
+    pub bounds: [f32; 12],
+    pub partial: bool,
+    pub cubic: bool,
+}
+impl QuadShape {
+    pub fn new(positions: &[[f32; 3]; 4], face: Direction, full: bool) -> Self {
+        // `SizeInfo` indices into the face shape.
+        const DOWN: usize = 0;
+        const UP: usize = 1;
+        const NORTH: usize = 2;
+        const SOUTH: usize = 3;
+        const WEST: usize = 4;
+        const EAST: usize = 5;
+        let (mut min, mut max) = ([32f32; 3], [-32f32; 3]);
+        for p in positions {
+            for i in 0..3 {
+                min[i] = min[i].min(p[i]);
+                max[i] = max[i].max(p[i]);
+            }
+        }
+        let mut bounds = [0f32; 12];
+        for (index, value) in [
+            (WEST, min[0]),
+            (EAST, max[0]),
+            (DOWN, min[1]),
+            (UP, max[1]),
+            (NORTH, min[2]),
+            (SOUTH, max[2]),
+        ] {
+            bounds[index] = value;
+            bounds[index + 6] = 1.0 - value;
+        }
+        let (lo, hi) = (1.0e-4f32, 0.9999f32);
+        let partial =
+            |a: usize, b: usize| min[a] >= lo || min[b] >= lo || max[a] <= hi || max[b] <= hi;
+        let (partial, cubic) = match face {
+            Direction::Down => (partial(0, 2), min[1] == max[1] && (min[1] < lo || full)),
+            Direction::Up => (partial(0, 2), min[1] == max[1] && (max[1] > hi || full)),
+            Direction::North => (partial(0, 1), min[2] == max[2] && (min[2] < lo || full)),
+            Direction::South => (partial(0, 1), min[2] == max[2] && (max[2] > hi || full)),
+            Direction::West => (partial(1, 2), min[0] == max[0] && (min[0] < lo || full)),
+            Direction::East => (partial(1, 2), min[0] == max[0] && (max[0] > hi || full)),
+        };
+        QuadShape {
+            bounds,
+            partial,
+            cubic,
+        }
+    }
+}
 pub struct BakedFace {
    pub quad: ModelQuad,
    pub layer: u32,
@@ -37,6 +97,33 @@ pub struct BakedFace {
    /// The Fusion connecting texture rule its sprite joins by ([`crate::fusion`]), plus one:
    /// two bytes, within the padding every face already has.
    pub fusion: Option<std::num::NonZeroU16>,
+    /// `prepareQuadShape` of the quad, indexed by the block's `full` flag: the
+    /// mesher would otherwise recompute it for every face of every block.
+    pub shapes: [QuadShape; 2],
+    /// The quad's own UVs in `TerrainVertex` fixed point, which the mesh
+    /// otherwise recomputes for every face of every block.
+    pub uv_fixed: [[u16; 2]; 4],
+}
+impl BakedFace {
+    pub fn new(
+        quad: ModelQuad,
+        layer: u32,
+        opaque: bool,
+        translucent: bool,
+        fusion: Option<std::num::NonZeroU16>,
+    ) -> Self {
+        let shapes = [false, true].map(|full| QuadShape::new(&quad.positions, quad.facing, full));
+        let uv_fixed = crate::mesher::baked_uv(quad.uv);
+        Self {
+            quad,
+            layer,
+            opaque,
+            translucent,
+            fusion,
+            shapes,
+            uv_fixed,
+        }
+    }
 }
 pub struct BakedModel {
    pub ambient_occlusion: bool,
@@ -97,18 +184,12 @@ fn bake_resolved(
                Some(RenderType::Translucent | RenderType::Tripwire) => (true, false),
                Some(RenderType::Solid) => (false, true),
                Some(RenderType::Cutout | RenderType::CutoutMipped) => (false, false),
-                None => (
+                None | Some(RenderType::Unsupported) => (
                    quad.material.force_translucent || sprites.translucent[layer as usize],
                    sprites.region_opaque(layer, &quad.uv),
                ),
            };
-            Ok(BakedFace {
-                translucent,
-                opaque,
-                quad,
-                layer,
-                fusion: None,
-            })
+            Ok(BakedFace::new(quad, layer, opaque, translucent, None))
        })
        .collect::<Result<_>>()?;
    let cube = super::cube::cube_styles(&faces);
@@ -118,13 +118,7 @@ mod tests {
                        )
                        .unwrap()
                        .into_iter()
-                        .map(|quad| BakedFace {
-                            quad,
-                            layer: 7,
-                            opaque: true,
-                            translucent: false,
-                            fusion: None,
-                        })
+                        .map(|quad| BakedFace::new(quad, 7, true, false, None))
                        .collect();
                        let Some(styles) = cube_styles(&faces) else {
                            assert!(lock);
@@ -153,13 +147,7 @@ mod tests {
            bake_model_transformed(&model, BlockModelTransform::new([0; 3], false))
                .unwrap()
                .into_iter()
-                .map(|quad| BakedFace {
-                    quad,
-                    layer: 0,
-                    opaque: true,
-                    translucent: false,
-                    fusion: None,
-                })
+                .map(|quad| BakedFace::new(quad, 0, true, false, None))
                .collect();
        faces[0].opaque = false;
        assert!(cube_styles(&faces).is_none());
@@ -1515,6 +1515,8 @@ pub enum Event {
    PlayMusicTrack(String, String),
    /// Open the recordings folder in the system file browser.
    OpenStudioFolder,
+    /// Start playback from the selected Studio recording.
+    OpenStudioReplay(std::path::PathBuf),
 }
 /// A row of the Music page: the track, and the pool it is played from.
 #[derive(Clone, Debug, Default, PartialEq)]
@@ -3978,6 +3980,9 @@ impl OptionsUi {
            return match self.studio.click((x, y), size) {
                StudioAction::None => Vec::new(),
                StudioAction::Refresh => vec![Event::ButtonClick],
+                StudioAction::OpenReplay(path) => {
+                    vec![Event::ButtonClick, Event::OpenStudioReplay(path)]
+                }
                StudioAction::OpenFolder => vec![Event::ButtonClick, Event::OpenStudioFolder],
                StudioAction::Back => {
                    let mut events = vec![Event::ButtonClick];
@@ -4459,6 +4464,10 @@ impl OptionsUi {
            self.graphics.scroll(s, size, amount);
            return;
        }
+        if self.page() == Page::Studio {
+            self.studio.wheel(amount);
+            return;
+        }
        if Self::controller_page(self.page()).is_some() {
            self.controller.scroll(s, size, amount);
            return;
@@ -338,11 +338,21 @@ impl Settings {
            .map_or(-1, |i| i as i32)
    }
    pub fn load(path: &Path) -> Self {
-        let horizon = path
+        let mut horizon = path
            .parent()
            .map(crate::graphics::Graphics::load)
            .unwrap_or_default();
        crate::mipmap::set_dither_cutouts(horizon.dither_cutout_mips);
+        if let Some(dir) = path.parent() {
+            let (key, _) = crate::shader_pack_list::resolve(
+                &crate::logging::shared_dir(dir).join(crate::shader_pack_list::DIR),
+                &horizon.shader_pack,
+            );
+            if key != horizon.shader_pack {
+                horizon.shader_pack = key;
+                horizon.save(dir);
+            }
+        }
        let controller = path
            .parent()
            .map(crate::gamepad::PadSettings::load)
@@ -18,8 +18,10 @@ pub enum Kind {

 #[derive(Clone, Debug, PartialEq)]
 pub struct Entry {
-    /// The folder's or file's name in `shaderpacks`: what the pick saves.
+    /// The folder or file name in `shaderpacks`.
    pub file: String,
+    /// Native manifest identity (`horizon:<id>`), or a classic filename.
+    pub key: String,
    /// The pack's own name for Horizon's packs, else `file`.
    pub title: String,
    pub kind: Kind,
@@ -33,7 +35,7 @@ pub struct Entry {
 impl Entry {
    /// Saves the player's option values, for the pack in the folder `dir`.
    pub fn save_values(&self, dir: &Path) {
-        let path = dir.join(&self.file);
+        let path = values_pack(&dir.join(&self.file), &self.key);
        if let Err(e) = save_values(&path, &self.options, &self.values) {
            log::warn!("shader pack options of {}: {e}", self.file);
        }
@@ -106,7 +108,22 @@ pub fn scan(dir: &Path) -> Vec<Entry> {
    let Ok(entries) = std::fs::read_dir(dir) else {
        return Vec::new();
    };
-    let mut packs: Vec<Entry> = entries.flatten().filter_map(|e| entry(&e.path())).collect();
+    let mut paths: Vec<_> = entries.flatten().map(|e| e.path()).collect();
+    paths.sort();
+    let mut keys = std::collections::HashSet::new();
+    let mut packs: Vec<Entry> = paths
+        .iter()
+        .filter_map(|p| entry(p))
+        .filter(|e| keys.insert(e.key.clone()))
+        .collect();
+    for pack in &mut packs {
+        if let Some(id) = pack.key.strip_prefix("horizon:") {
+            pack.values = load_values(
+                &native_values_pack(&dir.join(&pack.file), id),
+                &pack.options,
+            );
+        }
+    }
    packs.sort_by(|a, b| {
        (a.kind == Kind::Classic, a.title.to_lowercase())
            .cmp(&(b.kind == Kind::Classic, b.title.to_lowercase()))
@@ -122,26 +139,18 @@ fn entry(path: &Path) -> Option<Entry> {
    if horizon_shader_api::package::is_pack(path) {
        // Its manifest's name; a pack that can't be read is still listed, under its file
        // name: picking it says why in the chat.
-        let manifest = if path.is_dir() {
-            std::fs::read_to_string(path.join(horizon_shader_api::MANIFEST))
-                .ok()
-                .and_then(|t| horizon_shader_api::Manifest::parse(&t).ok())
-        } else {
-            horizon_shader_api::Pack::read(path)
-                .ok()
-                .map(|p| p.manifest)
-        };
-        let (title, options, pages) = manifest.map_or_else(
-            || (file.clone(), Vec::new(), Vec::new()),
-            |m| (m.name, m.options, m.pages),
+        let manifest = horizon_shader_api::Pack::read_manifest(path).ok();
+        let (key, title, options, pages) = manifest.map_or_else(
+            || (file.clone(), file.clone(), Vec::new(), Vec::new()),
+            |m| (format!("horizon:{}", m.id), m.name, m.options, m.pages),
        );
-        let values = load_values(path, &options);
        return Some(Entry {
+            key,
            file,
            title,
            kind: Kind::Horizon,
            options,
-            values,
+            values: Vec::new(),
            pages,
        });
    }
@@ -151,6 +160,7 @@ fn entry(path: &Path) -> Option<Entry> {
            .is_some_and(|e| e.eq_ignore_ascii_case("zip"));
    (zip || path.join("shaders").is_dir()).then(|| Entry {
        title: file.clone(),
+        key: file.clone(),
        file,
        kind: Kind::Classic,
        options: Vec::new(),
@@ -159,6 +169,104 @@ fn entry(path: &Path) -> Option<Entry> {
    })
 }

+/// Resolves a saved identity, migrating a legacy native filename when its manifest or the
+/// launcher's `<id>-<version>.hshader` name identifies it. Duplicate IDs use the first filename
+/// in lexical order, matching `scan`; versions are free-form strings, not ordered versions.
+/// An absent arbitrary old filename cannot be attributed to a manifest safely.
+pub fn resolve(dir: &Path, picked: &str) -> (String, PathBuf) {
+    if picked.is_empty() {
+        return (String::new(), dir.join(picked));
+    }
+    let direct = dir.join(picked);
+    if direct.exists() && !horizon_shader_api::package::is_pack(&direct) {
+        return (picked.to_owned(), direct);
+    }
+    let mut native: Vec<_> = std::fs::read_dir(dir)
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter_map(|e| {
+            let path = e.path();
+            let file = path.file_name()?.to_str()?.to_owned();
+            if file.starts_with('.') || !horizon_shader_api::package::is_pack(&path) {
+                return None;
+            }
+            Some((file, horizon_shader_api::Pack::read_manifest(&path).ok()?))
+        })
+        .collect();
+    native.sort_by(|a, b| a.0.cmp(&b.0));
+    let id = native
+        .iter()
+        .find(|(file, _)| file == picked)
+        .map(|(_, m)| m.id.as_str())
+        .or_else(|| picked.strip_prefix("horizon:"))
+        .or_else(|| {
+            // Never reinterpret an installed classic pack as a native identity.
+            if dir.join(picked).exists() {
+                return None;
+            }
+            let stem = picked.strip_suffix(".hshader")?;
+            native
+                .iter()
+                .find(|(_, m)| {
+                    stem.strip_prefix(&m.id)
+                        .is_some_and(|v| v.starts_with('-') && v.len() > 1)
+                })
+                .map(|(_, m)| m.id.as_str())
+        });
+    if let Some((file, m)) = native.iter().find(|(_, m)| Some(m.id.as_str()) == id) {
+        let key = format!("horizon:{}", m.id);
+        if !picked.starts_with("horizon:") {
+            migrate_values(&dir.join(picked), &key);
+        }
+        migrate_values(&dir.join(file), &key);
+        return (key, dir.join(file));
+    }
+    (picked.to_owned(), dir.join(picked))
+}
+
+fn values_pack(pack: &Path, key: &str) -> PathBuf {
+    key.strip_prefix("horizon:").map_or_else(
+        || pack.to_path_buf(),
+        |id| {
+            pack.parent()
+                .unwrap_or_else(|| Path::new("."))
+                .join(".horizon-options")
+                .join(id)
+        },
+    )
+}
+
+/// The native options path; imports a filename sidecar once, keeping the original intact.
+pub fn native_values_pack(pack: &Path, id: &str) -> PathBuf {
+    let key = format!("horizon:{id}");
+    migrate_values(pack, &key);
+    values_pack(pack, &key)
+}
+
+fn migrate_values(pack: &Path, key: &str) {
+    let target = values_path(&values_pack(pack, key));
+    if target.exists() {
+        return;
+    }
+    if let Ok(text) = std::fs::read(values_path(pack)) {
+        let result = std::fs::create_dir_all(target.parent().unwrap()).and_then(|()| {
+            use std::io::Write;
+            // Another reader may already have imported the values.
+            let mut file = std::fs::OpenOptions::new()
+                .write(true)
+                .create_new(true)
+                .open(&target)?;
+            file.write_all(&text)
+        });
+        if let Err(e) = result
+            && e.kind() != std::io::ErrorKind::AlreadyExists
+        {
+            log::warn!("shader pack options migration: {e}");
+        }
+    }
+}
+
 /// Where the option values of the Horizon pack at `pack` are kept: `<pack>.txt` beside it,
 /// one `id=value` a line.
 pub fn values_path(pack: &Path) -> PathBuf {
@@ -186,8 +294,7 @@ pub fn load_values(pack: &Path, options: &[PackOption]) -> Vec<f64> {
        .collect()
 }

-/// Saves `values` of `options`; values at their defaults are left out, and with none left
-/// the file goes.
+/// Saves non-default values. An empty file records a reset, so old sidecars stay retired.
 fn save_values(pack: &Path, options: &[PackOption], values: &[f64]) -> std::io::Result<()> {
    let text: String = options
        .iter()
@@ -196,14 +303,10 @@ fn save_values(pack: &Path, options: &[PackOption], values: &[f64]) -> std::io::
        .map(|(o, v)| format!("{}={v}\n", o.id))
        .collect();
    let path = values_path(pack);
-    if text.is_empty() {
-        match std::fs::remove_file(&path) {
-            Err(e) if e.kind() != std::io::ErrorKind::NotFound => Err(e),
-            _ => Ok(()),
-        }
-    } else {
-        std::fs::write(path, text)
+    if let Some(dir) = path.parent() {
+        std::fs::create_dir_all(dir)?;
    }
+    std::fs::write(path, text)
 }

 fn clamp(kind: &OptionKind, v: f64) -> f64 {
@@ -315,6 +418,102 @@ pub fn show_value(kind: &OptionKind, v: f64) -> String {
 mod tests {
    use super::*;

+    fn install(dir: &Path, file: &str, version: &str) {
+        let manifest = format!(
+            "schema = 1\nid = \"warm\"\nname = \"Warm\"\nversion = \"{version}\"\napi = \"0.1\"\n\
+            [[post]]\nfile = \"p.wgsl\"\n[[options]]\nid = \"strength\"\nname = \"Strength\"\ntype = \"float\"\ndefault = 1.0\nmin = 0.0\nmax = 2.0\nstep = 0.5\n"
+        );
+        let files = [
+            (horizon_shader_api::MANIFEST.into(), manifest.into_bytes()),
+            ("p.wgsl".into(), b"original test fixture".to_vec()),
+        ]
+        .into();
+        let pack = horizon_shader_api::Pack::from_files(files).unwrap();
+        std::fs::write(dir.join(file), pack.package().unwrap()).unwrap();
+    }
+
+    #[test]
+    fn native_selection_and_values_survive_install_update_rename_and_reset() {
+        let dir =
+            std::env::temp_dir().join(format!("horizon-identity-update-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        install(&dir, "warm-1.hshader", "1");
+        std::fs::write(dir.join("warm-1.hshader.txt"), "strength=1.5\n").unwrap();
+        let options = dir.join("options.txt");
+        std::fs::write(&options, "").unwrap();
+        std::fs::write(
+            dir.join(crate::graphics::FILE),
+            "pickedShaderPack:warm-1.hshader\n",
+        )
+        .unwrap();
+        // Use the real settings loader, including persistence of the migrated selection.
+        // Its shaderpacks folder sits beside options.txt.
+        let packs = dir.join(DIR);
+        std::fs::create_dir_all(&packs).unwrap();
+        std::fs::rename(dir.join("warm-1.hshader"), packs.join("warm-1.hshader")).unwrap();
+        std::fs::rename(
+            dir.join("warm-1.hshader.txt"),
+            packs.join("warm-1.hshader.txt"),
+        )
+        .unwrap();
+        let settings = crate::settings::Settings::load(&options);
+        assert_eq!(settings.horizon.shader_pack, "horizon:warm");
+        assert_eq!(
+            crate::graphics::Graphics::load(&dir).shader_pack,
+            "horizon:warm"
+        );
+        assert_eq!(scan(&packs)[0].values, [1.5]);
+        install(&packs, "warm-2.hshader", "2");
+        std::fs::remove_file(packs.join("warm-1.hshader")).unwrap();
+        let (_, path) = resolve(&packs, &settings.horizon.shader_pack);
+        assert_eq!(path, packs.join("warm-2.hshader"));
+        std::fs::rename(path, packs.join("renamed.hshader")).unwrap();
+        let (_, path) = resolve(&packs, "horizon:warm");
+        assert_eq!(path, packs.join("renamed.hshader"));
+        let manifest = horizon_shader_api::Pack::read_manifest(&path).unwrap();
+        assert_eq!(
+            load_values(&native_values_pack(&path, &manifest.id), &manifest.options),
+            [1.5]
+        );
+        let mut entry = scan(&packs).remove(0);
+        entry.values[0] = 0.5;
+        entry.save_values(&packs);
+        assert_eq!(
+            load_values(&native_values_pack(&path, &manifest.id), &manifest.options),
+            [0.5]
+        );
+        entry.reset_options();
+        entry.save_values(&packs);
+        assert_eq!(scan(&packs)[0].values, [1.0]);
+        assert_eq!(
+            std::fs::read_to_string(packs.join("warm-1.hshader.txt")).unwrap(),
+            "strength=1.5\n"
+        );
+        std::fs::remove_dir_all(dir).unwrap();
+    }
+
+    #[test]
+    fn migrates_a_removed_registry_filename_and_resolves_duplicates_deterministically() {
+        let dir = std::env::temp_dir().join(format!(
+            "horizon-identity-duplicates-{}",
+            std::process::id()
+        ));
+        std::fs::create_dir_all(&dir).unwrap();
+        install(&dir, "z.hshader", "newest");
+        install(&dir, "a.hshader", "oldest");
+        std::fs::write(dir.join("warm-previous.hshader.txt"), "strength=2\n").unwrap();
+        let (key, path) = resolve(&dir, "warm-previous.hshader");
+        assert_eq!(key, "horizon:warm");
+        assert_eq!(path, dir.join("a.hshader"));
+        assert_eq!(resolve(&dir, "z.hshader"), (key.clone(), path));
+        assert_eq!(scan(&dir).len(), 1);
+        assert_eq!(scan(&dir)[0].values, [2.0]);
+        // A classic folder named like a native ID keeps its filename identity.
+        std::fs::create_dir_all(dir.join("warm/shaders")).unwrap();
+        assert_eq!(resolve(&dir, "warm"), ("warm".into(), dir.join("warm")));
+        std::fs::remove_dir_all(dir).unwrap();
+    }
+
    #[test]
    fn lists_both_kinds_horizon_first_and_skips_the_rest() {
        let dir = std::env::temp_dir().join(format!("horizon-shader-list-{}", std::process::id()));
@@ -397,7 +596,7 @@ mod tests {
        std::fs::write(values_path(&pack), "a=9\nb=1\nzzz=4\n").unwrap();
        assert_eq!(load_values(&pack, &options), [2.0, 1.0]);
        save_values(&pack, &options, &[1.0, 0.0]).unwrap();
-        assert!(!values_path(&pack).exists());
+        assert_eq!(std::fs::read_to_string(values_path(&pack)).unwrap(), "");
        assert_eq!(load_values(&pack, &options), [1.0, 0.0]);
        std::fs::remove_dir_all(&dir).unwrap();
    }
@@ -417,6 +616,7 @@ mod tests {
        };
        let mut entry = Entry {
            file: "p".into(),
+            key: "horizon:p".into(),
            title: "P".into(),
            kind: Kind::Horizon,
            options: vec![
@@ -64,7 +64,7 @@ fn picked(s: &Settings) -> Option<(usize, Kind)> {
    let i = s
        .shader_packs
        .iter()
-        .position(|p| !s.horizon.shader_pack.is_empty() && p.file == s.horizon.shader_pack)?;
+        .position(|p| !s.horizon.shader_pack.is_empty() && p.key == s.horizon.shader_pack)?;
    Some((i, s.shader_packs[i].kind))
 }

@@ -360,7 +360,7 @@ impl ShaderUi {
            Item::Pack(i) => Some(
                s.shader_packs
                    .get(usize::from(i))
-                    .is_some_and(|p| p.file == s.horizon.shader_pack),
+                    .is_some_and(|p| p.key == s.horizon.shader_pack),
            ),
            Item::Option(i) => match picked(s)? {
                (p, Kind::Horizon) => {
@@ -406,7 +406,7 @@ impl ShaderUi {
                    Kind::Horizon => "A Horizon shader pack.",
                    Kind::Classic => "An OptiFine or Iris shader pack.",
                });
-                let what = lang::get(if pack.file == s.horizon.shader_pack {
+                let what = lang::get(if pack.key == s.horizon.shader_pack {
                    "In use: press to turn shaders off."
                } else {
                    "Press to use it."
@@ -588,8 +588,14 @@ impl ShaderUi {
        // The picked pack's own screens go under its name, apart from Horizon's pack list.
        if side.len() > 1 {
            let [x, y, w, _] = cols.page(1);
-            let pack = &s.horizon.shader_pack;
-            let pack = pack.strip_suffix(".zip").unwrap_or(pack);
+            let pack = match picked(s) {
+                Some((i, Kind::Horizon)) => s.shader_packs[i].title.as_str(),
+                _ => s
+                    .horizon
+                    .shader_pack
+                    .strip_suffix(".zip")
+                    .unwrap_or(&s.horizon.shader_pack),
+            };
            let caption = lang::tr("%s settings", &[&pack]);
            let rect = [x + 2.0, y + 6.0, w - 4.0, 8.0];
            crate::widgets::record(&caption, rect, false);
@@ -854,10 +860,10 @@ impl ShaderUi {
                let Some(p) = s.shader_packs.get(usize::from(i)) else {
                    return Vec::new();
                };
-                s.horizon.shader_pack = if s.horizon.shader_pack == p.file {
+                s.horizon.shader_pack = if s.horizon.shader_pack == p.key {
                    String::new()
                } else {
-                    p.file.clone()
+                    p.key.clone()
                };
                vec![Action::ButtonClick, Action::Picked]
            }
@@ -1107,6 +1113,7 @@ mod tests {
    fn entry(file: &str, kind: Kind) -> Entry {
        Entry {
            file: file.into(),
+            key: file.into(),
            title: file.into(),
            kind,
            options: Vec::new(),
@@ -1174,14 +1181,20 @@ mod tests {

    #[test]
    fn picking_a_pack_and_picking_it_again_turns_shaders_off() {
-        let mut s = settings();
-        let mut ui = ShaderUi::default();
-        let actions = ui.activate(&mut s, Item::Pack(1), false, None);
-        assert_eq!(actions, [Action::ButtonClick, Action::Picked]);
-        assert_eq!(s.horizon.shader_pack, "B.zip");
-        ui.activate(&mut s, Item::Pack(1), false, None);
-        assert_eq!(s.horizon.shader_pack, "");
-        assert_eq!(ShaderUi::switch(Item::Pack(0), &s), Some(false));
+        for (kind, key) in [(Kind::Classic, "B.zip"), (Kind::Horizon, "horizon:warm")] {
+            let mut s = settings();
+            s.shader_packs[1].kind = kind;
+            s.shader_packs[1].key = key.into();
+            let mut ui = ShaderUi::default();
+            let actions = ui.activate(&mut s, Item::Pack(1), false, None);
+            assert_eq!(actions, [Action::ButtonClick, Action::Picked]);
+            assert_eq!(s.horizon.shader_pack, key);
+            assert_eq!(picked(&s), Some((1, kind)));
+            assert_eq!(ShaderUi::switch(Item::Pack(1), &s), Some(true));
+            ui.activate(&mut s, Item::Pack(1), false, None);
+            assert_eq!(s.horizon.shader_pack, "");
+            assert_eq!(ShaderUi::switch(Item::Pack(0), &s), Some(false));
+        }
    }

    #[test]
@@ -1251,6 +1264,7 @@ mod tests {
    #[test]
    fn a_horizon_packs_slider_drag_is_saved_once_when_let_go() {
        let mut pack = entry("H", Kind::Horizon);
+        pack.key = "horizon:slider_test".into();
        pack.options = vec![horizon_shader_api::PackOption {
            id: "strength".into(),
            name: "Strength".into(),
@@ -1267,7 +1281,7 @@ mod tests {
            shader_packs: vec![pack],
            ..Settings::default()
        };
-        s.horizon.shader_pack = "H".into();
+        s.horizon.shader_pack = "horizon:slider_test".into();
        let mut ui = ShaderUi::default();
        ui.open(Tab::Screen(0));
        let cols = Columns::of(SIZE.0, SIZE.1);
@@ -88,6 +88,7 @@ impl SavedRecordingItem {
 #[derive(Clone, Debug, PartialEq)]
 pub enum StudioAction {
    None,
+    OpenReplay(PathBuf),
    OpenFolder,
    Refresh,
    Back,
@@ -103,6 +104,12 @@ pub struct StudioUi {
    pub record_dir: PathBuf,
 }

+/// A recording's row and the gap under it, in GUI pixels.
+const ROW_STEP: f32 = 40.0;
+const ROW_GAP: f32 = 4.0;
+/// The panel's margins above and below its rows.
+const LIST_MARGINS: f32 = 10.0;
+
 impl Default for StudioUi {
    fn default() -> Self {
        let dir = PathBuf::from("recordings");
@@ -270,18 +277,19 @@ impl StudioUi {
            );
        } else {
            // Render scrollable cards
-            let card_h = 36.0;
-            let card_gap = 4.0;
-            let row_step = card_h + card_gap;
-            let visible_cards = (panel_h / row_step).floor() as usize;
+            let card_h = ROW_STEP - ROW_GAP;
+            let row_step = ROW_STEP;
+            // Rows that fit whole between the panel's margins, as the loop below draws them.
+            let visible_cards = ((panel_h - LIST_MARGINS + ROW_GAP) / row_step).floor() as usize;
            let max_scroll =
                (self.recordings.len().saturating_sub(visible_cards) as f32 * row_step).max(0.0);
            self.scroll = self.scroll.clamp(0.0, max_scroll);

            let card_w = panel_w - 12.0;
            let card_x = panel_x + 6.0;
-            let mut y = panel_y + 6.0 - (self.scroll % row_step);
-            let start_idx = (self.scroll / row_step) as usize;
+            // Whole rows: nothing here clips one that's partly scrolled off.
+            let mut y = panel_y + 6.0;
+            let start_idx = (self.scroll / row_step).round() as usize;

            for (idx, item) in self.recordings.iter().enumerate().skip(start_idx) {
                if y + card_h > panel_y + panel_h - 4.0 {
@@ -289,6 +297,8 @@ impl StudioUi {
                }

                let rect = [card_x, y, card_w, card_h];
+                crate::widgets::record_as(&item.title, rect, true, crate::widgets::Kind::Row);
+                crate::widgets::target_as(rect, crate::widgets::Kind::Row);
                let is_hovered = ui::hovered(cursor, card_x, y, card_w, card_h);
                let is_selected = self.selected == Some(idx);

@@ -334,6 +344,12 @@ impl StudioUi {
                y += row_step;
            }

+            crate::widgets::scroll_area(
+                [panel_x, panel_y, panel_w, panel_h],
+                self.scroll,
+                max_scroll,
+            );
+
            // Scrollbar track & thumb if scrollable
            if max_scroll > 0.0 {
                let track_x = panel_x + panel_w - 4.0;
@@ -357,35 +373,35 @@ impl StudioUi {
        // Button 1: Open Folder (Left)
        let f_btn = [panel_x, btn_y, 130.0, btn_h];
        let f_hover = ui::hovered(cursor, f_btn[0], f_btn[1], f_btn[2], f_btn[3]);
-        style::button(
-            batch,
-            atlas,
-            f_btn,
-            &Text::tr("horizon.studio.open_folder", &[]),
-            (f_hover, true, false),
-        );
+        let label = Text::tr("horizon.studio.open_folder", &[]);
+        crate::widgets::record(&label.plain(), f_btn, true);
+        style::button(batch, atlas, f_btn, &label, (f_hover, true, false));

        // Button 2: Refresh (Center-Left)
        let r_btn = [panel_x + 136.0, btn_y, 65.0, btn_h];
        let r_hover = ui::hovered(cursor, r_btn[0], r_btn[1], r_btn[2], r_btn[3]);
+        let label = Text::tr("horizon.studio.refresh", &[]);
+        crate::widgets::record(&label.plain(), r_btn, true);
+        style::button(batch, atlas, r_btn, &label, (r_hover, true, false));
+
+        // Button 3: Open the selected recording for playback.
+        let e_btn = [panel_x + panel_w - 180.0, btn_y, 110.0, btn_h];
+        let e_hover = ui::hovered(cursor, e_btn[0], e_btn[1], e_btn[2], e_btn[3]);
        style::button(
            batch,
            atlas,
-            r_btn,
-            &Text::tr("horizon.studio.refresh", &[]),
-            (r_hover, true, false),
+            e_btn,
+            &Text::tr("horizon.studio.open_replay", &[]),
+            (e_hover, true, false),
        );

        // Button 3: Done / Back (Right)
        let d_btn = [panel_x + panel_w - 64.0, btn_y, 64.0, btn_h];
        let d_hover = ui::hovered(cursor, d_btn[0], d_btn[1], d_btn[2], d_btn[3]);
-        style::button(
-            batch,
-            atlas,
-            d_btn,
-            &Text::tr("gui.done", &[]),
-            (d_hover, true, false),
-        );
+        let label = Text::tr("gui.done", &[]);
+        crate::widgets::record(&label.plain(), d_btn, true);
+        style::button(batch, atlas, d_btn, &label, (d_hover, true, false));
+        crate::widgets::declare_action(crate::widgets::Action::Done, d_btn, true);
    }

    /// Process mouse click on the Studio Browser screen.
@@ -411,20 +427,32 @@ impl StudioUi {
            return StudioAction::Refresh;
        }

-        // Button 3: Done
+        // Button 3: Open Replay
+        let e_btn = [panel_x + panel_w - 180.0, btn_y, 110.0, btn_h];
+        if ui::hovered(cursor, e_btn[0], e_btn[1], e_btn[2], e_btn[3]) {
+            if let Some(idx) = self.selected
+                && let Some(item) = self.recordings.get(idx)
+            {
+                return StudioAction::OpenReplay(item.path.clone());
+            } else if let Some(item) = self.recordings.first() {
+                self.selected = Some(0);
+                return StudioAction::OpenReplay(item.path.clone());
+            }
+        }
+
+        // Button 4: Done
        let d_btn = [panel_x + panel_w - 64.0, btn_y, 64.0, btn_h];
        if ui::hovered(cursor, d_btn[0], d_btn[1], d_btn[2], d_btn[3]) {
            return StudioAction::Back;
        }

        // Card clicks
-        let card_h = 36.0;
-        let card_gap = 4.0;
-        let row_step = card_h + card_gap;
+        let card_h = ROW_STEP - ROW_GAP;
+        let row_step = ROW_STEP;
        let card_w = panel_w - 12.0;
        let card_x = panel_x + 6.0;
-        let start_idx = (self.scroll / row_step) as usize;
-        let mut y = panel_y + 6.0 - (self.scroll % row_step);
+        let start_idx = (self.scroll / row_step).round() as usize;
+        let mut y = panel_y + 6.0;

        for (idx, _) in self.recordings.iter().enumerate().skip(start_idx) {
            if y + card_h > panel_y + panel_h - 4.0 {
@@ -444,7 +472,8 @@ impl StudioUi {

    /// Scroll list by mouse wheel delta.
    pub fn wheel(&mut self, amount: f32) {
-        self.scroll = (self.scroll - amount * 24.0).max(0.0);
+        // A notch is a row, as a focus step needs (`gamepad::list_step`).
+        self.scroll = (self.scroll - amount * ROW_STEP).max(0.0);
    }
 }

@@ -516,6 +545,11 @@ mod tests {
        assert_eq!(action, StudioAction::None);
        assert_eq!(ui.selected, Some(0));

+        // Click the bottom-bar Open Replay button.
+        // Panel width = 387, panel_x = 20, button x = 227..337, y = 692..712.
+        let open_replay_action = ui.click((280.0, 700.0), (427.0, 720.0));
+        assert!(matches!(open_replay_action, StudioAction::OpenReplay(_)));
+
        // Clean up
        let _ = fs::remove_dir_all(&temp_dir);
    }
@@ -527,6 +561,6 @@ mod tests {
        assert_eq!(ui.scroll, 0.0); // clamped at 0
        ui.scroll = 100.0;
        ui.wheel(1.0);
-        assert_eq!(ui.scroll, 76.0);
+        assert_eq!(ui.scroll, 100.0 - ROW_STEP);
    }
 }
@@ -63,6 +63,11 @@ struct Globals {
 // which then samples exactly as before.
 override SPRITE_ARRAYS: u32 = 1u;
 override SPRITE_SPLIT: u32 = 2048u;
+// Whether the solid shaders carry HDR output's lighting (a pipeline constant): the
+// renderer builds its solid terrain without it for the frames HDR is off, where
+// `hdr_light.z` is 0, since even a branch never taken costs Apple GPUs ~15% of a
+// solid pixel's time (gfx.rs's `SolidPipeline`).
+override HDR_LIGHTING: bool = true;
 // A sprite sampled with the given gradients, from whichever array holds its layer.
 fn sprite_grad(uv: vec2<f32>, layer: u32, dx: vec2<f32>, dy: vec2<f32>) -> vec4<f32> {
    let l = i32(layer % SPRITE_SPLIT);
@@ -620,7 +625,7 @@ fn hdr_mark(tier: u32, y: f32) -> f32 {
 }
 // `fs_solid` for the opaque pass (`opaque_quad`): no fade, no cutout, no discard.
@fragment fn fs_opaque(in: TerrainOut) -> @location(0) vec4<f32> {
-    if globals.hdr_light.z != 0.0 {
+    if HDR_LIGHTING && globals.hdr_light.z != 0.0 {
        hdr_normal = normalize(cross(dpdy(in.local), dpdx(in.local)));
    }
    let texel = sprite(in.uv, in.layer & 0x7fffu);
@@ -637,7 +642,7 @@ fn hdr_mark(tier: u32, y: f32) -> f32 {
 fn solid_color(in: TerrainOut) -> vec4<f32> {
    let dx = dpdx(in.local);
    let dy = dpdy(in.local);
-    if globals.hdr_light.z != 0.0 {
+    if HDR_LIGHTING && globals.hdr_light.z != 0.0 {
        hdr_normal = normalize(cross(dy, dx));
    }
    if faded(in.fade, in.local, dx, dy) { discard; }
@@ -665,7 +670,7 @@ fn solid_finish_at(in: TerrainOut, texel: vec4<f32>, color: vec4<f32>, du: vec2<
    // fully fogged mountain would stand out from the fog behind it.
    // Without HDR output nothing reads the alpha, so its lighting is not worked out.
    var emissive = 1.0;
-    if globals.hdr_light.z != 0.0 {
+    if HDR_LIGHTING && globals.hdr_light.z != 0.0 {
        let fogged = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
            linear_fog(in.cylindrical, globals.fog.z, globals.fog.w)) * globals.fog_color.a;
        emissive = hdr_scene_alpha(mix(hdr_scene(in.scene.x, in.scene.y, hdr_facing()),
@@ -718,6 +723,72 @@ fn solid_finish_at(in: TerrainOut, texel: vec4<f32>, color: vec4<f32>, du: vec2<
    return apply_fog(color, in.spherical, in.cylindrical);
 }

+// Native still-fluid boxes use block sprites and lightmap without terrain AO/emission
+// packing or entity-model diffuse shading. The absolute sprite layer occupies glint UV x.
+struct NativeFluidOut {
+    @builtin(position) clip: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+    @location(1) color: vec4<f32>,
+    @location(2) @interpolate(flat) sprite: u32,
+    @location(3) spherical: f32,
+    @location(4) cylindrical: f32,
+}
+@vertex fn vs_native_fluid(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
+    @location(3) color: vec4<f32>, @location(4) light: vec4<u32>,
+    @location(6) sprite: vec2<f32>) -> NativeFluidOut {
+    let block = max(f32(light.y), dynamic_block_light(position));
+    var lit = color * sample_lightmap(f32(light.x) / 16.0, block / 16.0);
+    if globals.colored_count.x > 0u {
+        lit = vec4(min(lit.rgb + color.rgb * native_colored_light(position), vec3(1.0)), lit.a);
+    }
+    return NativeFluidOut(globals.view_proj * vec4(position, 1.0), uv, lit, u32(sprite.x),
+        length(position), max(length(position.xz), abs(position.y)));
+}
+@fragment fn fs_native_fluid(in: NativeFluidOut) -> @location(0) vec4<f32> {
+    // The source translucent shader has no alpha discard; transparent texels write depth too.
+    let color = sprite_grad(in.uv, in.sprite, dpdx(in.uv), dpdy(in.uv)) * in.color;
+    return apply_fog(color, in.spherical, in.cylindrical);
+}
+
+// Native terrain models retain floating-point transformed normals. Fullbright still receives
+// entity directional shading; the material's alpha test and mip policy are independent.
+// Diffuse/normal policy: Flywheel 1.0.6, copyright2021-2024 Jozufozu (MIT);
+// full permission/warranty notice in THIRD_PARTY_NOTICES.md.
+override NATIVE_MODEL_ALPHA_CUTOFF: f32 = 0.0;
+struct NativeModelOut {
+    @builtin(position) clip: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+    @location(1) color: vec4<f32>,
+    @location(2) @interpolate(flat) sprite: u32,
+    @location(3) spherical: f32,
+    @location(4) cylindrical: f32,
+    @location(5) normal: vec3<f32>,
+}
+@vertex fn vs_native_model(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
+    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>,
+    @location(5) normal_z: u32, @location(6) normal_xy: vec2<f32>) -> NativeModelOut {
+    let block = max(f32(light.y), dynamic_block_light(position));
+    var lit = color * sample_lightmap(f32(light.x) / 16.0, block / 16.0);
+    if globals.colored_count.x > 0u {
+        lit = vec4(min(lit.rgb + color.rgb * native_colored_light(position), vec3(1.0)), lit.a);
+    }
+    return NativeModelOut(globals.view_proj * vec4(position, 1.0), uv, lit, layer >> 16u,
+        length(position), max(length(position.xz), abs(position.y)),
+        vec3(normal_xy, bitcast<f32>(normal_z)));
+}
+@fragment fn fs_native_model(in: NativeModelOut) -> @location(0) vec4<f32> {
+    var color = sprite_grad(in.uv, in.sprite, dpdx(in.uv), dpdy(in.uv)) * in.color;
+    if NATIVE_MODEL_ALPHA_CUTOFF > 0.0 && color.a < NATIVE_MODEL_ALPHA_CUTOFF { discard; }
+    if any(in.normal != vec3(0.0)) {
+        let light0 = normalize(vec3(0.2, 1.0, -0.7));
+        let light1 = normalize(vec3(-0.2, select(1.0, -1.0, globals.time.y > 0.5), 0.7));
+        let shade = min(1.0, (max(0.0, dot(light0, in.normal))
+            + max(0.0, dot(light1, in.normal))) * 0.6 + 0.4);
+        color = vec4(color.rgb * shade, color.a);
+    }
+    return apply_fog(color, in.spherical, in.cylindrical);
+}
+
 // Sky (SkyRenderer): the 10-vertex sky disc fan at y = 16 (radius 512) in
 // the sky colour with sky fog (sky.fsh: fog 0..FogSkyEnd on the spherical
 // distance, a step at FogSkyEnd on the cylindrical one), evaluated per pixel
@@ -0,0 +1,215 @@
+//! Native terrain-sheet models with explicit material and UV policy.
+use crate::{gfx, mesher::Vertex, models::catalog::BakedFace};
+use glam::{Mat3, Mat4, Vec3};
+use horizon_assets::bake::RenderType;
+fn same_sprite(left: &str, right: &str) -> bool {
+    left.strip_prefix("minecraft:").unwrap_or(left)
+        == right.strip_prefix("minecraft:").unwrap_or(right)
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum NativeModelMaterial {
+    /// Use each baked quad's material; unsupported translucent/tripwire quads fail the whole call.
+    #[default]
+    Model,
+    Solid,
+    Cutout,
+    CutoutMipped,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum NativeModelShade {
+    /// Respect the baked quad's directional-shading flag.
+    #[default]
+    Model,
+    Off,
+    /// The level's two entity light directions, even at full block/sky light.
+    Entity,
+}
+
+/// Transform UVs only on the explicitly named original sprite, in unit-sprite coordinates.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct NativeModelUvShift<'a> {
+    pub source_sprite: &'a str,
+    pub target_sprite: &'a str,
+    pub scale: [f32; 2],
+    pub offset: [f32; 2],
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct NativeModelRenderOptions<'a> {
+    pub material: NativeModelMaterial,
+    pub shade: NativeModelShade,
+    pub uv_shift: Option<NativeModelUvShift<'a>>,
+    /// Optional compatibility policy applied toward each face's UV bounds center before shifting.
+    /// Zero retains the baked UVs. For an older JSON FaceBakery use its actual atlas shrink ratio;
+    /// OBJ loaders that do not shrink UVs must keep zero.
+    pub uv_shrink_ratio: f32,
+    /// RGB multiplier on quads with a tint index; other quads keep their baked color.
+    pub tint: u32,
+}
+impl Default for NativeModelRenderOptions<'_> {
+    fn default() -> Self {
+        Self {
+            material: NativeModelMaterial::Model,
+            shade: NativeModelShade::Model,
+            uv_shift: None,
+            uv_shrink_ratio: 0.0,
+            tint: 0xff_ffff,
+        }
+    }
+}
+
+fn overlay(face: &BakedFace, policy: NativeModelMaterial) -> Option<u32> {
+    use NativeModelMaterial as M;
+    Some(match policy {
+        M::Solid => gfx::TERRAIN_MODEL_SOLID_OVERLAY,
+        M::Cutout => gfx::TERRAIN_MODEL_CUTOUT_OVERLAY,
+        M::CutoutMipped => gfx::TERRAIN_MODEL_CUTOUT_MIPPED_OVERLAY,
+        M::Model => match face.quad.render_type.unwrap_or(RenderType::Solid) {
+            RenderType::Solid if !face.quad.material.force_translucent => {
+                gfx::TERRAIN_MODEL_SOLID_OVERLAY
+            }
+            RenderType::Cutout => gfx::TERRAIN_MODEL_CUTOUT_OVERLAY,
+            RenderType::CutoutMipped => gfx::TERRAIN_MODEL_CUTOUT_MIPPED_OVERLAY,
+            _ => return None,
+        },
+    })
+}
+
+/// A whole draw validates before its first vertex. No temporary geometry allocation, resource
+/// scans, partial fallback or change to the ordinary native model helper.
+pub fn draw_model(
+    faces: &[BakedFace],
+    pose: Mat4,
+    light: u32,
+    options: NativeModelRenderOptions<'_>,
+    sprite: impl Fn(&str) -> Option<u32>,
+    mut emit: impl FnMut(Vertex),
+) -> bool {
+    if !pose.is_finite()
+        || !options.uv_shrink_ratio.is_finite()
+        || !(0.0..=1.0).contains(&options.uv_shrink_ratio)
+    {
+        return false;
+    }
+    let normal_pose = Mat3::from_mat4(pose).inverse().transpose();
+    if !normal_pose.is_finite() {
+        return false;
+    }
+    let shift = match options.uv_shift {
+        Some(shift) => {
+            if shift
+                .scale
+                .iter()
+                .chain(&shift.offset)
+                .any(|v| !v.is_finite())
+            {
+                return false;
+            }
+            let (Some(source), Some(target)) =
+                (sprite(shift.source_sprite), sprite(shift.target_sprite))
+            else {
+                return false;
+            };
+            if source > u16::MAX.into() || target > u16::MAX.into() {
+                return false;
+            }
+            if !faces
+                .iter()
+                .any(|face| same_sprite(&face.quad.material.sprite, shift.source_sprite))
+            {
+                return false;
+            }
+            Some((source, target, shift))
+        }
+        None => None,
+    };
+    let vertices = |face: &BakedFace| -> Option<[Vertex; 4]> {
+        let quad = &face.quad;
+        let overlay = overlay(face, options.material)?;
+        let mut layer = sprite(&quad.material.sprite)?;
+        if layer > u16::MAX.into() || layer != face.layer {
+            return None;
+        }
+        let mut uv = quad.uv;
+        if uv.iter().flatten().any(|v| !v.is_finite()) {
+            return None;
+        }
+        if options.uv_shrink_ratio != 0.0 {
+            let center = std::array::from_fn::<_, 2, _>(|i| {
+                let min = uv.iter().map(|p| p[i]).fold(f32::INFINITY, f32::min);
+                let max = uv.iter().map(|p| p[i]).fold(f32::NEG_INFINITY, f32::max);
+                (min + min + max + max) / 4.0
+            });
+            for p in &mut uv {
+                *p = std::array::from_fn(|i| p[i] + options.uv_shrink_ratio * (center[i] - p[i]));
+            }
+        }
+        if let Some((_, target, shift)) = shift
+            && same_sprite(&quad.material.sprite, shift.source_sprite)
+        {
+            layer = target;
+            for p in &mut uv {
+                *p = std::array::from_fn(|i| p[i] * shift.scale[i] + shift.offset[i]);
+            }
+        }
+        let shaded = match options.shade {
+            NativeModelShade::Model => quad.shade,
+            NativeModelShade::Off => false,
+            NativeModelShade::Entity => true,
+        };
+        let normal = if shaded {
+            let p = quad.positions.map(Vec3::from_array);
+            let n = (p[1] - p[0]).cross(p[2] - p[0]).normalize_or_zero();
+            // Baked model normals are signed bytes before the instance's normal matrix.
+            // Keep the transformed normal as floats; quantizing it again changes rotated faces.
+            let n = n.map(|v| ((v * 127.0) as i8) as f32 / 127.0);
+            (normal_pose * n).normalize_or_zero()
+        } else {
+            Vec3::ZERO
+        };
+        let normal_bits = normal.z.to_ne_bytes().map(|b| b as i8);
+        let argb = quad.color.map_or(u32::MAX, |v| v as u32);
+        let mut color = (argb & 0xff00_ff00) | (argb >> 16 & 0xff) | (argb & 0xff) << 16;
+        if quad.tint_index >= 0 {
+            let tint = options.tint;
+            let rgb = (tint >> 16 & 0xff) | (tint & 0xff00) | (tint & 0xff) << 16;
+            color = (color & 0xff00_0000)
+                | ((color & 0xff) * (rgb & 0xff) / 255)
+                | (((color >> 8 & 0xff) * (rgb >> 8 & 0xff) / 255) << 8)
+                | (((color >> 16 & 0xff) * (rgb >> 16 & 0xff) / 255) << 16);
+        }
+        let light = (light & 0xff).max(u32::from(quad.light[1]) * 16)
+            | ((light >> 8 & 0xff).max(u32::from(quad.light[0].max(quad.light_emission)) * 16)
+                << 8);
+        let positions = quad
+            .positions
+            .map(|p| pose.transform_point3(Vec3::from_array(p)));
+        if positions.iter().any(|p| !p.is_finite()) || uv.iter().flatten().any(|v| !v.is_finite()) {
+            return None;
+        }
+        Some(std::array::from_fn(|i| Vertex {
+            pos: positions[i].to_array(),
+            uv: uv[i],
+            layer: overlay | layer << 16,
+            color,
+            light,
+            normal: normal_bits,
+            glint_uv: [normal.x, normal.y],
+        }))
+    };
+    if faces.iter().any(|face| vertices(face).is_none()) {
+        return false;
+    }
+    for face in faces {
+        for vertex in vertices(face).expect("validated immutable model") {
+            emit(vertex);
+        }
+    }
+    true
+}
+
+#[cfg(test)]
+#[path = "terrain_model_tests.rs"]
+mod tests;
@@ -0,0 +1,171 @@
+use super::*;
+use horizon_assets::{
+    bake::bake_flat_face,
+    model::{Direction, Material},
+};
+
+fn face() -> BakedFace {
+    BakedFace::new(
+        bake_flat_face(
+            [0.0; 3],
+            [16.0; 3],
+            [0.0, 0.0, 16.0, 16.0],
+            Direction::South,
+            Material {
+                sprite: "test:source".into(),
+                force_translucent: false,
+            },
+            -1,
+        )
+        .unwrap(),
+        7,
+        true,
+        false,
+        None,
+    )
+}
+fn sprite(name: &str) -> Option<u32> {
+    match name {
+        "test:source" => Some(7),
+        "test:target" => Some(11),
+        _ => None,
+    }
+}
+fn draw(
+    faces: &[BakedFace],
+    pose: Mat4,
+    options: NativeModelRenderOptions<'_>,
+) -> (bool, Vec<Vertex>) {
+    let mut output = Vec::new();
+    let accepted = draw_model(faces, pose, 0xf0f0, options, sprite, |v| output.push(v));
+    (accepted, output)
+}
+#[test]
+fn late_unknown_material_or_sprite_rejects_the_whole_model() {
+    let first = face();
+    let mut second = face();
+    second.quad.render_type = Some(RenderType::Unsupported);
+    let mut faces = [first, second];
+    let (accepted, output) = draw(&faces, Mat4::IDENTITY, Default::default());
+    assert!(!accepted);
+    assert!(output.is_empty());
+    let (accepted, output) = draw(
+        &faces,
+        Mat4::IDENTITY,
+        NativeModelRenderOptions {
+            material: NativeModelMaterial::Cutout,
+            ..Default::default()
+        },
+    );
+    assert!(accepted);
+    assert_eq!(output.len(), 8);
+    faces[1].quad.material.sprite = "test:missing".into();
+    let (accepted, output) = draw(&faces, Mat4::IDENTITY, Default::default());
+    assert!(!accepted);
+    assert!(output.is_empty());
+}
+#[test]
+fn exact_sprite_shift_and_explicit_json_shrink_precede_array_mapping() {
+    let options = NativeModelRenderOptions {
+        uv_shrink_ratio: 4.0 / 2048.0,
+        uv_shift: Some(NativeModelUvShift {
+            source_sprite: "test:source",
+            target_sprite: "test:target",
+            scale: [0.5; 2],
+            offset: [0.25, 0.125],
+        }),
+        ..Default::default()
+    };
+    let (accepted, output) = draw(&[face()], Mat4::IDENTITY, options);
+    assert!(accepted);
+    assert_eq!(output[0].uv, [0.25048828, 0.12548828]);
+    assert_eq!(output[2].uv, [0.7495117, 0.6245117]);
+    assert!(output.iter().all(|v| v.layer >> 16 == 11));
+    let (accepted, output) = draw(
+        &[face()],
+        Mat4::IDENTITY,
+        NativeModelRenderOptions {
+            uv_shift: Some(NativeModelUvShift {
+                source_sprite: "test:target",
+                target_sprite: "test:source",
+                ..options.uv_shift.unwrap()
+            }),
+            ..options
+        },
+    );
+    assert!(!accepted);
+    assert!(output.is_empty());
+}
+#[test]
+fn transformed_slope_normal_stays_float_and_fullbright_keeps_shading() {
+    let mut face = face();
+    face.quad.positions = [
+        [0.0, 0.0, 0.0],
+        [0.0, 1.0, 1.0],
+        [1.0, 1.0, 1.0],
+        [1.0, 0.0, 0.0],
+    ];
+    let pose = Mat4::from_rotation_y(0.372) * Mat4::from_scale(Vec3::new(-2.0, 3.0, 1.0));
+    let (accepted, output) = draw(&[face], pose, Default::default());
+    assert!(accepted);
+    let normal = Vec3::new(
+        output[0].glint_uv[0],
+        output[0].glint_uv[1],
+        f32::from_ne_bytes(output[0].normal.map(|v| v as u8)),
+    );
+    assert!((normal.length() - 1.0).abs() < 1e-6);
+    assert!((normal.y - 0.31622776).abs() < 1e-6);
+    assert!((normal.x + 0.3448316).abs() < 1e-5, "{normal:?}");
+    assert_eq!(output[0].light, 0xf0f0);
+    assert_eq!(output[0].color, u32::MAX);
+    // Float payload, not a second signed-byte normal quantization.
+    assert_ne!(normal.y, (normal.y * 127.0) as i8 as f32 / 127.0);
+}
+#[test]
+fn invalid_shift_and_singular_pose_emit_nothing() {
+    let options = NativeModelRenderOptions {
+        uv_shrink_ratio: f32::NAN,
+        ..Default::default()
+    };
+    let (ok, output) = draw(&[face()], Mat4::IDENTITY, options);
+    assert!(!ok);
+    assert!(output.is_empty());
+    let (ok, output) = draw(
+        &[face()],
+        Mat4::from_scale(Vec3::new(1.0, 0.0, 1.0)),
+        Default::default(),
+    );
+    assert!(!ok);
+    assert!(output.is_empty());
+}
+
+#[test]
+fn a_deduplicated_array_layer_is_not_the_same_named_source_sprite() {
+    let mut alias = face();
+    alias.quad.material.sprite = "test:alias".into();
+    let mut output = Vec::new();
+    assert!(draw_model(
+        &[face(), alias],
+        Mat4::IDENTITY,
+        0xf0f0,
+        NativeModelRenderOptions {
+            uv_shift: Some(NativeModelUvShift {
+                source_sprite: "test:source",
+                target_sprite: "test:target",
+                scale: [0.5; 2],
+                offset: [0.25; 2]
+            }),
+            ..Default::default()
+        },
+        |name| if name == "test:alias" {
+            Some(7)
+        } else {
+            sprite(name)
+        },
+        |v| output.push(v)
+    ));
+    assert_eq!(output[0].layer >> 16, 11);
+    assert_eq!(output[4].layer >> 16, 7);
+    assert_eq!(output[4].uv, [0.0, 0.0]);
+    assert_eq!(output[6].uv, [1.0, 1.0]);
+}
@@ -184,6 +184,14 @@ impl Weather {
        self.rain_level.1 =
            (self.rain_level.1 + if self.raining { 0.01 } else { -0.01 }).clamp(0.0, 1.0);
    }
+    /// The levels at their targets at once (rain 1 while it rains, else 0, and thunder the
+    /// same), both halves, so the frame shows them at any partial tick: a frozen world under
+    /// `HORIZON_STILL`, which would otherwise have to run about a hundred ticks to fade them.
+    pub fn settle_levels(&mut self) {
+        let target = |on: bool| if on { 1.0 } else { 0.0 };
+        self.rain_level = (target(self.raining), target(self.raining));
+        self.thunder_level = (target(self.thundering), target(self.thundering));
+    }
    /// Level.getRainLevel / getThunderLevel (thunder scales with rain).
    pub fn levels(&self, partial: f32) -> (f32, f32) {
        let rain = self.rain_level.0 + (self.rain_level.1 - self.rain_level.0) * partial;
@@ -562,11 +570,31 @@ impl Default for HealthRules {

 #[cfg(test)]
 mod tests {
-    use super::{DirtySections, World};
+    use super::{DirtySections, Weather, World};
    use crate::chunk::{Chunk, MIN_Y, SECTIONS};
    use horizon_world::registry::BlockStateId;
    use std::sync::Arc;

+    /// `/weather thunder` then `/weather clear` in a frozen world: the levels sit at their
+    /// targets at every partial tick, where a tick of fading would have moved them 0.01.
+    #[test]
+    fn settled_weather_shows_its_targets_at_any_partial_tick() {
+        let mut weather = Weather {
+            raining: true,
+            thundering: true,
+            rain_level: (0.25, 0.26),
+            ..Weather::default()
+        };
+        weather.settle_levels();
+        for partial in [0.0, 0.37, 1.0] {
+            assert_eq!(weather.levels(partial), (1.0, 1.0), "{partial}");
+        }
+        weather.raining = false;
+        weather.thundering = false;
+        weather.settle_levels();
+        assert_eq!(weather.levels(0.5), (0.0, 0.0));
+    }
+
    /// Every block write marks the same section set the 27-cell loop did, but
    /// only the distinct keys: one in the interior, a neighbour section on a
    /// section face, a neighbour column on a chunk border and the diagonal at
@@ -4,7 +4,7 @@ default-run = "horizon-client"
 version = "0.1.0"
 edition.workspace = true
 license.workspace = true
-rust-version = "1.90"
+rust-version.workspace = true
 description = "Horizon native development client"
 autobins = false
 autoexamples = false
@@ -69,6 +69,7 @@ horizon-theme = { path = "../horizon-theme" }
 # the anonymous "I'm playing" ping the game sends itself (`heartbeat.rs`).
 horizon-telemetry = { path = "../horizon-telemetry", default-features = false, features = ["live"] }
 horizon-bench = { path = "../horizon-bench" }
+crc32fast = "1"
 zip = { version = "9.1.3", default-features = false, features = ["deflate"] }
 # Controllers (evdev + libudev on Linux, IOKit on macOS, Windows.Gaming.Input); the `controllers` feature.
 gilrs = { version = "0.11", optional = true }
@@ -146,6 +147,10 @@ path = "tests/mod_api_hooks.rs"
 name = "native_gui_overlay_probe"
 path = "examples/native_gui_overlay_probe.rs"

+[[example]]
+name = "wind_burst_hook_probe"
+path = "examples/wind_burst_hook_probe.rs"
+
 [build-dependencies]
 horizon-mod-api-gen = { path = "../horizon-mod-api-gen" }
 # The build script runs on the host, but embeds resources based on the target OS.
@@ -30,6 +30,30 @@
  "horizon.studio.record.error": "Studio-Aufzeichnungsfehler: %s",
  "horizon.studio.record.status.active": "Studio-Aufzeichnung aktiv — %s s, %s Pakete, %s KB (%s)",
  "horizon.studio.record.status.inactive": "Studio-Aufzeichnung inaktiv",
+  "horizon.studio.replay.usage": "Verwendung: /studio replay <open PATH|pause|resume|speed MULTIPLIER|seek MS|status|close>",
+  "horizon.studio.replay.open.usage": "Verwendung: /studio replay open <PATH>",
+  "horizon.studio.replay.opened": "Studio-Wiedergabe geöffnet: %s (%s s, %s Pakete)",
+  "horizon.studio.replay.open_error": "Wiedergabe konnte nicht geöffnet werden: %s",
+  "horizon.studio.replay.paused": "Studio-Wiedergabe pausiert",
+  "horizon.studio.replay.resumed": "Studio-Wiedergabe fortgesetzt",
+  "horizon.studio.replay.inactive": "Keine aktive Studio-Wiedergabe",
+  "horizon.studio.replay.speed.usage": "Verwendung: /studio replay speed <MULTIPLIER>",
+  "horizon.studio.replay.speed.set": "Studio-Wiedergabegeschwindigkeit auf %s× gesetzt",
+  "horizon.studio.replay.speed.invalid": "Ungültige Wiedergabegeschwindigkeit",
+  "horizon.studio.replay.seek.usage": "Verwendung: /studio replay seek <MILLISEKUNDEN>",
+  "horizon.studio.replay.seeked": "Studio-Wiedergabe auf %s ms (%s s) gesetzt",
+  "horizon.studio.replay.seek.error": "Wiedergabe konnte nicht verschoben werden: %s",
+  "horizon.studio.replay.seek.backward_requires_standalone": "Zurückspulen ist nur bei einer eigenständigen Wiedergabe verfügbar.",
+  "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.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.",
+  "horizon.studio.open_folder": "Aufnahmen öffnen",
+  "horizon.studio.open_replay": "Wiedergabe starten",
+  "horizon.studio.refresh": "Aktualisieren",
+  "horizon.studio.unknown_server": "Unbekannt",
  "horizon.pages.mods": "Mods",
  "horizon.pages.shader_packs": "Shader-Pakete",
  "horizon.pages.shader_options": "Shader-Optionen",