Merge pull request #1561 from ludovic111/fix/remove-shader-packs

Remove shader packs
A developer of Iris showed that Horizon's shader pack code was written from Iris's source. This removes it: the horizon-shaderpack crate, Java pack loading and its render stages, Horizon's own WGSL packs and the example packs, the Shader Packs screen and its option, the launcher's shader pack browsing and installing, and the docs about them. Shader packs may come back later as a clean-room rewrite. The vanilla renderer and its post-processing (resolution scale, FXAA) are unchanged. Options files that name a pack load and drop the key; the launcher reads manifests that list a shader pack, and files in `shaderpacks/` are never deleted. Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-07 11:06:11 -10:00 · 2026-10-24 17:42:17 +02:00 · 2026-10-24 16:15:39 +02:00 · 2026-10-24 15:52:15 +02:00 · 2026-10-24 15:45:29 +02:00 · 2026-10-24 15:09:23 +02:00
432 changed files with 5414 additions and 19565 deletions
@@ -1,8 +1,8 @@
 name: release
 # Automatic game releases (docs/release-flow.md). After every green `checks` run on main, every 10 minutes (so a
 # release waiting for merges to settle goes out without another merge) and by hand, tools/release_train.py decides:
-# a release when pull requests merged since the last one changed what players run and the newest merged 5 minutes
-# ago (the oldest 20 minutes ago, if merges never pause), or at once for a pull request labelled release-now.
+# a release when 5 pull requests merged since the last one changed what players run and the newest merged 5 minutes
+# ago, or when the oldest has waited 6 hours, or at once for a pull request labelled release-now.
 # RELEASES_PAUSED=1 (repository variable) stops them; so does an open issue labelled release-blocker, forced runs too.
 # Builds Linux (an older Ubuntu, so the binary runs on any recent distribution and on NixOS through nix-ld) and
 # Windows on GitHub, macOS on the Mac mini's runner (MAC_RUNNER=macos-latest sends it to GitHub), then
@@ -12,17 +12,20 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
  folders in `HORIZON_HOME` (the game's data), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`. Never write to
  `~/.local/share/{applications,horizon,horizon-launcher}` or `~/.local/bin`.
- **Mark what an agent posts.** A PR body starts with
-  `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.` (issues: "Filed by", reviews:
-  "Review by"); every comment starts with `🤖 Agent:`. Never write as Ludovic.
- **Attribution.** Commits end with `Co-Authored-By: Claude <model> <[email protected]>`; PR bodies end
-  with `🤖 Generated with [Claude Code](https://claude.com/claude-code)`.
+- **Mark what an agent posts.** A PR body starts with a line naming whose agent opened it and with what.
+  Ludovic's agents write `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.`, and a
+  contributor's agent names its own person and tool (issues: "Filed by", reviews: "Review by"). Every
+  comment starts with `🤖 Agent:`. Never write as Ludovic or as anyone else.
+- **Attribution.** Commits end with a `Co-Authored-By:` line for the agent that wrote them, and PR bodies
+  with that agent's own "Generated with" line. Ludovic's agents use
+  `Co-Authored-By: Claude <model> <[email protected]>` and
+  `🤖 Generated with [Claude Code](https://claude.com/claude-code)`.
 - Everything players run is Rust. Python/Java only for dev tools and harness drivers in `tools/`.
 - Horizon-only features follow [docs/design-system.md](docs/design-system.md) and are off by default where
  they would change the vanilla look.
 - Small PRs (< ~500 lines). Labels: `feature` (players get something new), `skip-release` (they see no
-  change), none for a fix. Agents never add `release-now`: the maintainer decides it. Every merge to main ships
-  ([docs/release-flow.md](docs/release-flow.md)).
+  change), none for a fix. Agents never add `release-now`: the maintainer decides it. Merges ship in batches of 5, or after
+  6 hours ([docs/release-flow.md](docs/release-flow.md)).
 - Contributors first: `gh pr list --state open --search <area>` before you start; never duplicate theirs.

 ## Crates
@@ -40,7 +43,6 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 | `horizon-server` | `horizon-server`: `server.toml`, CLI, supervisor of the headless game ([docs/hosting.md](docs/hosting.md)) |
 | `horizon-server-files` | `server.properties`, eula, ops/whitelist/bans, usercache |
 | `horizon-friends`, `horizon-relay` | Play with Friends: invite codes, encrypted tunnel, the relay ([docs/play-with-friends.md](docs/play-with-friends.md)) |
-| `horizon-shaderpack` | OptiFine/Iris packs: preprocessor, GLSL → WGSL ([docs/shader-packs.md](docs/shader-packs.md)) |
 | `horizon-mods`, `horizon-mod-sdk`, `cargo-horizon-mod` | Sandboxed WebAssembly mods: runtime, SDK + WIT, `cargo horizon-mod` ([docs/mods.md](docs/mods.md)) |
 | `horizon-port-pack` | Porting Java modpacks ([docs/modpacks.md](docs/modpacks.md)) |
 | `horizon-theme` | Design tokens and fonts for the launcher, the game's own menus and the website |
@@ -123,7 +125,6 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 | Input | game.rs `fn window_event`, `fn key_pressed`, `fn play_mouse`; L: `keybinds.rs`, `keymapping.rs`, `key_names.rs`, `mouse.rs`, `input.rs`, `interaction_input.rs`, `gamepad.rs`, `osk.rs`, `clipboard.rs`; G: `pad.rs`, `pad_menu.rs` |
 | Audio | L: `audio.rs` (mixer), `sound_engine.rs`, `sound_events.rs`, `music.rs`, `ambience.rs`; G: `music.rs`, `subtitle_hud.rs` |
 | Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`, `lang.rs`; crate `horizon-assets`; G: `packs.rs` |
-| Shader packs | L: `shader_pack.rs` (Horizon WGSL packs), `java_pack.rs` + crate `horizon-shaderpack` (Iris/OptiFine), `gfx/pack_stages.rs`, `gfx/java_stages.rs`; G: `shader_packs.rs` |
 | Agent control | L: `control.rs` (socket), `bin/horizon-ctl/`; G: `control.rs`, `agent.rs`, `events.rs`, `ui_control.rs` ([docs/agent-control.md](docs/agent-control.md)) |
 | Mods | crate `horizon-mods`; G: `mods.rs`; L: `mod_content.rs`, `mod_list.rs` |
 | Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs`, `tweaks.rs`, `options.rs` |
@@ -148,19 +149,19 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end

 ## The two single-player paths

-1. **In-frame (default since #1428):** the window's `Game` ticks the world itself, one level that follows
-   the player (`fn enter_dimension`). This is what Stable players run and what harnesses test.
-2. **Server thread (`--server-thread` or `HORIZON_SERVER_THREAD=1`):** `game/integrated.rs` runs a second
-   `Game` (`serving`) on a "Server thread" with one level per dimension; the window joins it as a client
-   through memory (`remote`), exactly as a LAN guest or a dedicated server's player does. Not at parity yet:
-   open `[server-thread]` issues list the gaps.
+1. **Server thread (default since #1514):** `game/integrated.rs` runs a second `Game` (`serving`) on a
+   "Server thread" with one level per dimension; the window joins it as a client through memory (`remote`),
+   exactly as a LAN guest or a dedicated server's player does. This is what players run. Open
+   `[server-thread]` issues list the gaps left.
+2. **In-frame (`--in-frame`, `--no-server-thread` or `HORIZON_SERVER_THREAD=0`):** the window's `Game` ticks
+   the world itself, one level that follows the player (`fn enter_dimension`). Most harnesses test this path.

 LAN guests and dedicated servers always use the server code, so a fix there serves both. Test both paths
 when you touch player-facing gameplay:

 ```sh
-cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T                   # in-frame
-cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T --server-thread   # server thread
+cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T               # server thread
+cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T --in-frame    # in-frame
 python3 tools/lan_e2e.py --check <name>                  # host in-frame, guest is a server client
 python3 tools/lan_e2e.py --server-thread --check <name>  # host on its server thread (portals, levels, distance, lava need it)
 python3 tools/parity.py dedicated_server server_entities server_player_damage
@@ -178,15 +178,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b"

-[[package]]
-name = "ascii-canvas"
-version = "4.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef1e3e699d84ab1b0911a1010c5c106aa34ae89aeac103be5ce0c3859db1e891"
-dependencies = [
- "term",
-]
-
 [[package]]
 name = "ash"
 version = "0.38.0+1.3.281"
@@ -214,30 +205,15 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"

-[[package]]
-name = "bit-set"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
-dependencies = [
- "bit-vec 0.8.0",
-]
-
 [[package]]
 name = "bit-set"
 version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2f926cc3060f09db9ebc5b52823d85268d24bb917e472c0c4bea35780a7d"
 dependencies = [
- "bit-vec 0.9.1",
+ "bit-vec",
 ]

-[[package]]
-name = "bit-vec"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
-
 [[package]]
 name = "bit-vec"
 version = "0.9.1"
@@ -283,16 +259,6 @@ dependencies = [
 "objc2 0.6.5",
 ]

-[[package]]
-name = "borsh"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "553c5d846a6ba5150c65e3b1b8ec073bcf1abc20f9b7220de384a4443ea4e20a"
-dependencies = [
- "bytes",
- "cfg_aliases",
-]
-
 [[package]]
 name = "bumpalo"
 version = "3.20.3"
@@ -484,15 +450,6 @@ dependencies = [
 "crossbeam-utils",
 ]

-[[package]]
-name = "convert_case"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
-dependencies = [
- "unicode-segmentation",
-]
-
 [[package]]
 name = "coords-hud"
 version = "0.1.0"
@@ -797,41 +754,6 @@ dependencies = [
 "syn 2.0.119",
 ]

-[[package]]
-name = "darling"
-version = "0.20.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
-dependencies = [
- "darling_core",
- "darling_macro",
-]
-
-[[package]]
-name = "darling_core"
-version = "0.20.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
-dependencies = [
- "fnv",
- "ident_case",
- "proc-macro2",
- "quote",
- "strsim",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "darling_macro"
-version = "0.20.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
-dependencies = [
- "darling_core",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "dasp_sample"
 version = "0.11.0"
@@ -849,29 +771,6 @@ dependencies = [
 "syn 3.0.6",
 ]

-[[package]]
-name = "derive_more"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
-dependencies = [
- "derive_more-impl",
-]
-
-[[package]]
-name = "derive_more-impl"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
-dependencies = [
- "convert_case",
- "proc-macro2",
- "quote",
- "rustc_version",
- "syn 2.0.119",
- "unicode-xid",
-]
-
 [[package]]
 name = "digest"
 version = "0.10.7"
@@ -958,15 +857,6 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"

-[[package]]
-name = "ena"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eabffdaee24bd1bf95c5ef7cec31260444317e72ea56c4c91750e8b7ee58d5f1"
-dependencies = [
- "log",
-]
-
 [[package]]
 name = "encoding_rs"
 version = "0.8.42"
@@ -1230,58 +1120,6 @@ version = "0.30.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19fc433e8437a212d1b6f1e68c7824af3aed907da60afa994e7f542d18d12aa9"

-[[package]]
-name = "glsl-lang"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "983a18d0c2ecad18ac9ff3c94b069d6bd03b47405a200836d9d8d63def8e34de"
-dependencies = [
- "glsl-lang-lexer",
- "glsl-lang-types",
- "lalrpop",
- "lalrpop-util",
- "lang-util",
- "once_cell",
- "thiserror 2.0.21",
-]
-
-[[package]]
-name = "glsl-lang-lexer"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abdbc0bdfbc81d557f4865e695457eb23d68031bfb061fda3444f56511b26eee"
-dependencies = [
- "glsl-lang-pp",
- "glsl-lang-types",
- "lalrpop-util",
- "lang-util",
- "thiserror 2.0.21",
-]
-
-[[package]]
-name = "glsl-lang-pp"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88677876fb27f116015d0ecebda6d77bdf65f3a6fa3f5dfeed10b8c8f04cb2c5"
-dependencies = [
- "arrayvec",
- "derive_more",
- "lang-util",
- "string_cache",
- "string_cache_codegen",
- "thiserror 2.0.21",
-]
-
-[[package]]
-name = "glsl-lang-types"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd8b1532b424d40df634cf2dc2be56d59f994b9ac07fa7c1e3183fd33db9cb07"
-dependencies = [
- "lang-util",
- "thiserror 2.0.21",
-]
-
 [[package]]
 name = "gpu-allocator"
 version = "0.28.0"
@@ -1428,7 +1266,6 @@ dependencies = [
 "horizon-mods",
 "horizon-protocol",
 "horizon-server-files",
- "horizon-shaderpack",
 "horizon-telemetry",
 "horizon-theme",
 "horizon-threads",
@@ -1443,7 +1280,6 @@ dependencies = [
 "serde_json",
 "sha2",
 "symphonia",
- "toml",
 "ureq",
 "wgpu",
 "winit",
@@ -1594,16 +1430,6 @@ dependencies = [
 "ureq",
 ]

-[[package]]
-name = "horizon-shaderpack"
-version = "0.1.0"
-dependencies = [
- "glsl-lang",
- "naga",
- "pp-rs",
- "zip",
-]
-
 [[package]]
 name = "horizon-telemetry"
 version = "0.1.0"
@@ -1755,12 +1581,6 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"

-[[package]]
-name = "ident_case"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
-
 [[package]]
 name = "idna"
 version = "1.1.0"
@@ -1943,73 +1763,6 @@ dependencies = [
 "wasm-bindgen",
 ]

-[[package]]
-name = "keccak"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653"
-dependencies = [
- "cpufeatures",
-]
-
-[[package]]
-name = "lalrpop"
-version = "0.22.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba4ebbd48ce411c1d10fb35185f5a51a7bfa3d8b24b4e330d30c9e3a34129501"
-dependencies = [
- "ascii-canvas",
- "bit-set 0.8.0",
- "ena",
- "itertools",
- "lalrpop-util",
- "petgraph 0.7.1",
- "pico-args",
- "regex",
- "regex-syntax",
- "sha3",
- "string_cache",
- "term",
- "unicode-xid",
- "walkdir",
-]
-
-[[package]]
-name = "lalrpop-util"
-version = "0.22.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5baa5e9ff84f1aefd264e6869907646538a52147a755d494517a8007fb48733"
-dependencies = [
- "regex-automata",
- "rustversion",
-]
-
-[[package]]
-name = "lang-util"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1715a1e56998f119cd6d49ac8a69802dcbe4fca96d8291243d6dae87abeb913"
-dependencies = [
- "derive_more",
- "lalrpop-util",
- "lang-util-derive",
- "line-span",
- "smol_str 0.3.6",
- "text-size",
-]
-
-[[package]]
-name = "lang-util-derive"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f2acc66aedf0e445534e0a6b3f0f6ee20ef6ebb9647dbe10735e52ea8d6a096"
-dependencies = [
- "darling",
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "lazy_static"
 version = "1.5.1"
@@ -2066,12 +1819,6 @@ dependencies = [
 "pkg-config",
 ]

-[[package]]
-name = "line-span"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29fc123b2f6600099ca18248f69e3ee02b09c4188c0d98e9a690d90dec3e408a"
-
 [[package]]
 name = "linux-raw-sys"
 version = "0.4.15"
@@ -2183,7 +1930,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a616d2fb8c89516ac2723a581f69d6c18576046bed761bd6b305e5618e6ae130"
 dependencies = [
 "arrayvec",
- "bit-set 0.10.0",
+ "bit-set",
 "bitflags 2.13.2",
 "cfg-if",
 "cfg_aliases",
@@ -2196,7 +1943,6 @@ dependencies = [
 "naga-types",
 "num-traits",
 "once_cell",
- "pp-rs",
 "rustc-hash 1.1.0",
 "spirv",
 "thiserror 2.0.21",
@@ -2245,12 +1991,6 @@ dependencies = [
 "jni-sys 0.3.1",
 ]

-[[package]]
-name = "new_debug_unreachable"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
-
 [[package]]
 name = "nix"
 version = "0.31.3"
@@ -2750,16 +2490,6 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"

-[[package]]
-name = "petgraph"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772"
-dependencies = [
- "fixedbitset",
- "indexmap",
-]
-
 [[package]]
 name = "petgraph"
 version = "0.8.3"
@@ -2771,31 +2501,6 @@ dependencies = [
 "indexmap",
 ]

-[[package]]
-name = "phf_generator"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
-dependencies = [
- "phf_shared",
- "rand",
-]
-
-[[package]]
-name = "phf_shared"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
-dependencies = [
- "siphasher",
-]
-
-[[package]]
-name = "pico-args"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
-
 [[package]]
 name = "pin-project"
 version = "1.1.13"
@@ -2914,21 +2619,6 @@ dependencies = [
 "zerovec",
 ]

-[[package]]
-name = "pp-rs"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb458bb7f6e250e6eb79d5026badc10a3ebb8f9a15d1fff0f13d17c71f4d6dee"
-dependencies = [
- "unicode-xid",
-]
-
-[[package]]
-name = "precomputed-hash"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
-
 [[package]]
 name = "presser"
 version = "0.3.1"
@@ -3022,15 +2712,6 @@ version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"

-[[package]]
-name = "rand"
-version = "0.8.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c"
-dependencies = [
- "rand_core",
-]
-
 [[package]]
 name = "rand_core"
 version = "0.6.4"
@@ -3369,16 +3050,6 @@ dependencies = [
 "digest",
 ]

-[[package]]
-name = "sha3"
-version = "0.10.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77fd7028345d415a4034cf8777cd4f8ab1851274233b45f84e3d955502d93874"
-dependencies = [
- "digest",
- "keccak",
-]
-
 [[package]]
 name = "shlex"
 version = "2.0.1"
@@ -3407,12 +3078,6 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"

-[[package]]
-name = "siphasher"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256"
-
 [[package]]
 name = "slab"
 version = "0.4.12"
@@ -3462,16 +3127,6 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "smol_str"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4aaa7368fcf4852a4c2dd92df0cace6a71f2091ca0a23391ce7f3a31833f1523"
-dependencies = [
- "borsh",
- "serde_core",
-]
-
 [[package]]
 name = "socket2"
 version = "0.5.10"
@@ -3521,37 +3176,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"

-[[package]]
-name = "string_cache"
-version = "0.8.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf776ba3fa74f83bf4b63c3dcbbf82173db2632ed8452cb2d891d33f459de70f"
-dependencies = [
- "new_debug_unreachable",
- "parking_lot",
- "phf_shared",
- "precomputed-hash",
- "serde",
-]
-
-[[package]]
-name = "string_cache_codegen"
-version = "0.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c711928715f1fe0fe509c53b43e993a9a557babc2d0a3567d0a3006f1ac931a0"
-dependencies = [
- "phf_generator",
- "phf_shared",
- "proc-macro2",
- "quote",
-]
-
-[[package]]
-name = "strsim"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
-
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -3668,15 +3292,6 @@ version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"

-[[package]]
-name = "term"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8c27177b12a6399ffc08b98f76f7c9a1f4fe9fc967c784c5a071fa8d93cf7e1"
-dependencies = [
- "windows-sys 0.61.2",
-]
-
 [[package]]
 name = "termcolor"
 version = "1.4.1"
@@ -3686,12 +3301,6 @@ dependencies = [
 "winapi-util",
 ]

-[[package]]
-name = "text-size"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f18aa187839b2bdb1ad2fa35ead8c4c2976b64e4363c386d45ac0f7ee85c9233"
-
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -3852,7 +3461,7 @@ checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
 dependencies = [
 "memchr",
 "nom",
- "petgraph 0.8.3",
+ "petgraph",
 ]

 [[package]]
@@ -4573,8 +4182,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14c018fce9b6270aa203c2fdd56f3cce996713534bd757e4ea58c8560b121f14"
 dependencies = [
 "arrayvec",
- "bit-set 0.10.0",
- "bit-vec 0.9.1",
+ "bit-set",
+ "bit-vec",
 "bitflags 2.13.2",
 "bytemuck",
 "cfg_aliases",
@@ -4624,7 +4233,7 @@ dependencies = [
 "android_system_properties",
 "arrayvec",
 "ash",
- "bit-set 0.10.0",
+ "bit-set",
 "bitflags 2.13.2",
 "block2 0.6.2",
 "bytemuck",
@@ -5122,7 +4731,7 @@ dependencies = [
 "rustix 0.38.44",
 "sctk-adwaita",
 "smithay-client-toolkit",
- "smol_str 0.2.2",
+ "smol_str",
 "tracing",
 "unicode-segmentation",
 "wasm-bindgen",
@@ -1,6 +1,6 @@
 [workspace]
 exclude = ["launcher", "crates/horizon-telemetry-server", "third_party/wgpu-hal"]
-members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/voxel-kernels", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-shaderpack", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "xtask"]
+members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/voxel-kernels", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "xtask"]
 resolver = "2"

 [workspace.package]
@@ -45,7 +45,7 @@ The [documentation](https://playhorizon.dev/docs/) covers each of these.

 - **The game:** singleplayer with vanilla's world generation, mobs, villagers, raids, redstone, every command, the HUD and the recipe book, on saves in vanilla's format. Worlds from 1.8 to 26.2 are upgraded as vanilla does. [Status table](#project-status).
 - **Horizon's own extras:** new menus (vanilla's are one setting away), graphics presets, distant terrain up to 1024 chunks, controller support, optional zoom, minimap and more, all off by default where they would change the vanilla look. See [Settings](https://playhorizon.dev/docs/settings).
- **Resource packs, shader packs and data packs:** resource packs work, Java shader packs run their full-screen effects (experimental), and data packs load functions, predicates and item modifiers.
+- **Resource packs and data packs:** resource packs work, and data packs load functions, predicates and item modifiers.
 - **Playing with others:** invite friends from the pause menu's Friends button with a code, Open to LAN, and joining offline-mode servers. Horizon cannot sign in to a Microsoft account yet, so it cannot join servers that check accounts. See [Multiplayer](https://playhorizon.dev/docs/multiplayer).
 - **Mods:** Horizon has its own mod system (Rust compiled to WebAssembly). Java mod jars do not run. See [Mods and data packs](https://playhorizon.dev/docs/mods).

@@ -57,7 +57,7 @@ Screenshots, captured in the Rust client itself with vanilla assets and no mods
  </tr>
  <tr>
    <td width="50%"><img src="docs/media/survival.webp" alt="Survival at dusk: a zombie walks up, with the hotbar, health, hunger and experience"></td>
-    <td width="50%"><img src="docs/media/settings.webp" alt="Vanilla's Video Settings screen with Horizon's own buttons at the top: Horizon Graphics, Advanced Graphics and Shader Packs"></td>
+    <td width="50%"><img src="docs/media/settings.webp" alt="Vanilla's Video Settings screen with Horizon's own buttons at the top: Horizon Graphics and Advanced Graphics"></td>
  </tr>
  <tr>
    <td width="50%"><img src="docs/media/village.webp" alt="A plains village among savanna hills, with farms, villagers and an iron golem"></td>
@@ -29,13 +29,9 @@ png = "0.18"
 sha2 = "0.10.9"
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1.0.151", features = ["raw_value"] }
-# Shader packs: pack.toml, and WGSL checked before it reaches wgpu.
-toml = "1.1"
 # hlsl-out: the gfx.rs tests translate every shader as wgpu's DirectX 12 backend does. A normal feature,
 # not a dev-dependency's, so builds, tests and examples share one build of naga, wgpu and this crate.
 naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out"] }
-# Java (OptiFine/Iris) shader packs, translated to WGSL.
-horizon-shaderpack = { path = "../horizon-shaderpack" }
 # Sound (ALSA on Linux); the `audio` feature.
 cpal = { version = "0.16", optional = true }
 symphonia = { version = "0.5", default-features = false, features = ["ogg", "vorbis"] }
@@ -85,6 +81,11 @@ mods = ["horizon-mods/runtime"]
 # Records the call sites of mob random draws (`mob_ai_probe` traces).
 rng-trace = ["horizon-core/rng-trace"]

+# Its own name, not `probe`: Cargo copies every crate's examples into one target/<profile>/examples.
+[[example]]
+name = "client_probe"
+path = "examples/probe/main.rs"
+
 [lints]
 workspace = true

@@ -41,7 +41,7 @@ pub fn main(names: &[&str], run: fn(&str) -> Option<ExitCode>) -> ExitCode {
    let name = std::env::args().nth(1).unwrap_or_default();
    run(&name).unwrap_or_else(|| {
        eprintln!(
-            "usage: probe <name> [arguments...]\nprobes: {}",
+            "usage: client_probe <name> [arguments...]\nprobes: {}",
            names.join(" ")
        );
        ExitCode::from(2)
@@ -293,6 +293,47 @@ fn spawn_seed(index: usize) -> i64 {
    1000 + 7919 * index as i64
 }

+/// `Villager.spawnGolemIfNeeded` for villager `a`, the game's way: the golem
+/// draws from the level's random and joins the scenario's mobs next tick,
+/// seeded as the oracle seeds what a tick spawned.
+fn summon_golem(
+    mobs: &mut [Mob],
+    a: usize,
+    needed: usize,
+    w: &MobWorld,
+    types: &MobTypes,
+    born: &mut Vec<Mob>,
+    level_random: &mut LegacyRandom,
+) {
+    use horizon_client::mobs::{villager, villager_brain};
+    let Some(near) = villager::golem_summoners(mobs, a, w.game_time, needed) else {
+        return;
+    };
+    let kind = Arc::new(
+        types
+            .types
+            .get("minecraft:iron_golem")
+            .expect("iron golem")
+            .clone(),
+    );
+    let index = mobs.len() + born.len();
+    let p = mobs[a].position;
+    let start = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32];
+    let golem = villager::summon_golem(w, start, level_random, |random, at, yaw| {
+        let mut m = Mob::new(100_000 + index as u32, kind.clone(), at, yaw);
+        villager::finalize_summoned_golem(&mut m, random);
+        m
+    });
+    let Some(mut golem) = golem else {
+        return;
+    };
+    golem.random = LegacyRandom::new(spawn_seed(index));
+    born.push(golem);
+    for j in near {
+        villager_brain::golem_detected(&mut mobs[j], w.game_time);
+    }
+}
+
 /// Villager events that act at once in vanilla (`TradeWithVillager` and
 /// `VillagerMakeLove` write the other villager directly).
 fn villager_events(
@@ -304,6 +345,7 @@ fn villager_events(
    items: &Items,
    born: &mut Vec<Mob>,
    day_time: i64,
+    level_random: &mut LegacyRandom,
 ) {
    use horizon_client::mobs::villager;
    let index = |mobs: &[Mob], id: u32| {
@@ -314,6 +356,7 @@ fn villager_events(
    while i < events.len() {
        match events[i] {
            MobEvent::VillagerMeet { mob, other } => {
+                events.remove(i);
                if let (Some(a), Some(b)) = (index(mobs, mob), index(mobs, other)) {
                    let meeting = villager::meet(mobs, a, b, w.game_time, |item| {
                        items.get(item).map_or(64, |i| i.max_stack)
@@ -322,8 +365,16 @@ fn villager_events(
                        meeting.thrown.is_empty(),
                        "villagers toss items: not modelled here"
                    );
+                    if meeting.gossiped {
+                        summon_golem(mobs, a, 5, w, types, born, level_random);
+                    }
                }
+            }
+            MobEvent::GolemCheck { mob, needed } => {
                events.remove(i);
+                if let Some(a) = index(mobs, mob) {
+                    summon_golem(mobs, a, needed, w, types, born, level_random);
+                }
            }
            MobEvent::VillagerBirth {
                parent,
@@ -1167,6 +1218,7 @@ pub fn main() -> horizon_client::Result<()> {
                    &items,
                    &mut born,
                    s.time,
+                    &mut scratch,
                );
                horizon_client::mobs::warden::hear_mob_events(&mut mobs, &events, from, &w);
                // Melee hits on other mobs land during the attacker's tick
@@ -1323,6 +1375,31 @@ pub fn main() -> horizon_client::Result<()> {
                    world.set(at[0], at[1], at[2], registry.resolve(&st)?)?;
                }
            }
+            // Doors villagers opened or closed (DoorBlock.setOpen), both halves.
+            let doors: Vec<([i32; 3], bool)> = events
+                .iter()
+                .filter_map(|e| match e {
+                    MobEvent::SetDoorOpen { pos, open } => Some((*pos, *open)),
+                    _ => None,
+                })
+                .collect();
+            for (at, open) in doors {
+                let Some(half) = registry
+                    .state(world.block(at[0], at[1], at[2]))
+                    .and_then(|s| s.properties.get("half").cloned())
+                else {
+                    continue;
+                };
+                let other = if half == "lower" { 1 } else { -1 };
+                for y in [at[1], at[1] + other] {
+                    if let Some(mut st) = registry.state(world.block(at[0], y, at[2])).cloned()
+                        && st.properties.contains_key("open")
+                    {
+                        st.properties.insert("open".to_owned(), open.to_string());
+                        world.set(at[0], y, at[2], registry.resolve(&st)?)?;
+                    }
+                }
+            }
            mobs.append(&mut born);
            mobs.append(&mut added);
            for e in &heart_events {
@@ -147,7 +147,6 @@ const PAGES: Ty = Ty::Enum(&[
    "graphics-advanced",
    "extras",
    "horizon",
-    "shader-packs",
    "agent",
 ]);

@@ -382,7 +382,7 @@ impl Providers {
        );
        Self { ints, floats }
    }
-    fn eval(&self, v: &Value, fast: bool, table: &HashMap<String, Value>, depth: u32) -> f64 {
+    fn eval(v: &Value, fast: bool, table: &HashMap<String, Value>, depth: u32) -> f64 {
        if depth > 16 {
            return 0.0;
        }
@@ -390,10 +390,10 @@ impl Providers {
            Value::Number(n) => n.as_f64().unwrap_or(0.0),
            Value::String(name) => table
                .get(name)
-                .map_or(0.0, |v| self.eval(v, fast, table, depth + 1)),
+                .map_or(0.0, |v| Self::eval(v, fast, table, depth + 1)),
            Value::Object(o) => {
                let f =
-                    |k: &str| self.eval(o.get(k).unwrap_or(&Value::Null), fast, table, depth + 1);
+                    |k: &str| Self::eval(o.get(k).unwrap_or(&Value::Null), fast, table, depth + 1);
                match o.get("type").and_then(Value::as_str).unwrap_or("") {
                    "minecraft:div" => {
                        let r = f("right");
@@ -425,14 +425,14 @@ impl Providers {
    }
    /// A plain `context_int_provider` value or reference (no context conditions).
    pub fn int_value(&self, v: &Value) -> i32 {
-        self.eval(v, false, &self.ints, 0) as i32
+        Self::eval(v, false, &self.ints, 0) as i32
    }
    /// A plain `context_float_provider` value or reference; `default` when absent.
    pub fn float_value(&self, v: &Value, default: f32) -> f32 {
        if v.is_null() {
            default
        } else {
-            self.eval(v, false, &self.floats, 0) as f32
+            Self::eval(v, false, &self.floats, 0) as f32
        }
    }
    #[cfg(test)]
@@ -446,14 +446,14 @@ impl Providers {
        items
            .get(&stack.item)
            .and_then(|i| i.fuel.as_ref())
-            .map_or(0, |(time, _)| self.eval(time, fast, &self.ints, 0) as i32)
+            .map_or(0, |(time, _)| Self::eval(time, fast, &self.ints, 0) as i32)
    }
    pub fn speed(&self, items: &Items, stack: &ItemStack, fast: bool) -> f32 {
        items
            .get(&stack.item)
            .and_then(|i| i.fuel.as_ref())
            .map_or(1.0, |(_, speed)| {
-                self.eval(speed, fast, &self.floats, 0) as f32
+                Self::eval(speed, fast, &self.floats, 0) as f32
            })
    }
 }
@@ -425,6 +425,29 @@ fn split_id(id: &str) -> (String, String) {
        None => ("minecraft".to_owned(), id.to_owned()),
    }
 }
+/// The slot under the cursor, for the search tab's keys.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Hover {
+    Nothing,
+    /// A display slot (`isCreativeSlot`), showing an item or past the end.
+    Display {
+        filled: bool,
+    },
+    /// Any other slot: the hotbar row, or the inventory tab's slots.
+    Slot,
+}
+
+/// `CreativeModeInventoryScreen.keyPressed` on the search tab: whether a
+/// key is a hotbar swap on the hovered slot instead of text for the search
+/// box. `numeric` is `getNumericKeyValue().isPresent()` (the digit and keypad
+/// keys); `hotbar_key` is a `keyHotbarSlots` key. Over an empty display slot
+/// the key types (`doQuickSwap` is false), and `checkHotbarKeyPressed` needs
+/// a hovered slot and an empty cursor.
+pub fn search_key_swaps(numeric: bool, hotbar_key: bool, hover: Hover, carrying: bool) -> bool {
+    let quick_swap = hover != Hover::Display { filled: false };
+    quick_swap && numeric && hotbar_key && !carrying && hover != Hover::Nothing
+}
+
 /// What a click on an item tab's display slot does besides changing the
 /// carried stack.
 #[derive(Clone, PartialEq, Debug)]
@@ -529,6 +552,22 @@ mod tests {
        (carried, effect)
    }

+    #[test]
+    fn search_tab_number_keys_swap_over_a_slot_before_typing() {
+        let filled = Hover::Display { filled: true };
+        let empty = Hover::Display { filled: false };
+        // Over an item, the hotbar row or another slot: the hotbar swap.
+        assert!(search_key_swaps(true, true, filled, false));
+        assert!(search_key_swaps(true, true, Hover::Slot, false));
+        // Over an empty display slot, nothing or with a carried stack: text.
+        assert!(!search_key_swaps(true, true, empty, false));
+        assert!(!search_key_swaps(true, true, Hover::Nothing, false));
+        assert!(!search_key_swaps(true, true, filled, true));
+        // Letters always type; so do the digits no hotbar key is bound to.
+        assert!(!search_key_swaps(false, false, filled, false));
+        assert!(!search_key_swaps(true, false, filled, false));
+    }
+
    #[test]
    fn display_slot_clicks_follow_slot_clicked() {
        use crate::menu::Input::*;
@@ -102,7 +102,8 @@ enum Provider {
 /// One font (`FontSet`): its providers and the glyphs resolved so far.
 struct FontSet {
    providers: Vec<Provider>,
-    glyphs: HashMap<char, Glyph>,
+    /// Every char drawn looks up here, so the hasher is Fx, not SipHash.
+    glyphs: crate::fast_hash::FxHashMap<char, Glyph>,
    /// `glyphsByWidth` for obfuscated text (built on first use).
    by_width: Option<HashMap<u32, Vec<char>>>,
 }
@@ -647,7 +648,7 @@ impl Font {
            .collect();
        FontSet {
            providers,
-            glyphs: HashMap::new(),
+            glyphs: Default::default(),
            by_width: None,
        }
    }
@@ -138,7 +138,6 @@ mod screens;
 mod sculk;
 mod sculk_fixture;
 mod server_travel;
-mod shader_packs;
 mod shield;
 mod sign_edit;
 mod sniffers;
@@ -285,11 +284,9 @@ struct Options {
    benchmark: Option<String>,
    /// `--dev-mod PATH` (repeatable): mods always on and reloaded when rebuilt.
    dev_mods: Vec<PathBuf>,
-    /// `--server-thread` or `HORIZON_SERVER_THREAD=1`: single player runs on an
-    /// integrated server thread (game/integrated.rs), as vanilla's does. Off by
-    /// default again until a server's players reach parity with the in-frame
-    /// world (signs, books, totems, keep_inventory...); `--no-server-thread`
-    /// keeps it off.
+    /// Single player runs on an integrated server thread (game/integrated.rs),
+    /// as vanilla's does: the default. `--in-frame` (or `--no-server-thread`,
+    /// or `HORIZON_SERVER_THREAD=0`) runs the world in the frame instead.
    server_thread: bool,
    /// Set on the integrated server's own options: it draws nothing, so it skips meshing.
    integrated: bool,
@@ -347,7 +344,7 @@ impl Options {
            dev_mods: Vec::new(),
            // The command harness (HORIZON_COMMAND_SCRIPT) drives the world
            // itself, without the event loop: it stays in the frame.
-            server_thread: std::env::var("HORIZON_SERVER_THREAD").is_ok_and(|v| v == "1")
+            server_thread: std::env::var("HORIZON_SERVER_THREAD").map_or(true, |v| v != "0")
                && std::env::var_os("HORIZON_COMMAND_SCRIPT").is_none(),
            integrated: false,
        };
@@ -357,7 +354,7 @@ impl Options {
            match arg.as_str() {
                "--help" | "-h" => {
                    println!(
-                        "Horizon — Minecraft Java Edition {} in Rust\n\n  --resources PATH        Prepared resources (horizon-prepare)\n  --render-distance N     Chunks, 2..64 (default 12)\n  --world NAME            World folder under saves/ (default \"New World\")\n  --seed N                World seed for new worlds (default 0)\n  --width N, --height N   Window size (default 1280 x 720)\n  --creative              Creative mode (default survival)\n  --test-terrain          Simple test terrain instead of vanilla generation\n  --frames N              Exit after N frames (testing)\n  --world-frames N        Exit after N frames drawn in the world (testing)\n  --smoke-report PATH     Write a JSON report on exit\n  --benchmark SCENARIO    Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n  --control               Accept horizon-ctl commands on a local socket\n  --control-socket PATH   Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n  --server HOST[:PORT]    Join a multiplayer server (offline mode) at start\n  --name NAME             Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n  --session-file PATH     Signed-in account from the launcher (read once, then deleted)\n  --dev-mod PATH          A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n  --server-thread         Run single player's world on its server thread (not at parity yet)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.",
+                        "Horizon — Minecraft Java Edition {} in Rust\n\n  --resources PATH        Prepared resources (horizon-prepare)\n  --render-distance N     Chunks, 2..64 (default 12)\n  --world NAME            World folder under saves/ (default \"New World\")\n  --seed N                World seed for new worlds (default 0)\n  --width N, --height N   Window size (default 1280 x 720)\n  --creative              Creative mode (default survival)\n  --test-terrain          Simple test terrain instead of vanilla generation\n  --frames N              Exit after N frames (testing)\n  --world-frames N        Exit after N frames drawn in the world (testing)\n  --smoke-report PATH     Write a JSON report on exit\n  --benchmark SCENARIO    Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n  --control               Accept horizon-ctl commands on a local socket\n  --control-socket PATH   Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n  --server HOST[:PORT]    Join a multiplayer server (offline mode) at start\n  --name NAME             Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n  --session-file PATH     Signed-in account from the launcher (read once, then deleted)\n  --dev-mod PATH          A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n  --in-frame              Run single player's world in the frame, not on its server thread\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.",
                        horizon_core::VANILLA_VERSION
                    );
                    return Ok(None);
@@ -372,7 +369,7 @@ impl Options {
                "--offscreen" => o.offscreen = true,
                "--control" => o.control = Some(horizon_client::control::default_path()),
                "--server-thread" => o.server_thread = true,
-                "--no-server-thread" => o.server_thread = false,
+                "--in-frame" | "--no-server-thread" => o.server_thread = false,
                _ => {
                    let value = args
                        .next()
@@ -1201,8 +1198,6 @@ struct Game<'a> {
    modifiers: winit::keyboard::ModifiersState,
    /// The window's fullscreen request and reported state.
    fullscreen: horizon_client::window::FullscreenState,
-    /// The selected Horizon shader pack (`game/shader_packs.rs`).
-    shader_packs: shader_packs::ShaderPacks,
    /// MouseHandler's accumulated look and wheel state.
    mouse: MouseLook,
    /// An agent moved the mouse (`mouse-move`) since the pointer was last
@@ -1446,6 +1441,8 @@ struct Game<'a> {
    mount_menu: mount_menu::MountMenu,
    /// The player's fishing hook.
    hook: Option<fishing::Hook>,
+    /// The other players' hooks a server tracks to this client.
+    remote_hooks: Vec<fishing::RemoteHook>,
    tridents: Vec<trident::ThrownTrident>,
    rockets: Vec<fireworks::Rocket>,
    /// Ominous trial spawners' item spawners.
@@ -1741,10 +1738,10 @@ impl Game<'_> {
            let state = self.world.block(pos[0], pos[1], pos[2]);
            let f = self.res.facts().get(state);
            if !self.res.facts().is_air(state)
-                && !(f.fluid != Fluid::None
-                    && !f.waterlogged
-                    && &*f.name != "minecraft:kelp"
-                    && f.render_shape != horizon_client::blocks::RenderShape::Model)
+                && (f.fluid == Fluid::None
+                    || f.waterlogged
+                    || &*f.name == "minecraft:kelp"
+                    || f.render_shape == horizon_client::blocks::RenderShape::Model)
                && !matches!(
                    &*f.name,
                    "minecraft:water" | "minecraft:lava" | "minecraft:bubble_column"
@@ -1817,6 +1814,65 @@ impl Game<'_> {
        self.stack_in_mut(self.held_slot())
    }
    /// The slot of the hand that acts: the selected one, or `OFFHAND_SLOT`.
+    /// `LivingEntity.canGlideUsing`: a glider in the chest slot that will
+    /// not break with its next point of wear.
+    fn glider_worn(&self) -> bool {
+        self.armor[1].as_ref().is_some_and(|s| {
+            self.res
+                .items()
+                .get(&s.item)
+                .is_some_and(|i| i.glider && (i.max_damage == 0 || s.damage + 1 < i.max_damage))
+        })
+    }
+    /// What the window decides for its player's body every tick, in frame and
+    /// on a server alike: the look (Player.travel steers sprint-swimming by
+    /// the pitch), Auto Jump (LocalPlayer.sendPosition), the slowdown of an
+    /// item in use (LocalPlayer.modifyInput), the helmet's Respiration
+    /// (decreaseAirSupply), the wings, leather boots on powder snow
+    /// (PowderSnowBlock.canEntityWalkOnPowderSnow), freeze-immune wear
+    /// (LivingEntity.canFreeze) and the dimension's FAST_LAVA.
+    pub(crate) fn sync_player_body(&mut self) {
+        let glider = self.glider_worn();
+        let item_use_speed = self
+            .using
+            .and_then(|(slot, _)| {
+                if slot == shield::OFFHAND_SLOT {
+                    self.offhand.as_ref()
+                } else {
+                    self.inventory.get(slot)?.as_ref()
+                }
+            })
+            .and_then(|s| self.res.items().get(&s.item))
+            .map(|i| i.use_speed);
+        let respiration = self.armor[0]
+            .as_ref()
+            .map_or(0, |s| s.enchantment_level("minecraft:respiration") as i32);
+        let leather_boots = self.armor[3]
+            .as_ref()
+            .is_some_and(|s| &*s.item == "minecraft:leather_boots");
+        let immune = self
+            .res
+            .items()
+            .item_tags
+            .get("minecraft:freeze_immune_wearables");
+        let freeze_immune = self
+            .armor
+            .iter()
+            .flatten()
+            .any(|s| immune.is_some_and(|t| t.contains(&*s.item)));
+        let Some(player) = self.player.as_mut() else {
+            return;
+        };
+        player.yaw = self.yaw;
+        player.pitch = self.pitch;
+        player.auto_jump_enabled = self.settings.auto_jump;
+        player.item_use_speed = item_use_speed;
+        player.respiration = respiration;
+        player.glider = glider;
+        player.leather_boots = leather_boots;
+        player.freeze_immune = freeze_immune;
+        player.fluids.fast_lava = self.dim == Dim::Nether;
+    }
    fn held_slot(&self) -> usize {
        match self.hand {
            Hand::Main => self.selected,
@@ -3451,7 +3507,7 @@ impl Game<'_> {
            return Ok(true);
        }
        // Block foods attempt placement before starting consumption.
-        if !on_block && !(info.block.is_some() && block_hit.is_some()) && self.start_eating(&info) {
+        if !on_block && (info.block.is_none() || block_hit.is_none()) && self.start_eating(&info) {
            return Ok(true);
        }
        // BoatItem.use also performs its own fluid/block raycast.
@@ -3671,16 +3727,8 @@ impl Game<'_> {
        // Switching hotbar slots only ends a main-hand use.
        let hand_changed = slot != self.selected && slot != shield::OFFHAND_SLOT;
        if !self.right || hand_changed || self.screen != Screen::Playing {
-            if &*stack.item == "minecraft:bow" && !hand_changed {
-                self.release_bow(ticks);
-            }
-            if &*stack.item == "minecraft:spyglass" {
-                self.stop_spyglass();
-            }
-            if &*stack.item == "minecraft:trident" && !hand_changed {
-                self.release_trident(ticks);
-            }
            self.using = None;
+            self.release_used_item(&stack, ticks, hand_changed);
            return;
        }
        let Some(info) = self.res.items().get(&stack.item).cloned() else {
@@ -3736,6 +3784,17 @@ impl Game<'_> {
            self.using = Some((slot, ticks));
        }
    }
+    /// `LivingEntity.releaseUsingItem` (`Item.releaseUsing`) for `stack`,
+    /// used for `ticks`, its hand acting: a bow or a trident lets go (not
+    /// when its hand changed), a spyglass stops scoping.
+    pub(super) fn release_used_item(&mut self, stack: &ItemStack, ticks: u32, hand_changed: bool) {
+        match &*stack.item {
+            "minecraft:bow" if !hand_changed => self.release_bow(ticks),
+            "minecraft:trident" if !hand_changed => self.release_trident(ticks),
+            "minecraft:spyglass" => self.stop_spyglass(),
+            _ => {}
+        }
+    }
    fn tick_mining(&mut self) -> Result<()> {
        if self.destroy_delay > 0 {
            self.destroy_delay -= 1;
@@ -3825,7 +3884,12 @@ impl Game<'_> {
        }
        self.crack_particle(crack.0, crack.1, state);
        let m = self.mining.as_mut().ok_or("mining")?;
-        if m.progress >= 1.0 {
+        // ServerPlayerGameMode breaks a player's block at once only when it is instant (START's
+        // insta-mine); otherwise it waits for the client's STOP_DESTROY_BLOCK
+        // (`guest_stop_digging`), never breaking it on its own count. Breaking it here would
+        // take the block from under the player's crack before the player's client predicts the
+        // break, so it gets neither particles nor sound.
+        if m.progress >= 1.0 && (self.lan_acting.is_none() || m.ticks == 1) {
            let pos = m.pos;
            self.mining = None;
            self.break_block(pos)?;
@@ -3959,13 +4023,7 @@ impl Game<'_> {
            .as_ref()
            .map_or(0, |s| s.enchantment_level("minecraft:respiration") as i32);
        player.pitch = self.pitch;
-        // LivingEntity.canGlideUsing: a glider in its slot that will not break next.
-        player.glider = self.armor[1].as_ref().is_some_and(|s| {
-            self.res
-                .items()
-                .get(&s.item)
-                .is_some_and(|i| i.glider && (i.max_damage == 0 || s.damage + 1 < i.max_damage))
-        });
+        player.glider = self.glider_worn();
        // A saved death already dropped inventory/XP and counted the death.
        if player.health.dead_or_dying() {
            self.screen = Screen::Dead;
@@ -4041,8 +4099,9 @@ impl Game<'_> {
            self.tick_riding(keys)?;
        }
        let riding = self.riding.is_some();
-        let ghast_collisions = self.happy_ghast_player_collisions();
+        let entity_collisions = self.player_entity_collisions();
        let spin_targets = self.spin_targets();
+        self.sync_player_body();
        let Some(player) = self.player.as_mut() else {
            // A dedicated server has no local player: the world still runs.
            if self.options.dedicated.is_some() {
@@ -4074,52 +4133,10 @@ impl Game<'_> {
        if !riding {
            self.previous_position = player.position;
        }
-        player.yaw = self.yaw;
        let spectator = self.mode == horizon_client::command::args::GameMode::Spectator;
        player.may_fly = self.creative || spectator;
-        // LocalPlayer.sendPosition: autoJumpEnabled follows the option.
-        player.auto_jump_enabled = self.settings.auto_jump;
        player.invulnerable = self.creative || spectator;
        player.spectator = spectator;
-        player.respiration = self.armor[0]
-            .as_ref()
-            .map_or(0, |s| s.enchantment_level("minecraft:respiration") as i32);
-        player.pitch = self.pitch;
-        // LivingEntity.canGlideUsing: a glider in its slot that will not break next.
-        player.glider = self.armor[1].as_ref().is_some_and(|s| {
-            self.res
-                .items()
-                .get(&s.item)
-                .is_some_and(|i| i.glider && (i.max_damage == 0 || s.damage + 1 < i.max_damage))
-        });
-        // LocalPlayer.modifyInput: walking while using an item.
-        player.item_use_speed = self
-            .using
-            .and_then(|(slot, _)| {
-                if slot == shield::OFFHAND_SLOT {
-                    self.offhand.as_ref()
-                } else {
-                    self.inventory.get(slot)?.as_ref()
-                }
-            })
-            .and_then(|s| self.res.items().get(&s.item))
-            .map(|i| i.use_speed);
-        // PowderSnowBlock.canEntityWalkOnPowderSnow and LivingEntity.canFreeze.
-        player.leather_boots = self.armor[3]
-            .as_ref()
-            .is_some_and(|s| &*s.item == "minecraft:leather_boots");
-        let immune = self
-            .res
-            .items()
-            .item_tags
-            .get("minecraft:freeze_immune_wearables");
-        player.freeze_immune = self
-            .armor
-            .iter()
-            .flatten()
-            .any(|s| immune.is_some_and(|t| t.contains(&*s.item)));
-        // The dimension's FAST_LAVA: the Nether's lava pushes harder.
-        player.fluids.fast_lava = self.dim == Dim::Nether;
        player.spin_targets = spin_targets;
        let grounded = player.ground.on_ground;
        let before = (
@@ -4129,7 +4146,7 @@ impl Game<'_> {
        );
        if !riding {
            MotionWorld {
-                entities: &ghast_collisions,
+                entities: &entity_collisions,
                player,
                scene: &mut self.world,
                assets: &self.pack.assets,
@@ -6002,6 +6019,37 @@ impl Game<'_> {
        }
        true
    }
+    /// `CreativeModeInventoryScreen.keyPressed` on the search tab: a hotbar
+    /// key over a slot swaps before the search box sees it.
+    fn search_tab_hotbar_key(&mut self, code: KeyCode) -> bool {
+        use horizon_client::creative::{Hover, search_key_swaps};
+        let hotbar_key = HOTBAR_DIGITS.contains(&code);
+        let numeric = hotbar_key || NUMERIC_KEYS.contains(&code);
+        if !numeric {
+            return false;
+        }
+        let Some(size) = self
+            .renderer
+            .as_ref()
+            .map(|r| [r.config.width, r.config.height])
+        else {
+            return false;
+        };
+        let batch = HudBatch::new(size);
+        let hover = match self.slot_at(&batch, self.cursor.0, self.cursor.1) {
+            None => Hover::Nothing,
+            Some(slot) if slot >= Creative::DISPLAY => {
+                let first = self.creative_screen.first_row(&self.pack.names);
+                let shown = self.creative_screen.items(&self.pack.names).len();
+                Hover::Display {
+                    filled: first * 9 + slot - Creative::DISPLAY < shown,
+                }
+            }
+            Some(_) => Hover::Slot,
+        };
+        search_key_swaps(numeric, hotbar_key, hover, self.carried.is_some())
+            && self.inventory_hotkey(code)
+    }
    /// Number keys, F and Q over a slot of the open menu: SWAP with a hotbar
    /// slot or the off hand, THROW one or the whole stack.
    fn inventory_hotkey(&mut self, key: KeyCode) -> bool {
@@ -6017,19 +6065,7 @@ impl Game<'_> {
        let Some(slot) = self.slot_at(&batch, self.cursor.0, self.cursor.1) else {
            return false;
        };
-        let digit = [
-            KeyCode::Digit1,
-            KeyCode::Digit2,
-            KeyCode::Digit3,
-            KeyCode::Digit4,
-            KeyCode::Digit5,
-            KeyCode::Digit6,
-            KeyCode::Digit7,
-            KeyCode::Digit8,
-            KeyCode::Digit9,
-        ]
-        .iter()
-        .position(|k| *k == key);
+        let digit = HOTBAR_DIGITS.iter().position(|k| *k == key);
        let done = match (digit, key) {
            (Some(n), _) => self.menu_click(Some(slot), n as i32, Input::Swap),
            (None, KeyCode::KeyF) => self.menu_click(Some(slot), 40, Input::Swap),
@@ -7395,30 +7431,17 @@ impl Game<'_> {
        self.tick_player_model();
        Ok(())
    }
-    /// What the loaded Java shader pack changes in this dimension's vanilla
-    /// sky (`sunPathRotation`, `clouds`, `sun`, `moon`); `None` without one.
-    fn java_sky(&self) -> Option<(f32, horizon_shaderpack::properties::SkyDirectives)> {
-        self.shader_packs.java_sky(match self.dim {
-            Dim::Overworld => 0,
-            Dim::Nether => -1,
-            Dim::End => 1,
-        })
-    }
    /// SkyRenderer.renderSunMoonAndStars: bodies on a frame rotated Y -90 then X by angle.
-    /// A Java pack's `sunPathRotation` tilts it about Z in between, and its
-    /// `sun = false` / `moon = false` leave those out, as Iris does. Returns
-    /// the sun and moon quads, and the stars' frame and brightness (the
-    /// renderer keeps their geometry, built once).
+    /// Returns the sun and moon quads, and the stars' frame and brightness
+    /// (the renderer keeps their geometry, built once).
    fn celestial_geometry(
        &self,
        sky: &horizon_client::environment::Sky,
    ) -> (Vec<Vertex>, Option<(glam::Mat4, f32)>) {
        let mut out = Vec::new();
        let atlas = &self.gui.atlas;
-        let (tilt, keep) = self.java_sky().unwrap_or_default();
        let frame = |angle: f32| {
            glam::Mat4::from_rotation_y((-90.0f32).to_radians())
-                * glam::Mat4::from_rotation_z(tilt.to_radians())
                * glam::Mat4::from_rotation_x(angle.to_radians())
        };
        let mut body = |name: &str, angle: f32, size: f32, color: u32| {
@@ -7440,14 +7463,12 @@ impl Game<'_> {
                });
            }
        };
-        if keep.sun {
-            body(
-                "environment/celestial/sun",
-                sky.sun_angle,
-                30.0,
-                0xFFFF_FFFF,
-            );
-        }
+        body(
+            "environment/celestial/sun",
+            sky.sun_angle,
+            30.0,
+            0xFFFF_FFFF,
+        );
        let phases = [
            "full_moon",
            "waning_gibbous",
@@ -7459,14 +7480,12 @@ impl Game<'_> {
            "waxing_gibbous",
        ];
        let phase = phases[(self.world.day_time / 24000).rem_euclid(8) as usize];
-        if keep.moon {
-            body(
-                &format!("environment/celestial/moon/{phase}"),
-                sky.moon_angle,
-                20.0,
-                0xFFFF_FFFF,
-            );
-        }
+        body(
+            &format!("environment/celestial/moon/{phase}"),
+            sky.moon_angle,
+            20.0,
+            0xFFFF_FFFF,
+        );
        // SkyRenderer.renderStars: the static star buffer on the same frame.
        let stars =
            (sky.star_brightness > 0.0).then(|| (frame(sky.star_angle), sky.star_brightness));
@@ -9792,7 +9811,6 @@ impl Game<'_> {
            }
            return Ok(false);
        }
-        self.poll_shader_pack();
        let Some(size) = self
            .renderer
            .as_ref()
@@ -10005,18 +10023,6 @@ impl Game<'_> {
            self.dragon_fireball_geometry(camera, alpha, &mut dragon);
            entities.extend(dragon);
        }
-        // A Java pack's `clouds` replaces the cloud option (`renderClouds`:
-        // "false", "fast", "true"), as Iris overrides `getCloudsType`.
-        let clouds_mode = {
-            use horizon_shaderpack::properties::CloudSetting;
-            match self.java_sky().and_then(|(_, sky)| sky.clouds) {
-                Some(CloudSetting::Off) => "false",
-                Some(CloudSetting::Fast) => "fast",
-                Some(CloudSetting::Fancy) => "true",
-                None => self.settings.clouds.as_str(),
-            }
-            .to_owned()
-        };
        let (celestial, stars) = if title {
            (Vec::new(), None)
        } else if self.dim == Dim::Overworld
@@ -10060,7 +10066,6 @@ impl Game<'_> {
        let frame = Frame {
            weather: &weather,
            weather_time: horizon_client::weather::Time::new(self.world.game_time, alpha as f32),
-            shader: self.shader_inputs(camera, alpha as f32),
            nether_lighting: self.dim == Dim::Nether,
            camera,
            yaw,
@@ -10108,7 +10113,7 @@ impl Game<'_> {
            hud: &hud,
            clouds: (!title
                && self.dim == Dim::Overworld
-                && horizon_client::clouds::visible(&clouds_mode, sky.cloud_color[3]))
+                && horizon_client::clouds::visible(&self.settings.clouds, sky.cloud_color[3]))
            .then(|| self.gui.atlas.sprites.get("horizon/white"))
            .flatten()
            .map(|white| horizon_client::clouds::Input {
@@ -10118,7 +10123,7 @@ impl Game<'_> {
                time: self.world.game_time,
                partial_tick: alpha,
                range: self.settings.cloud_range,
-                fast: clouds_mode == "fast",
+                fast: self.settings.clouds == "fast",
                color: sky.cloud_color,
            }),
            entities: &entities,
@@ -10340,6 +10345,11 @@ impl Game<'_> {
                if (self.screen == Screen::Inventory
                    || (self.screen == Screen::Creative && !self.creative_screen.tab().search))
                    && self.inventory_hotkey(key) => {}
+            // The search tab's number keys (scripted presses; the window's
+            // keys reach search_tab_hotbar_key before the search box).
+            _ if self.screen == Screen::Creative
+                && self.creative_screen.tab().search
+                && self.search_tab_hotbar_key(key) => {}
            KeyCode::KeyT if self.screen == Screen::Inventory => self.recipe_focus_search(),
            KeyCode::KeyT if self.screen == Screen::Playing => self.open_chat(""),
            // key.advancements.
@@ -10831,9 +10841,6 @@ impl ApplicationHandler for Game<'_> {
                WindowEvent::CloseRequested => {
                    self.pending_save.as_mut().unwrap().quit = true;
                }
-                WindowEvent::DroppedFile(path) => {
-                    self.drop_shader_pack(&path);
-                }
                WindowEvent::Focused(focused) => {
                    self.focused = focused;
                    if !focused {
@@ -11211,7 +11218,11 @@ impl ApplicationHandler for Game<'_> {
                        && event.state == ElementState::Pressed
                        && !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
                {
-                    if let Some(shortcut) = self.edit_shortcut(&event) {
+                    if let PhysicalKey::Code(key) = event.physical_key
+                        && self.search_tab_hotbar_key(key)
+                    {
+                        // The hovered slot took the key (`ignoreTextInput`).
+                    } else if let Some(shortcut) = self.edit_shortcut(&event) {
                        self.creative_search_shortcut(shortcut);
                    } else {
                        let backspace = event.physical_key == PhysicalKey::Code(KeyCode::Backspace);
@@ -11712,7 +11723,6 @@ impl<'a> Game<'a> {
            focused: true,
            modifiers: winit::keyboard::ModifiersState::empty(),
            fullscreen: horizon_client::window::FullscreenState::new(false),
-            shader_packs: Default::default(),
            mouse: MouseLook::default(),
            agent_pointer: false,
            smooth_camera: false,
@@ -11872,6 +11882,7 @@ impl<'a> Game<'a> {
            recipe_ui: Default::default(),
            mount_menu: Default::default(),
            hook: None,
+            remote_hooks: Vec::new(),
            tridents: Vec::new(),
            rockets: Vec::new(),
            ominous_spawners: Vec::new(),
@@ -12149,6 +12160,33 @@ impl Game<'_> {
    }
 }

+/// `key.hotbar.1` to `key.hotbar.9` in a menu.
+const HOTBAR_DIGITS: [KeyCode; 9] = [
+    KeyCode::Digit1,
+    KeyCode::Digit2,
+    KeyCode::Digit3,
+    KeyCode::Digit4,
+    KeyCode::Digit5,
+    KeyCode::Digit6,
+    KeyCode::Digit7,
+    KeyCode::Digit8,
+    KeyCode::Digit9,
+];
+/// The other keys `InputConstants.Key.getNumericKeyValue` gives a digit.
+const NUMERIC_KEYS: [KeyCode; 11] = [
+    KeyCode::Digit0,
+    KeyCode::Numpad0,
+    KeyCode::Numpad1,
+    KeyCode::Numpad2,
+    KeyCode::Numpad3,
+    KeyCode::Numpad4,
+    KeyCode::Numpad5,
+    KeyCode::Numpad6,
+    KeyCode::Numpad7,
+    KeyCode::Numpad8,
+    KeyCode::Numpad9,
+];
+
 const STAGES: u32 = 10;
 const STAGE_LINES: [&str; 10] = [
    "Loading menu",
@@ -12643,7 +12681,6 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> {
        night_vision: 0.0,
        block_flicker: 0.0,
        menu_blur: None,
-        shader: Default::default(),
    }
 }

@@ -463,6 +463,7 @@ impl Game<'_> {
                "velocity": [p.velocity.x, p.velocity.y, p.velocity.z],
                "on_ground": p.ground.on_ground,
                "flying": p.flying,
+                "fall_flying": p.fall_flying,
                "sneaking": self.keys.contains(&KeyCode::ShiftLeft),
                "sprinting": self.keys.contains(&KeyCode::ControlLeft),
                "health": p.health.health(),
@@ -59,6 +59,30 @@ impl Game<'_> {
    }
    /// Block commands; None when `words[0]` is not one of them.
    pub(super) fn block_command(&mut self, words: &[&str]) -> Result<Option<Value>> {
+        let ours = matches!(
+            words.first(),
+            Some(&("setblock" | "fill" | "getblock" | "container"))
+        );
+        // Single player on its server thread: the world is the server's, so
+        // the command runs there, in the owner's level, and the client hears
+        // of it like any change.
+        if ours && let Some(server) = &self.integrated {
+            let owned: Vec<String> = words.iter().map(|w| (*w).to_owned()).collect();
+            return server
+                .call(move |g| {
+                    let words: Vec<&str> = owned.iter().map(String::as_str).collect();
+                    g.in_owner_level(|g| g.block_command(&words).map_err(|e| e.to_string()))
+                })
+                .ok_or("the integrated server stopped")?
+                .map_err(Into::into);
+        }
+        // Another server's world changes only through its own commands, which
+        // it checks as the player's; `getblock` and `container` read what this
+        // client has of it.
+        if self.remote.is_some() && matches!(words.first(), Some(&("setblock" | "fill"))) {
+            self.send_chat(&format!("/{}", words.join(" ")));
+            return Ok(Some(json!({ "ok": true, "sent": true })));
+        }
        let int = |i: usize| -> Result<i32> {
            Ok(words
                .get(i)
@@ -183,13 +183,18 @@ impl BoatModels {
 }
 impl Game<'_> {
    fn fluid_height(&self, x: i32, y: i32, z: i32) -> Option<(f32, bool)> {
+        self.fluid_height_of(x, y, z, Some(Fluid::Water))
+    }
+    /// `FluidState.getHeight` and whether it is a source, for `fluid` or,
+    /// with `None`, any fluid (`ClipContext.Fluid.ANY`).
+    fn fluid_height_of(&self, x: i32, y: i32, z: i32, fluid: Option<Fluid>) -> Option<(f32, bool)> {
        let f = self.res.facts().get(self.world.block(x, y, z));
-        if f.fluid != Fluid::Water {
+        if f.fluid == Fluid::None || fluid.is_some_and(|want| f.fluid != want) {
            return None;
        }
        let above = self.res.facts().get(self.world.block(x, y + 1, z));
        // FluidState.getHeight: 1 under the same fluid, else amount / 9.
-        let height = if above.fluid == Fluid::Water {
+        let height = if above.fluid == f.fluid {
            1.0
        } else {
            f32::from(f.fluid_level) / 9.0
@@ -461,6 +466,59 @@ impl Game<'_> {
            let b = self.boats[i].clone();
            self.boats[i] = self.tick_boat(b, false);
        }
+        // AbstractBoat.tick's applyEffectsFromBlocks, on the server for every
+        // boat, the client-driven ones too.
+        let mut i = 0;
+        while i < self.boats.len() {
+            let p = self.boats[i].position;
+            let skip = Some(self.boats[i].id) == self.riding
+                || !ticking(p.x.floor() as i32, p.z.floor() as i32);
+            if skip || !self.boat_lava_tick(i) {
+                i += 1;
+            }
+        }
+    }
+    /// `LavaFluid.entityInside` (`lavaHurt`) from the two
+    /// `applyEffectsFromBlocks` calls in `AbstractBoat.tick`: twice 40
+    /// damage, so lava breaks a boat on its first tick inside, and the fire
+    /// `lavaIgnite` lights never gets to burn it. True when the boat broke.
+    fn boat_lava_tick(&mut self, i: usize) -> bool {
+        if !self.in_lava(self.boats[i].bounds()) {
+            return false;
+        }
+        for _ in 0..2 {
+            let p = self.boats[i].position;
+            let broke = self.hurt_boat(i, 4.0, false);
+            self.lava_hurt_sound([p.x, p.y, p.z]);
+            if broke {
+                return true;
+            }
+        }
+        false
+    }
+    /// `Entity.lavaHurt`'s sound once the hurt went through.
+    pub(super) fn lava_hurt_sound(&mut self, at: [f64; 3]) {
+        let pitch = 2.0 + self.world.random.next_float() * 0.4;
+        self.audio
+            .play("minecraft:entity.generic.burn", Some(at), 0.4, pitch);
+    }
+    /// Whether a vehicle's box, deflated by 1e-5, reaches into lava below its
+    /// surface (`Entity.collidedWithFluid`).
+    pub(super) fn in_lava(&self, bb: Aabb) -> bool {
+        let (lo, hi) = (bb.min_position(), bb.max_position());
+        let e = 1.0e-5;
+        for x in (lo.x + e).floor() as i32..=(hi.x - e).floor() as i32 {
+            for y in (lo.y + e).floor() as i32..=(hi.y - e).floor() as i32 {
+                for z in (lo.z + e).floor() as i32..=(hi.z - e).floor() as i32 {
+                    if let Some((height, _)) = self.fluid_height_of(x, y, z, Some(Fluid::Lava))
+                        && lo.y + e < f64::from(y) + f64::from(height)
+                    {
+                        return true;
+                    }
+                }
+            }
+        }
+        false
    }
    /// The player's tick while riding: steer, tick the boat, sit in it.
    pub(super) fn tick_riding(&mut self, keys: Keys) -> horizon_client::Result<()> {
@@ -489,6 +547,9 @@ impl Game<'_> {
            p.fall_distance = 0.0;
        }
        self.boats[i] = b;
+        if self.boat_lava_tick(i) {
+            self.riding = None;
+        }
        Ok(())
    }
    /// `getDismountLocationForPassenger`: in front of the player if there is
@@ -534,7 +595,8 @@ impl Game<'_> {
        };
        let dir = view_vector(self.yaw, self.pitch);
        let reach = self.reach();
-        // ClipContext.Fluid.ANY: the first water surface or block along the ray.
+        // ClipContext.Fluid.ANY: the first fluid surface (water or lava) or
+        // block along the ray.
        let block = self.pick().map(|h| {
            (
                h.point,
@@ -544,7 +606,7 @@ impl Game<'_> {
                    .sqrt(),
            )
        });
-        let mut water = None;
+        let mut fluid = None;
        let mut t = 0.0;
        while t < reach {
            let p: [f64; 3] = std::array::from_fn(|a| eye[a] + dir[a] * t);
@@ -553,15 +615,15 @@ impl Game<'_> {
                p[1].floor() as i32,
                p[2].floor() as i32,
            );
-            if let Some((h, _)) = self.fluid_height(x, y, z)
+            if let Some((h, _)) = self.fluid_height_of(x, y, z, None)
                && p[1] <= f64::from(y) + f64::from(h)
            {
-                water = Some(([p[0], f64::from(y) + f64::from(h), p[2]], t));
+                fluid = Some(([p[0], f64::from(y) + f64::from(h), p[2]], t));
                break;
            }
            t += 0.05;
        }
-        let hit = match (block, water) {
+        let hit = match (block, fluid) {
            (Some(b), Some(w)) => {
                if w.1 < b.1 {
                    w.0
@@ -682,15 +744,23 @@ impl Game<'_> {
            return false;
        }
        self.vehicle_attack_sounds();
+        self.hurt_boat(i, damage, self.creative);
+        self.swing_arm();
+        true
+    }
+    /// `VehicleEntity.hurtServer`: wobble, add the damage and break past 40
+    /// (`creative`: a creative player's hit removes it without drops).
+    /// True when the boat was removed.
+    pub(super) fn hurt_boat(&mut self, i: usize, damage: f32, creative: bool) -> bool {
        let b = &mut self.boats[i];
        b.hurt_dir = -b.hurt_dir;
        b.hurt_time = 10;
        b.damage += damage * 10.0;
-        let destroyed = self.creative || b.damage > 40.0;
+        let destroyed = creative || b.damage > 40.0;
        if destroyed {
            let b = self.boats.remove(i);
            let at = [b.position.x, b.position.y, b.position.z];
-            if !self.creative && self.ui.rules.bool("entity_drops") {
+            if !creative && self.ui.rules.bool("entity_drops") {
                // ChestBoat.destroy: chestVehicleDestroyed spills the contents.
                for stack in b.items.iter().flatten() {
                    self.spawn_item(stack.clone(), at, super::dispenser::new_item_motion(), 10);
@@ -709,8 +779,7 @@ impl Game<'_> {
                );
            }
        }
-        self.swing_arm();
-        true
+        destroyed
    }
    /// AbstractBoatRenderer.
    pub(super) fn boat_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec<Vertex>) {
@@ -1,6 +1,6 @@
 //! Chat, the command registries and the per-world state behind commands
 //! (game rules, the world clock, difficulty), bound to the game.
-use super::{Dim, Game, Screen};
+use super::{Game, Screen};
 use horizon_client::{
    chat::{Chat, ChatAction, ChatScreen, Commands, SYSTEM_INDICATOR},
    command::Registries,
@@ -695,10 +695,7 @@ impl Game<'_> {
    /// Advance the overworld clock (ServerClockManager.tick) when
    /// `advance_time` allows it.
    pub(super) fn advance_clock(&mut self) {
-        if !self.ui.rules.bool("advance_time")
-            || self.ui.clock.paused
-            || self.dim == Dim::Nether && false
-        {
+        if !self.ui.rules.bool("advance_time") || self.ui.clock.paused {
            return;
        }
        let c = &mut self.ui.clock;
@@ -128,7 +128,7 @@ impl Game<'_> {
        if self.state_in_tag(avoid, ground) {
            return false;
        }
-        let entities = self.happy_ghast_player_collisions();
+        let entities = self.player_entity_collisions();
        let Some(player) = self.player.as_mut() else {
            return false;
        };
@@ -589,7 +589,6 @@ impl Game<'_> {
                    "credits" => Page::Credits,
                    "horizon" => Page::Horizon,
                    "agent" => Page::Agent,
-                    "shader-packs" => Page::ShaderPacks,
                    other => return Err(format!("unknown options page {other}").into()),
                };
                if self.screen == Screen::Playing && self.title.is_none() {
@@ -988,6 +987,7 @@ impl Game<'_> {
            "flashes": self.lightning_seen[1], "flash": self.flash});
        // Primed TNT, falling blocks, projectiles, tridents and end crystals.
        status["projectiles"] = json!(self.projectiles_status());
+        status["maps"] = json!(self.maps_status());
        // The particles made so far, by type.
        status["particles"] = json!(self.particles.made());
        // The world border this side knows of.
@@ -47,6 +47,8 @@ pub(super) struct Creatures {
    pub pearl_cooldown: u32,
    /// The wind charge's use cooldown (ticks).
    pub wind_cooldown: u32,
+    /// Wind bursts from a guest's turn, waiting for it to end (game/wind.rs).
+    pub wind_bursts: Vec<super::wind::Burst>,
    /// Ticks left of the elder guardian's apparition (MobAppearanceParticle).
    pub elder_apparition: i32,
    /// The wandering trader spawner's clock.
@@ -1005,6 +1007,11 @@ impl Game<'_> {
                MobEvent::SetBlock { pos, state } => {
                    self.world.set(pos[0], pos[1], pos[2], state)?
                }
+                MobEvent::SetDoorOpen { pos, open } => {
+                    let pos = BlockPos::new(pos[0], pos[1], pos[2]);
+                    self.with_level(|b, level, ticks| b.set_door_open(level, ticks, pos, open));
+                    self.process_level_events()?;
+                }
                MobEvent::SetBlockName { pos, name, effect } => {
                    if effect {
                        let old = self.world.block(pos[0], pos[1], pos[2]);
@@ -1489,12 +1496,16 @@ impl Game<'_> {
                o.hurt
            }
        {
-            let (xd, zd) = (from[0] - player.position.x, from[2] - player.position.z);
-            self.knock_back_player(f64::from(0.4_f32), xd, zd);
-            if let Some(p) = self.player.as_mut()
-                && let Some(r) = p.hurt_log.last_mut()
-            {
-                r.knockback = Some([p.velocity.x, p.velocity.y, p.velocity.z]);
+            // LivingEntity.hurtServer's dealDefaultKnockback: not inside the
+            // hurt cooldown (a stronger hit there only adds its difference).
+            if o.knockback {
+                let (xd, zd) = (from[0] - player.position.x, from[2] - player.position.z);
+                self.knock_back_player(f64::from(0.4_f32), xd, zd);
+                if let Some(p) = self.player.as_mut()
+                    && let Some(r) = p.hurt_log.last_mut()
+                {
+                    r.knockback = Some([p.velocity.x, p.velocity.y, p.velocity.z]);
+                }
            }
            self.hurt_armor(amount);
            self.thorns(from);
@@ -1778,7 +1789,7 @@ impl Game<'_> {
                _ => self.projectile_hit(&p, hit)?,
            }
        }
-        Ok(())
+        self.flush_wind_bursts()
    }
    /// `projectile_hit` for a projectile the guest `conn` shot, run as them;
    /// as the host's when they have left.
@@ -38,7 +38,7 @@ impl DebugHost for Host<'_, '_> {
        // the menu as it always has (key_pressed).
        let g = &mut *self.game;
        if without_menu && g.screen == Screen::Playing {
-            g.pause_menu = !(g.has_singleplayer_server() && !g.is_published());
+            g.pause_menu = !g.has_singleplayer_server() || g.is_published();
            g.screen = Screen::Paused;
            g.capture(false);
            g.mining = None;
@@ -593,7 +593,6 @@ impl Game<'_> {
            DebugAction::ReloadResourcePacks => {
                self.debug_translated("debug.reload_resourcepacks.message");
                self.reload_packs();
-                self.load_shader_pack();
                true
            }
            DebugAction::CopyLocation if player => {
@@ -121,11 +121,13 @@ impl Game<'_> {
        let bonus = if knockback_attack { 0.5 } else { 0.0 };
        (enchanted / 2.0 + bonus, knockback_attack)
    }
-    /// `causeExtraKnockback`'s direction, `(sin yRot, -cos yRot)`: the target
-    /// flies where the attacker looks, not away from it.
+    /// `causeExtraKnockback`'s direction, `(sin yRot, -cos yRot)` from Mth's
+    /// sine table: the target flies where the attacker looks, not away from
+    /// it (straight along an axis when the attacker faces one).
    pub(super) fn extra_knockback_direction(&self) -> (f64, f64) {
-        let yaw = self.yaw.to_radians();
-        (f64::from(yaw.sin()), -f64::from(yaw.cos()))
+        use horizon_core::geometry::trig;
+        let yaw = f64::from(self.yaw * trig::DEG_TO_RAD);
+        (f64::from(trig::sin(yaw)), -f64::from(trig::cos(yaw)))
    }
    /// The attacker's side of `causeExtraKnockback` as the attacking client
    /// sees it: the server's player stops sprinting, and its flag reaches the
@@ -69,12 +69,18 @@ impl Game<'_> {
        let lo = Vec3::new(f.pos[0] - half, f.pos[1], f.pos[2] - half);
        let hi = Vec3::new(f.pos[0] + half, f.pos[1] + 0.8, f.pos[2] + half);
        let b = horizon_core::geometry::Aabb::new(lo, hi);
-        if let Some(p) = self.player_view()
-            && p.alive
-            && p.bounds.intersects(b)
-        {
-            self.mob_hits_player_kind(6.0, f.pos, "minecraft:indirect_magic");
-        }
+        // Every player in the box, the server's players too.
+        let pos = f.pos;
+        let bite = move |g: &mut Self| {
+            if let Some(p) = g.player_view()
+                && p.alive
+                && p.bounds.intersects(b)
+            {
+                g.mob_hits_player_kind(6.0, pos, "minecraft:indirect_magic");
+            }
+        };
+        bite(self);
+        self.each_guest_hit(bite);
        for m in &mut self.mobs {
            let ally = matches!(
                m.species(),
@@ -2,6 +2,7 @@
 //! bobbing, lure and bite timers, open water, hooking mobs, retrieving the
 //! `gameplay/fishing` loot) and `FishingHookRenderer` (bobber and line).
 use super::{Game, view_vector};
+use horizon_client::lan::{entity::States, hub::Hub};
 use horizon_client::{
    blocks::Fluid,
    collisions::SceneCollisions,
@@ -15,7 +16,10 @@ use horizon_core::{
    geometry::{Aabb, Vec3, trig},
    random::RandomSource,
 };
-use std::sync::Arc;
+use horizon_protocol::entity_data::{Value, serializer};
+use std::{collections::HashMap, sync::Arc};
+
+use super::lan_actions::GuestPlay;

 #[derive(Clone, Copy, Debug, PartialEq)]
 enum State {
@@ -24,6 +28,8 @@ enum State {
    Hooked(u32),
 }
 pub(super) struct Hook {
+    /// Its entity id, which a server's players track it under.
+    id: u32,
    position: Vec3,
    previous: Vec3,
    velocity: Vec3,
@@ -114,7 +120,9 @@ impl Game<'_> {
            );
            // A spawned hook's start position is its feet: centre the box on the eye.
            let start = Vec3::new(start.x, start.y - SIZE / 2.0, start.z);
+            self.next_entity += 1;
            self.hook = Some(Hook {
+                id: self.next_entity,
                position: start,
                previous: start,
                velocity: v,
@@ -562,12 +570,17 @@ impl Game<'_> {
            lerp(h.previous.z, h.position.z),
        ))
    }
-    /// FishingHookRenderer: the bobber, a camera-facing half-block quad
-    /// centred on the hook.
+    /// FishingHookRenderer: the bobbers (this player's and the others' a
+    /// server tracks), camera-facing half-block quads centred on the hooks.
    pub(super) fn fishing_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec<Vertex>) {
-        let Some(p) = self.hook_position(alpha) else {
+        let hooks: Vec<glam::DVec3> = self
+            .hook_position(alpha)
+            .into_iter()
+            .chain(self.remote_hook_ends(alpha).into_iter().map(|(h, _)| h))
+            .collect();
+        if hooks.is_empty() {
            return;
-        };
+        }
        let Some(r) = self
            .gui
            .atlas
@@ -577,56 +590,57 @@ impl Game<'_> {
        else {
            return;
        };
-        let light = self
-            .world
-            .light(p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32);
-        let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
        let forward = glam::DVec3::from_array(view_vector(self.yaw, self.pitch));
        let right = forward.cross(glam::DVec3::Y).normalize_or_zero();
        let up = right.cross(forward).normalize_or_zero();
        let s = 0.25;
-        let corners = [
-            p - right * s - up * s,
-            p + right * s - up * s,
-            p + right * s + up * s,
-            p - right * s + up * s,
-        ];
        let uv = [[r.u0, r.v1], [r.u1, r.v1], [r.u1, r.v0], [r.u0, r.v0]];
-        for (v, uv) in corners.iter().zip(uv) {
-            out.push(Vertex {
-                normal: [0; 4],
-                pos: (*v - camera).as_vec3().to_array(),
-                uv,
-                layer: 0,
-                color: 0xFFFF_FFFF,
-                light: packed,
-            });
+        for p in hooks {
+            let light =
+                self.world
+                    .light(p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32);
+            let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
+            let corners = [
+                p - right * s - up * s,
+                p + right * s - up * s,
+                p + right * s + up * s,
+                p - right * s + up * s,
+            ];
+            for (v, uv) in corners.iter().zip(uv) {
+                out.push(Vertex {
+                    normal: [0; 4],
+                    pos: (*v - camera).as_vec3().to_array(),
+                    uv,
+                    layer: 0,
+                    color: 0xFFFF_FFFF,
+                    light: packed,
+                });
+            }
        }
    }
-    /// FishingHookRenderer: the line, 16 black `lines` segments sagging from
-    /// a quarter block above the hook to the rod in the player's hand,
+    /// FishingHookRenderer: each line, 16 black `lines` segments sagging
+    /// from a quarter block above the hook to the rod in its owner's hand,
    /// `width` pixels wide (`Window.getAppropriateLineWidth`).
    pub(super) fn fishing_line(&self, alpha: f64, size: [u32; 2]) -> Vec<Line> {
-        let (Some(hook), Some(hand)) = (
-            self.hook_position(alpha),
-            self.rod_hand_position(alpha, size),
-        ) else {
-            return Vec::new();
-        };
-        let offset = (hand - (hook + glam::DVec3::new(0.0, 0.25, 0.0))).as_vec3();
-        let point = |a: f32| {
-            let y = offset.y * (a * a + a) * 0.5 + 0.25;
-            hook + glam::Vec3::new(offset.x * a, y, offset.z * a).as_dvec3()
-        };
+        let own = self
+            .hook_position(alpha)
+            .zip(self.rod_hand_position(alpha, size));
        let width = horizon_client::gfx::outline_width(size[0]);
-        (0..16)
-            .map(|i| Line {
+        let mut lines = Vec::new();
+        for (hook, hand) in own.into_iter().chain(self.remote_hook_ends(alpha)) {
+            let offset = (hand - (hook + glam::DVec3::new(0.0, 0.25, 0.0))).as_vec3();
+            let point = |a: f32| {
+                let y = offset.y * (a * a + a) * 0.5 + 0.25;
+                hook + glam::Vec3::new(offset.x * a, y, offset.z * a).as_dvec3()
+            };
+            lines.extend((0..16).map(|i| Line {
                start: point(i as f32 / 16.0).to_array(),
                end: point((i + 1) as f32 / 16.0).to_array(),
                color: 0xFF00_0000,
                width,
-            })
-            .collect()
+            }));
+        }
+        lines
    }
    /// `FishingHookRenderer.getPlayerHandPos`: on the near plane in first
    /// person, beside the body otherwise.
@@ -694,6 +708,20 @@ impl Game<'_> {
    }
 }
 impl Game<'_> {
+    /// The hooks drawn here, with their owners' ids (0 for this player's own).
+    pub(super) fn hooks_status(&self) -> Vec<serde_json::Value> {
+        let at = |p: Vec3| [p.x, p.y, p.z];
+        let own = self.hook.iter().map(|h| (h.id, 0, h.position));
+        let others = self
+            .remote_hooks
+            .iter()
+            .map(|h| (h.id, h.owner, h.position));
+        own.chain(others)
+            .map(|(id, owner, p)| {
+                serde_json::json!({"id": id, "kind": "minecraft:fishing_bobber", "owner": owner, "position": at(p)})
+            })
+            .collect()
+    }
    /// The hook for `horizon-ctl status`.
    pub(super) fn hook_status(&self) -> Option<serde_json::Value> {
        let h = self.hook.as_ref()?;
@@ -706,3 +734,175 @@ impl Game<'_> {
        }))
    }
 }
+
+/// A hook a server tracks to this client (`FishingHook.recreateFromPacket`)
+/// that another player cast: drawn where the server puts it, its line
+/// running to that player's hand.
+pub(super) struct RemoteHook {
+    id: u32,
+    owner: u32,
+    position: Vec3,
+    previous: Vec3,
+}
+
+impl Hook {
+    /// This client's own hook as its server tracks it: drawn, never ticked here.
+    fn remote(id: u32, at: Vec3) -> Self {
+        Self {
+            id,
+            position: at,
+            previous: at,
+            velocity: Vec3::ZERO,
+            state: State::Flying,
+            life: 0,
+            on_ground: false,
+            nibble: 0,
+            time_until_lured: 0,
+            time_until_hooked: 0,
+            fish_angle: 0.0,
+            out_of_water: 0,
+            open_water: true,
+            luck: 0,
+            lure: 0,
+        }
+    }
+    /// `FishingHook`'s entity for the players tracking it: the owner's id in
+    /// its add packet, DATA_HOOKED_ENTITY (the hooked id plus one) and
+    /// DATA_BITING when they differ from their defaults.
+    fn track(&self, owner: i32, out: &mut States) {
+        let p = self.position;
+        let e = out.add(
+            self.id as i32,
+            super::lan::entity_uuid(self.id),
+            "minecraft:fishing_bobber",
+        );
+        e.position = [p.x, p.y, p.z];
+        e.velocity = [self.velocity.x, self.velocity.y, self.velocity.z];
+        e.on_ground = self.on_ground;
+        e.data = owner;
+        if let State::Hooked(id) = self.state {
+            e.meta.push((8, serializer::INT, Value::Int(id as i32 + 1)));
+        }
+        if self.nibble > 0 {
+            e.meta.push((9, serializer::BOOLEAN, Value::Bool(true)));
+        }
+    }
+}
+
+impl Game<'_> {
+    /// The hooks guests track: the host's and each guest's in the level.
+    pub(super) fn lan_hook_states(
+        &self,
+        host_entity: Option<i32>,
+        play: &HashMap<u32, GuestPlay>,
+        hub: &Hub,
+        out: &mut States,
+    ) {
+        if let (Some(h), Some(owner)) = (&self.hook, host_entity) {
+            h.track(owner, out);
+        }
+        for g in hub.guests.iter().filter(|g| hub.here(g)) {
+            if let Some(h) = play.get(&g.conn).and_then(|p| p.hook.as_ref()) {
+                h.track(g.entity_id, out);
+            }
+        }
+    }
+
+    /// `handleAddEntity` for a fishing bobber: this player's own becomes its
+    /// hook (`Player.fishing`), another player's is drawn on its line to them.
+    pub(super) fn spawn_remote_hook(&mut self, id: u32, at: Vec3, owner: i32) {
+        let own = self.remote.as_ref().map(|r| r.entity_id);
+        if own == Some(owner) {
+            self.hook = Some(Hook::remote(id, at));
+        } else {
+            self.remote_hooks.push(RemoteHook {
+                id,
+                owner: owner as u32,
+                position: at,
+                previous: at,
+            });
+        }
+    }
+
+    /// One tick of interpolation for the hooks a server tracks.
+    pub(super) fn step_remote_hooks(&mut self, mut step: impl FnMut(u32, Vec3) -> Vec3) {
+        if self.remote.is_none() {
+            return;
+        }
+        if let Some(h) = self.hook.as_mut() {
+            h.previous = h.position;
+            h.position = step(h.id, h.position);
+        }
+        for h in &mut self.remote_hooks {
+            h.previous = h.position;
+            h.position = step(h.id, h.position);
+        }
+    }
+
+    /// `FishingHook.onSyncedDataUpdated`: this player's hook is biting
+    /// (DATA_BITING), which `status` shows as a nibble.
+    pub(super) fn remote_hook_data(&mut self, id: u32, values: &[(u8, i32, Value)]) {
+        let Some(h) = self
+            .hook
+            .as_mut()
+            .filter(|h| h.id == id && self.remote.is_some())
+        else {
+            return;
+        };
+        for (index, _, value) in values {
+            if let (9, Value::Bool(biting)) = (index, value) {
+                h.nibble = i32::from(*biting);
+            }
+        }
+    }
+
+    pub(super) fn remove_remote_hook(&mut self, id: u32) {
+        if self.remote.is_some() && self.hook.as_ref().is_some_and(|h| h.id == id) {
+            self.hook = None;
+        }
+        self.remote_hooks.retain(|h| h.id != id);
+    }
+
+    pub(super) fn clear_remote_hooks(&mut self) {
+        if self.remote.is_some() {
+            self.hook = None;
+        }
+        self.remote_hooks.clear();
+    }
+
+    /// Other players' hooks: the bobber and its line to the owner's hand
+    /// (`FishingHookRenderer.getPlayerHandPos` in third person), as
+    /// (hook, hand) this frame.
+    fn remote_hook_ends(&self, alpha: f64) -> Vec<(glam::DVec3, glam::DVec3)> {
+        let lerp = |a: Vec3, b: Vec3| {
+            glam::DVec3::new(
+                a.x + (b.x - a.x) * alpha,
+                a.y + (b.y - a.y) * alpha,
+                a.z + (b.z - a.z) * alpha,
+            )
+        };
+        self.remote_hooks
+            .iter()
+            .filter_map(|h| {
+                let owner = self.mobs.iter().find(|m| m.id == h.owner)?;
+                let feet = lerp(owner.previous, owner.position);
+                let body = horizon_client::camera::lerp(
+                    alpha as f32,
+                    owner.previous_body_yaw,
+                    owner.body_yaw,
+                );
+                let angle = f64::from(body * (std::f64::consts::PI / 180.0) as f32);
+                let (sin, cos) = (f64::from(trig::sin(angle)), f64::from(trig::cos(angle)));
+                // The right arm; a crouching owner's eyes are lower.
+                let eye = owner.eye_y() - owner.position.y;
+                let hand = feet
+                    + glam::DVec3::new(
+                        -cos * 0.35 - sin * 0.8,
+                        eye - 0.45,
+                        -sin * 0.35 + cos * 0.8,
+                    );
+                Some((lerp(h.previous, h.position), hand))
+            })
+            .collect()
+    }
+}
@@ -200,7 +200,7 @@ impl Game<'_> {
            }
            Action::Copy => self.friends_copy(),
            Action::Stop => self.friends_stop(),
-            // The system browser, as the Shader Packs page opens its folder.
+            // The system browser, as the folder buttons open their folders.
            Action::Help => {
                if let Some(url) = &view.help {
                    super::packs::open_folder(std::path::Path::new(url));
@@ -10,9 +10,10 @@ use horizon_core::geometry::{Aabb, Vec3};
 use horizon_world::registry::BlockStateId;

 impl Game<'_> {
-    /// Client `EntityGetter.getEntityCollisions`: only solid happy ghasts,
-    /// excluding the player's own vehicle.
-    pub(super) fn happy_ghast_player_collisions(&self) -> Vec<Aabb> {
+    /// Client `EntityGetter.getEntityCollisions` for the player: the
+    /// entities that `canBeCollidedWith` it, solid happy ghasts and boats
+    /// (`AbstractBoat.canBeCollidedWith`), except the player's own vehicle.
+    pub(super) fn player_entity_collisions(&self) -> Vec<Aabb> {
        let Some(p) = &self.player else {
            return Vec::new();
        };
@@ -24,6 +25,12 @@ impl Game<'_> {
                    && happy_ghast::collides_with_player(m, p.position.y)
            })
            .map(|m| m.bounds())
+            .chain(
+                self.boats
+                    .iter()
+                    .filter(|b| Some(b.id) != self.riding)
+                    .map(super::boats::Boat::bounds),
+            )
            .collect()
    }
    /// `HappyGhast.mobInteract`. Returns whether the click was used.
@@ -6,12 +6,10 @@
 //! the world's options) with [`Integrated::call`], as vanilla's client calls
 //! into its `IntegratedServer`.
 //!
-//! Opt-in again (`--server-thread` or `HORIZON_SERVER_THREAD=1`) until a
-//! server's players reach parity with the in-frame world: on the server
-//! thread, signs open no editor, books don't open, a totem doesn't save its
-//! holder and death keeps the inventory (#1380, #1366, #1292, #1284 and the
-//! other `[server-thread]` issues). LAN guests and dedicated servers use the
-//! same code either way.
+//! On by default. `--in-frame` (or `--no-server-thread`, or
+//! `HORIZON_SERVER_THREAD=0`) runs the world in the frame instead, the
+//! escape hatch. LAN guests and dedicated servers use the same code either
+//! way.
 use super::{
    Game, Options, PackResources, Resources, UiResources,
    lan::{LanSettings, Owner},
@@ -498,6 +496,22 @@ impl Game<'_> {
        out
    }

+    /// Run `f` with the owner's level in place (the server holds one per
+    /// dimension), then put back the level that was.
+    pub(super) fn in_owner_level<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T {
+        let owner = self.serving.as_ref().map(|s| s.owner);
+        let dim = self.lan.as_ref().and_then(|h| {
+            let g = h.hub.guests.iter().find(|g| Some(g.uuid) == owner)?;
+            Some(super::Dim::from_id(&g.dimension))
+        });
+        let back = dim.and_then(|d| self.enter_command_level(d));
+        let out = f(self);
+        if let Some(back) = back {
+            self.enter_command_level(back);
+        }
+        out
+    }
+
    /// The window's requests, between two ticks.
    fn run_tasks(&mut self) {
        let tasks: Vec<Task> = match &self.serving {
@@ -411,7 +411,12 @@ impl Game<'_> {
                    "game_mode": g.game_mode,
                    // ItemCooldowns: the ticks the shield an axe disabled stays down.
                    "shield_cooldown": h.play.get(&g.conn).map_or(0, |p| p.shield_cooldown),
+                    // The item the server has this guest using: its slot and ticks.
+                    "using": h.play.get(&g.conn).and_then(|p| p.using())
+                        .map(|(slot, ticks)| json!({ "slot": slot, "ticks": ticks })),
                    "sneaking": g.sneaking,
+                    // The server's Elytra glide (shared flag 7).
+                    "fall_flying": g.fall_flying,
                    "sleeping": g.bed,
                    "health": g.health,
                    // The server's body: its air supply and golden hearts.
@@ -870,6 +875,7 @@ impl Game<'_> {
                    .collect();
                self.lan_riding(host_entity, &guests, &mut host.hub.riding);
                self.lan_entities(host_entity, &host.mob_players, &mut host.hub, &mut states);
+                self.lan_hook_states(host_entity, &host.play, &host.hub, &mut states);
            } else {
                states.clear();
            }
@@ -1006,6 +1012,8 @@ impl Game<'_> {
        drop(holding);
        lan::flush_all(host.hub.guests.iter().map(|g| &g.sender));
        self.lan = Some(host);
+        // A mace's wind burst from a guest's attack.
+        let _ = self.flush_wind_bursts();
    }

    fn lan_guest_joined(
@@ -1061,6 +1069,7 @@ impl Game<'_> {
            }
            // A dedicated server has no host player.
            self.lan_entities(None, &host.mob_players, &mut host.hub, &mut theirs);
+            self.lan_hook_states(None, &host.play, &host.hub, &mut theirs);
            theirs.as_slice()
        } else {
            entities
@@ -82,6 +82,8 @@ pub(super) struct GuestPlay {
    /// (`LivingEntity.collectEquipmentChanges`).
    modifiers: Vec<(String, String)>,
    equipped: Option<Vec<Option<ItemStack>>>,
+    /// The guest's cast fishing hook (`Player.fishing`).
+    pub(super) hook: Option<super::fishing::Hook>,
 }

 /// A guest's command waiting for the hub (`LanHost::commands`).
@@ -261,6 +263,7 @@ impl Game<'_> {
        motion.pitch = g.pitch;
        motion.sprinting = g.sprinting;
        motion.may_fly = g.creative() || g.game_mode == SPECTATOR;
+        motion.flying = g.flying;
        motion.invulnerable = motion.may_fly;
        let _ = motion.set_health(g.health, false);
        motion.health.food.food = g.food;
@@ -344,6 +347,7 @@ impl Game<'_> {
        std::mem::swap(&mut self.adv.unlocked, &mut g.recipes_unlocked);
        std::mem::swap(&mut self.level.recipe_book, &mut g.recipe_book);
        std::mem::swap(&mut self.stats, &mut play.stats);
+        std::mem::swap(&mut self.hook, &mut play.hook);
        let adv_loaded = std::mem::replace(&mut self.adv.loaded, true);
        let last_inventory = std::mem::replace(&mut self.adv.last_inventory, play.last_inventory);
        let death_cause = std::mem::replace(&mut self.ui.death_cause, play.death_cause.take());
@@ -551,6 +555,7 @@ impl Game<'_> {
        std::mem::swap(&mut self.adv.unlocked, &mut g.recipes_unlocked);
        std::mem::swap(&mut self.level.recipe_book, &mut g.recipe_book);
        std::mem::swap(&mut self.stats, &mut play.stats);
+        std::mem::swap(&mut self.hook, &mut play.hook);
        self.adv.loaded = adv_loaded;
        play.last_inventory = std::mem::replace(&mut self.adv.last_inventory, last_inventory);
        let stat_events = std::mem::take(&mut play.stats.events);
@@ -590,6 +595,11 @@ impl Game<'_> {
            // A teleport (commands, a pearl) moves the guest; a pearl's is
            // sent even to where they stand (ServerPlayer.teleport).
            let at = [m.position.x, m.position.y, m.position.z];
+            // A hit with extra knockback stopped the guest's sprint
+            // (Player.causeExtraKnockback's setSprinting(false)).
+            if !m.sprinting {
+                g.sprinting = false;
+            }
            m.sprinting = false;
            let teleported = std::mem::take(&mut m.teleported);
            let moved: f64 = (0..3).map(|k| (at[k] - g.position[k]).powi(2)).sum();
@@ -871,14 +881,20 @@ impl Game<'_> {
                        self.as_guest(host, conn, |g| g.drop_held(a.action == 4));
                    }
                }
+                // RELEASE_USE_ITEM: ServerPlayer.releaseUsingItem, with the
+                // hand of the item in use acting.
                6 => {
                    self.as_guest(host, conn, |g| {
-                        if let Some((slot, ticks)) = g.using.take()
-                            && g.stack_in(slot)
-                                .is_some_and(|s| &*s.item == "minecraft:bow")
-                        {
-                            g.release_bow(ticks);
-                        }
+                        let Some(hand) = g.used_hand() else {
+                            return;
+                        };
+                        g.with_hand(hand, |g| {
+                            if let Some((slot, ticks)) = g.using.take()
+                                && let Some(stack) = g.stack_in(slot).cloned()
+                            {
+                                g.release_used_item(&stack, ticks, false);
+                            }
+                        });
                    });
                }
                // SWAP_ITEM_WITH_OFFHAND: the hands swap and the item in use stops
@@ -1035,6 +1051,7 @@ impl Game<'_> {
                    g.open_ridden_mount_menu();
                });
            }
+            S::PlayerCommand(p) if p.action == 6 => self.lan_start_gliding(host, conn),
            S::ContainerButtonClick(p) => {
                self.lan_station_button(host, conn, p.container, p.button);
            }
@@ -1047,20 +1064,14 @@ impl Game<'_> {
            S::SetBeacon(p) => self.lan_station_beacon(host, conn, p.primary, p.secondary),
            S::SelectTrade(p) => self.lan_select_trade(host, conn, p.item),
            S::ContainerClose(p) if self.lan_merchant_closed(host, conn, Some(p.container)) => {
-                let g = &mut host.hub.guests[gi];
-                if let Some(c) = g.carried.take() {
-                    self.drop_guest_items(host, gi, vec![c]);
-                }
+                self.guest_carried_back(host, gi);
            }
            S::ContainerClose(p)
                if self.lan_crafting_closed(host, conn, Some(p.container))
                    || self.lan_station_closed(host, conn, Some(p.container))
                    || self.lan_mount_closed(host, conn, Some(p.container)) =>
            {
-                let g = &mut host.hub.guests[gi];
-                if let Some(c) = g.carried.take() {
-                    self.drop_guest_items(host, gi, vec![c]);
-                }
+                self.guest_carried_back(host, gi);
            }
            S::ContainerClick(p) => {
                let rules = ItemRules(self.res.items());
@@ -1076,10 +1087,7 @@ impl Game<'_> {
                    self.guest_container_closed(host, conn);
                }
                host.hub.container_closed(conn, p.container);
-                let g = &mut host.hub.guests[gi];
-                if let Some(c) = g.carried.take() {
-                    self.drop_guest_items(host, gi, vec![c]);
-                }
+                self.guest_carried_back(host, gi);
            }
            S::ChatCommand(c) => self.guest_chat_command(host, conn, &c.command),
            S::ChatCommandSigned(p) => self.guest_signed_command(host, conn, p),
@@ -1226,6 +1234,17 @@ impl Game<'_> {
        Some(out)
    }

+    /// `AbstractContainerMenu.removed`: what a closing player held on the
+    /// cursor goes back into their inventory (`placeItemBackInInventory`,
+    /// dropped only if it doesn't fit), and their client's cursor empties
+    /// with the inventory it is sent.
+    fn guest_carried_back(&mut self, host: &mut LanHost, gi: usize) {
+        if let Some(c) = host.hub.guests[gi].carried.take() {
+            self.lan_place_back(host, gi, vec![c]);
+            host.hub.send_inventory(gi);
+        }
+    }
+
    pub(super) fn drop_guest_items(&mut self, host: &LanHost, gi: usize, stacks: Vec<ItemStack>) {
        let g = &host.hub.guests[gi];
        let eye = [
@@ -1308,8 +1327,11 @@ impl Game<'_> {
            return;
        }
        if let Some(victim) = Self::pvp_victim(host, conn, id) {
-            if let Some(Some(strike)) = self.as_guest(host, conn, |g| g.pvp_strike()) {
-                self.pvp_land(host, victim, &strike);
+            if let Some(Some(strike)) = self.as_guest(host, conn, |g| g.pvp_strike())
+                && self.pvp_land(host, victim, &strike)
+                && strike.stops_sprint()
+            {
+                self.as_guest(host, conn, |g| g.stop_sprint_after_extra_knockback());
            }
            return;
        }
@@ -1691,6 +1713,17 @@ impl Game<'_> {
                        g.use_delay -= 1;
                    }
                });
+                // ServerPlayerGameMode.handleBlockBreakAction: a creative
+                // player's START breaks the block once (destroyAndAck) and
+                // leaves nothing being destroyed; its client sends no STOP.
+                // Kept, the dig broke whatever was put there next, every
+                // destroy delay, for as long as the player broke nothing else.
+                if digging.is_some()
+                    && host.hub.guests[gi].creative()
+                    && let Some(play) = host.play.get_mut(&conn)
+                {
+                    play.digging = None;
+                }
            }
            // Player.tick: a different main-hand item resets the attack
            // strength, and detectEquipmentUpdates gives the guest its modifiers.
@@ -1712,16 +1745,23 @@ impl Game<'_> {
            // PlayerAdvancements.flushDirty.
            let sleeping = host.hub.guests[gi].sleeping;
            self.as_guest(host, conn, |g| {
+                g.tick_fishing();
+                g.tick_maps();
                g.count_tick_stats(sleeping);
                g.tick_advancements();
                g.update_player_attributes();
            });
+            self.lan_map_updates(host, conn);
            host.hub.flush_progress(conn);
            self.guest_dig_feedback(host, conn);
            self.guest_pickups(host, gi);
            self.guest_orbs(host, gi);
            if host.hub.guests[gi].health <= 0.0 && !host.hub.guests[gi].dead {
                self.guest_forget_digging(host, conn);
+                // FishingHook.shouldStopFishing: its owner is dead.
+                if let Some(play) = host.play.get_mut(&conn) {
+                    play.hook = None;
+                }
            }
            let g = &mut host.hub.guests[gi];
            if g.health <= 0.0 && !g.dead {
@@ -1860,6 +1900,13 @@ impl Game<'_> {
    /// sounds are heard at the guest.
    fn guest_server_tick(&mut self, host: &mut LanHost, conn: u32) {
        self.guest_vehicle_tick(host, conn);
+        // The last move's fall stands in for the server's delta movement.
+        let fell = host
+            .hub
+            .guest_mut(conn)
+            .and_then(|g| g.moves.last().map(|m| m.0[1]))
+            .unwrap_or(0.0);
+        self.guest_glide_tick(host, conn, fell);
        let Some(g) = host.hub.guest_mut(conn) else {
            return;
        };
@@ -1883,7 +1930,7 @@ impl Game<'_> {
            let (rules, motion) = (game.world.health_rules, game.motion);
            let health = &motion.health;
            let Some(player) = game.player.as_mut() else {
-                return Vec::new();
+                return (Vec::new(), None);
            };
            let mut w = MotionWorld {
                entities: &[],
@@ -1959,22 +2006,125 @@ impl Game<'_> {
            game.border_damage();
            game.tick_mob_effects();
            let Some(player) = game.player.as_mut() else {
-                return Vec::new();
+                return (Vec::new(), None);
            };
            let _ = player.peaceful_regeneration(rules);
            let _ = player.food_tick(health, rules);
            events.append(&mut player.events);
-            events
+            let _ = MotionWorld {
+                entities: &[],
+                player,
+                scene: &mut game.world,
+                assets: &game.pack.assets,
+                collision_binding: game.collision,
+                resources: game.motion,
+            }
+            .server_travel();
+            // A hurt since the last tick marked the velocity (Entity.markHurt):
+            // ServerEntity.sendChanges sends it as it is after this travel.
+            let marked = std::mem::take(&mut player.health.sync_velocity);
+            let sounds = events
                .into_iter()
                .filter_map(|e| match e {
                    MotionEvent::HurtSound(sound) => Some(sound),
                    _ => None,
                })
-                .collect::<Vec<_>>()
+                .collect::<Vec<_>>();
+            (sounds, marked.then_some(player.velocity))
        });
-        for sound in sounds.into_iter().flatten() {
+        let Some((sounds, marked)) = sounds else {
+            return;
+        };
+        for sound in sounds {
            self.player_hurt_sound(sound, at);
        }
+        if let (Some(v), Some(g)) = (marked, host.hub.guest(conn)) {
+            g.send(&C::SetEntityMotion(play::SetEntityMotion {
+                id: g.entity_id,
+                velocity: [v.x, v.y, v.z],
+            }));
+        }
+    }
+
+    /// ServerGamePacketListenerImpl.handlePlayerCommand START_FALL_FLYING:
+    /// `Player.tryToStartFallFlying`, or else `stopFallFlying` (a second
+    /// start while gliding ends the glide, as in vanilla).
+    fn lan_start_gliding(&mut self, host: &mut LanHost, conn: u32) {
+        let Some(g) = host.hub.guest_mut(conn) else {
+            return;
+        };
+        let start = !g.fall_flying && self.guest_can_glide(host, conn) == Some(true);
+        let in_liquid = self
+            .as_guest(host, conn, |game| {
+                game.player
+                    .as_ref()
+                    .is_some_and(|p| p.fluids.was_touching_water || p.is_in_lava())
+            })
+            .unwrap_or(true);
+        if let Some(g) = host.hub.guest_mut(conn) {
+            g.fall_flying = start && !in_liquid;
+        }
+    }
+
+    /// `Player.canGlide`: not flying, airborne, not riding, no levitation, and
+    /// a glider that its next point of wear won't break.
+    fn guest_can_glide(&mut self, host: &mut LanHost, conn: u32) -> Option<bool> {
+        let g = host.hub.guest_mut(conn)?;
+        if g.flying || g.on_ground || g.vehicle.is_some() {
+            return Some(false);
+        }
+        self.as_guest(host, conn, |game| {
+            game.glider_worn() && game.potions.effects.get("levitation").is_none()
+        })
+    }
+
+    /// `LivingEntity.updateFallFlying` on the server, once a tick for a
+    /// gliding guest: the glide ends once `canGlide` fails; otherwise every
+    /// 20th tick wears the glider by one, and every 10th is an
+    /// `elytra_glide` game event. Entity.checkFallDistanceAccumulation runs
+    /// first: a glide that isn't diving keeps the fall distance at 1.
+    fn guest_glide_tick(&mut self, host: &mut LanHost, conn: u32, fell: f64) {
+        let Some(g) = host.hub.guest_mut(conn) else {
+            return;
+        };
+        if !g.fall_flying {
+            if let Some(m) = g.motion.as_mut() {
+                m.fall_fly_ticks = 0;
+            }
+            return;
+        }
+        let creative = g.creative();
+        if let Some(m) = g.motion.as_mut()
+            && fell > -0.5
+            && m.fall_distance > 1.0
+        {
+            m.fall_distance = 1.0;
+        }
+        if self.guest_can_glide(host, conn) != Some(true) {
+            if let Some(g) = host.hub.guest_mut(conn) {
+                g.fall_flying = false;
+            }
+            return;
+        }
+        self.as_guest(host, conn, |game| {
+            let Some(p) = game.player.as_mut() else {
+                return;
+            };
+            p.fall_fly_ticks += 1;
+            let next = p.fall_fly_ticks + 1;
+            let at = [p.position.x, p.position.y, p.position.z];
+            if next % 10 != 0 {
+                return;
+            }
+            if (next / 10) % 2 == 0
+                && !creative
+                && let Some(elytra) = game.armor[1].as_mut()
+            {
+                elytra.damage += 1;
+            }
+            let ctx = game.player_context(None);
+            game.post_game_event("minecraft:elytra_glide", at, ctx);
+        });
    }

    /// `Player.isInWall`: a suffocating block in the 0.48-wide box at the
@@ -78,6 +78,8 @@ pub(super) fn acts_on_player(e: &MobEvent) -> bool {
                target: Who::Player,
                ..
            }
+            | MobEvent::EffectPlayer { .. }
+            | MobEvent::AxolotlSupportPlayer
    )
 }

@@ -115,6 +117,25 @@ impl Game<'_> {
        views
    }

+    /// Runs `f` as each guest in play here, for what strikes every player in
+    /// an area (`Level.getEntities`), not only the window's own.
+    pub(super) fn each_guest_hit(&mut self, mut f: impl FnMut(&mut Self)) {
+        let Some(mut host) = self.lan.take() else {
+            return;
+        };
+        let conns: Vec<u32> = host
+            .hub
+            .guests
+            .iter()
+            .filter(|g| host.hub.here(g) && g.loaded && !g.dead)
+            .map(|g| g.conn)
+            .collect();
+        for conn in conns {
+            self.guest_hit_by(&mut host, conn, &mut f);
+        }
+        self.lan = Some(host);
+    }
+
    /// Mob events aimed at a guest, run as that guest (`guest_hit_by`).
    pub(super) fn lan_guest_mob_events(&mut self, events: Vec<(u32, MobEvent)>) {
        if events.is_empty() {
@@ -192,7 +213,9 @@ impl Game<'_> {

 impl Game<'_> {
    /// Hurt a guest: `f` runs as them, and the knockback it gave reaches
-    /// their client (`hurtMarked`: ClientboundSetEntityMotionPacket).
+    /// their client. A hurt marks the velocity (Entity.markHurt), which goes
+    /// out once the guest's server copy has travelled (`guest_server_tick`);
+    /// a push with no hurt goes out at once.
    pub(super) fn guest_hit_by<R>(
        &mut self,
        host: &mut LanHost,
@@ -202,16 +225,47 @@ impl Game<'_> {
        let (result, pushed) = self.as_guest(host, conn, |g| {
            let before = g.player.as_ref().map(|p| p.velocity);
            let result = f(g);
-            let after = g.player.as_ref().map(|p| p.velocity);
-            (result, after.filter(|v| Some(*v) != before))
+            let pushed = g
+                .player
+                .as_ref()
+                .filter(|p| !p.health.sync_velocity && Some(p.velocity) != before)
+                .map(|p| p.velocity);
+            (result, pushed)
        })?;
-        if let (Some(v), Some(g)) = (pushed, host.hub.guest(conn)) {
+        self.send_guest_motion(host, conn, pushed);
+        Some(result)
+    }
+
+    /// A player's melee hit on a guest (Player.causeExtraKnockback on a
+    /// ServerPlayer): a hurt that marked the velocity sends it at once, and
+    /// the server's copy goes back to the velocity it had before the hit.
+    pub(super) fn guest_struck_by<R>(
+        &mut self,
+        host: &mut LanHost,
+        conn: u32,
+        f: impl FnOnce(&mut Self) -> R,
+    ) -> Option<R> {
+        let (result, sent) = self.as_guest(host, conn, |g| {
+            let before = g.player.as_ref().map(|p| p.velocity);
+            let result = f(g);
+            let sent = g.player.as_mut().zip(before).and_then(|(p, before)| {
+                std::mem::take(&mut p.health.sync_velocity)
+                    .then(|| std::mem::replace(&mut p.velocity, before))
+            });
+            (result, sent)
+        })?;
+        self.send_guest_motion(host, conn, sent);
+        Some(result)
+    }
+
+    /// ClientboundSetEntityMotionPacket to a guest about themselves.
+    pub(super) fn send_guest_motion(&self, host: &LanHost, conn: u32, velocity: Option<Vec3>) {
+        if let (Some(v), Some(g)) = (velocity, host.hub.guest(conn)) {
            g.send(&C::SetEntityMotion(play::SetEntityMotion {
                id: g.entity_id,
                velocity: [v.x, v.y, v.z],
            }));
        }
-        Some(result)
    }
 }

@@ -3,7 +3,7 @@
 //! `/particle` uses) and `ClientboundExplodePacket` (`ServerLevel.explode`).
 use super::Game;
 use horizon_client::particles::{ParticleOptions, ParticleType};
-use horizon_core::random::RandomSource;
+use horizon_core::{geometry::Vec3, random::RandomSource};
 use horizon_protocol::{
    entity_data::{Particle, ParticleData},
    packets::play::{self, Clientbound as C},
@@ -154,7 +154,7 @@ impl Game<'_> {
    }

    /// `ClientPacketListener.handleExplosion`: the blast's particles (and its
-    /// sound, when the packet carries it).
+    /// sound, when the packet carries it), then the player's push.
    pub(super) fn remote_explode(&mut self, p: &play::Explode) {
        if p.play_sound {
            let pitch = (1.0
@@ -168,37 +168,88 @@ impl Game<'_> {
                pitch,
            );
        }
-        let (world, facts) = (&self.world, self.res.facts());
-        self.particles
-            .explosion(p.center, p.radius, p.block_count.max(0) as usize, &|b| {
-                facts.is_air(world.block(b[0], b[1], b[2]))
-            });
+        if let Some(options) = self.received_particle(&p.particle, p.center) {
+            self.particles.add(&options, p.center, [1.0, 0.0, 0.0]);
+        }
+        // A wind charge's burst throws none.
+        if !p.block_particles.is_empty() {
+            let (world, facts) = (&self.world, self.res.facts());
+            self.particles.explosion_blocks(
+                p.center,
+                p.radius,
+                p.block_count.max(0) as usize,
+                &|b| facts.is_air(world.block(b[0], b[1], b[2])),
+            );
+        }
+        // Entity.pushFromExplosion.
+        if let (Some(push), Some(player)) = (p.knockback, self.player.as_mut()) {
+            player.velocity = Vec3::new(
+                player.velocity.x + push[0],
+                player.velocity.y + push[1],
+                player.velocity.z + push[2],
+            );
+        }
    }

    /// `ServerLevel.explode`'s packet to each player within 64 blocks. The
    /// sound and the push reach them on their own (the level's sounds, the
-    /// players' motion), so the packet carries neither.
+    /// motion a hurt player is sent), so the packet carries neither.
    pub(super) fn lan_explode(&self, center: [f64; 3], radius: f32, block_count: usize) {
-        let Some(host) = self.lan.as_ref() else {
-            return;
-        };
-        let particle = |name: &str| {
-            Some(Particle {
-                id: host.hub.registry_id("minecraft:particle_type", name)?,
-                data: None,
-            })
-        };
        let emitter = if radius < 2.0 {
            "minecraft:explosion"
        } else {
            "minecraft:explosion_emitter"
        };
-        let (Some(at_center), Some(poof), Some(smoke)) = (
-            particle(emitter),
-            particle("minecraft:poof"),
-            particle("minecraft:smoke"),
-        ) else {
-            return;
+        let sound = "minecraft:entity.generic.explode";
+        if let Some(packet) =
+            self.explosion_packet(center, radius, block_count, emitter, sound, true)
+        {
+            self.send_explosion(packet, &[]);
+        }
+    }
+
+    /// A wind charge's burst (`AbstractWindCharge.explode`): gust emitters,
+    /// no block particles, and for each player it pushed the push
+    /// (`ServerExplosion.hitPlayers`), which only that client applies, as
+    /// nothing hurt them.
+    pub(super) fn lan_wind_burst(
+        &self,
+        center: [f64; 3],
+        radius: f32,
+        sound: &str,
+        block_count: usize,
+        pushed: &[(u32, [f64; 3])],
+    ) {
+        let emitter = if radius < 2.0 {
+            "minecraft:gust_emitter_small"
+        } else {
+            "minecraft:gust_emitter_large"
+        };
+        if let Some(packet) =
+            self.explosion_packet(center, radius, block_count, emitter, sound, false)
+        {
+            self.send_explosion(packet, pushed);
+        }
+    }
+
+    /// `ClientboundExplodePacket` without a push, or None while not serving.
+    /// The sound is the level's, which the players hear already, so it isn't
+    /// played from the packet.
+    fn explosion_packet(
+        &self,
+        center: [f64; 3],
+        radius: f32,
+        block_count: usize,
+        emitter: &str,
+        sound: &str,
+        block_particles: bool,
+    ) -> Option<play::Explode> {
+        let hub = &self.lan.as_ref()?.hub;
+        let particle = |name: &str| {
+            Some(Particle {
+                id: hub.registry_id("minecraft:particle_type", name)?,
+                data: None,
+            })
        };
        // Level.DEFAULT_EXPLOSION_BLOCK_PARTICLES.
        let info = |particle, scaling| play::ExplosionParticle {
@@ -207,22 +258,49 @@ impl Game<'_> {
            speed: 1.0,
            weight: 1,
        };
-        let packet = C::Explode(play::Explode {
+        let block_particles = if block_particles {
+            vec![
+                info(particle("minecraft:poof")?, 0.5),
+                info(particle("minecraft:smoke")?, 1.0),
+            ]
+        } else {
+            Vec::new()
+        };
+        Some(play::Explode {
            center,
            radius,
            block_count: block_count as i32,
            knockback: None,
-            particle: at_center,
-            sound: match host
-                .hub
-                .registry_id("minecraft:sound_event", "minecraft:entity.generic.explode")
-            {
+            particle: particle(emitter)?,
+            sound: match hub.registry_id("minecraft:sound_event", sound) {
                Some(id) => (id, None),
-                None => (-1, Some(("minecraft:entity.generic.explode".into(), None))),
+                None => (-1, Some((sound.into(), None))),
            },
-            block_particles: vec![info(poof, 0.5), info(smoke, 1.0)],
+            block_particles,
            play_sound: false,
-        });
-        host.hub.broadcast_near(center, 64.0, &packet, None);
+        })
+    }
+
+    /// `packet` to each player within 64 blocks of its centre, with the push
+    /// `pushed` holds for them.
+    fn send_explosion(&self, mut packet: play::Explode, pushed: &[(u32, [f64; 3])]) {
+        let Some(host) = self.lan.as_ref() else {
+            return;
+        };
+        let center = packet.center;
+        let plain = C::Explode(packet.clone()).encode();
+        for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) {
+            let d: f64 = (0..3).map(|k| (g.position[k] - center[k]).powi(2)).sum();
+            if d >= 4096.0 {
+                continue;
+            }
+            match pushed.iter().find(|(conn, _)| *conn == g.conn) {
+                Some((_, push)) => {
+                    packet.knockback = Some(*push);
+                    g.send(&C::Explode(packet.clone()));
+                }
+                None => g.sender.send(plain.clone()),
+            }
+        }
    }
 }
@@ -45,6 +45,14 @@ pub(super) struct Strike {
    team: Option<horizon_client::scoreboard::Team>,
 }

+impl Strike {
+    /// Whether it has extra knockback, which stops the attacker's sprint
+    /// once it lands (Player.causeExtraKnockback).
+    pub(super) fn stops_sprint(&self) -> bool {
+        self.knockback.0 > 0.0
+    }
+}
+
 impl Game<'_> {
    /// The guest on the host's crosshair and how far, within reach.
    pub(super) fn guest_hit(&self) -> Option<(u32, f64)> {
@@ -74,7 +82,7 @@ impl Game<'_> {
        };
        if let Some(strike) = self.pvp_strike()
            && self.pvp_land(&mut host, Victim::Guest(conn), &strike)
-            && strike.knockback.0 > 0.0
+            && strike.stops_sprint()
        {
            self.stop_sprint_after_extra_knockback();
        }
@@ -240,7 +248,7 @@ impl Game<'_> {
            && harm
            && match victim {
                Victim::Host => land(self),
-                Victim::Guest(conn) => self.guest_hit_by(host, conn, land).unwrap_or(false),
+                Victim::Guest(conn) => self.guest_struck_by(host, conn, land).unwrap_or(false),
            };
        let sound = match (hurt, s.crit, s.scale > 0.9) {
            (false, ..) => "minecraft:entity.player.attack.nodamage",
@@ -205,7 +205,9 @@ impl Game<'_> {
            return;
        };
        let [x, y, z] = p.position;
-        if !(x.is_finite() && y.is_finite() && z.is_finite())
+        if !x.is_finite()
+            || !y.is_finite()
+            || !z.is_finite()
            || !p.yaw.is_finite()
            || !p.pitch.is_finite()
        {
@@ -280,11 +280,12 @@ impl Game<'_> {
    }
    /// `thunderHit` for entities within 3 blocks (up to 9 above).
    fn thunder_hit(&mut self, b: &mut Bolt) {
-        let inside = |p: [f64; 3]| {
-            (p[0] - b.at[0]).abs() <= 3.0
-                && (p[2] - b.at[2]).abs() <= 3.0
-                && p[1] >= b.at[1] - 3.0
-                && p[1] <= b.at[1] + 9.0
+        let at = b.at;
+        let inside = move |p: [f64; 3]| {
+            (p[0] - at[0]).abs() <= 3.0
+                && (p[2] - at[2]).abs() <= 3.0
+                && p[1] >= at[1] - 3.0
+                && p[1] <= at[1] + 9.0
        };
        let damage = Damage {
            kind: DamageKind::Generic,
@@ -349,19 +350,24 @@ impl Game<'_> {
        if !events.is_empty() {
            let _ = self.handle_mob_events(events);
        }
-        if let Some(p) = self.player.as_ref().map(|p| p.position)
-            && inside([p.x, p.y, p.z])
-        {
-            if let Some(p) = self.player.as_mut() {
-                p.fire_ticks += 1;
-                if p.fire_ticks == 0
-                    && let Err(error) = p.ignite_for_ticks(160)
-                {
-                    self.error = Some(error);
+        // Every player in the box, the server's players too.
+        let strike = move |g: &mut Self| {
+            if let Some(p) = g.player.as_ref().map(|p| p.position)
+                && inside([p.x, p.y, p.z])
+            {
+                if let Some(p) = g.player.as_mut() {
+                    p.fire_ticks += 1;
+                    if p.fire_ticks == 0
+                        && let Err(error) = p.ignite_for_ticks(160)
+                    {
+                        g.error = Some(error);
+                    }
                }
+                g.hurt_player_by("minecraft:lightning_bolt", 5.0);
            }
-            self.hurt_player_by("minecraft:lightning_bolt", 5.0);
-        }
+        };
+        strike(self);
+        self.each_guest_hit(strike);
        // Dropped items burn up (ItemEntity health 5), save fire-resistant ones.
        self.dropped.retain(|e| {
            !inside([e.position.x, e.position.y, e.position.z])
@@ -4,7 +4,7 @@
 //! shading, the dithered edge), the player marker, `data/minecraft/maps/<id>.dat` and
 //! `maps/last_id.dat`, the 128x128 texture in an atlas slot, the two-handed
 //! first-person view and maps in item frames.
-use super::Game;
+use super::{Game, lan::LanHost};
 use horizon_client::{
    blocks::{Fluid, MAP_COLORS},
    hud::{MAP_SLOTS, Rect},
@@ -14,13 +14,48 @@ use horizon_client::{
 use horizon_world::nbt::Tag;
 use std::collections::HashMap;

-/// A decoration: sprite, map position (-128..127, half pixels) and rotation (0..15).
+/// A decoration: sprite, map position (-128..127, half pixels) and rotation
+/// (0..15), and the player it marks (an item's own decorations mark none).
 #[derive(Clone, Debug, PartialEq)]
 pub(super) struct Decoration {
    pub sprite: &'static str,
    pub x: i8,
    pub y: i8,
    pub rot: u8,
+    pub holder: Option<u32>,
+}
+/// The host among a map's holders (the guests are their connections).
+const HOST: u32 = u32::MAX;
+/// A player carrying a map, or seeing it framed
+/// (`MapItemSavedData.HoldingPlayer`): the column sweep's step, and what
+/// changed since the last `ClientboundMapItemDataPacket` it was sent.
+struct Holder {
+    who: u32,
+    /// The last tick it carried the map, and saw it framed.
+    carried: i64,
+    framed: i64,
+    step: i32,
+    /// The changed pixels' box (min x, min y, max x, max y).
+    dirty: Option<[i32; 4]>,
+    decorations: bool,
+    tick: u32,
+}
+impl Holder {
+    fn new(who: u32) -> Self {
+        Self {
+            who,
+            carried: 0,
+            framed: 0,
+            step: 0,
+            dirty: Some([0, 0, 127, 127]),
+            decorations: true,
+            tick: 0,
+        }
+    }
+    /// Still carrying the map, or seeing it framed (frames tick every 10).
+    fn holds(&self, now: i64) -> bool {
+        self.carried + 1 >= now || self.framed + 10 >= now
+    }
 }
 pub(super) struct MapData {
    pub center: [i32; 2],
@@ -31,8 +66,7 @@ pub(super) struct MapData {
    pub unlimited: bool,
    pub colors: Vec<u8>,
    pub decorations: Vec<Decoration>,
-    /// HoldingPlayer.step for the column sweep.
-    step: i32,
+    holders: Vec<Holder>,
    /// Changed since the last save / texture upload.
    dirty: bool,
    texture_dirty: bool,
@@ -51,7 +85,7 @@ impl MapData {
            unlimited: false,
            colors: vec![0; 128 * 128],
            decorations: Vec::new(),
-            step: 0,
+            holders: Vec::new(),
            dirty: true,
            texture_dirty: true,
        }
@@ -64,8 +98,128 @@ impl MapData {
        self.colors[i] = color;
        self.dirty = true;
        self.texture_dirty = true;
+        // setColorsDirty: every holder's next packet carries it.
+        for h in &mut self.holders {
+            h.dirty = Some(match h.dirty {
+                Some([x0, y0, x1, y1]) => [x0.min(x), y0.min(y), x1.max(x), y1.max(y)],
+                None => [x, y, x, y],
+            });
+        }
        true
    }
+    /// `tickCarriedBy`'s holder for `who`, added when new.
+    fn holder(&mut self, who: u32) -> &mut Holder {
+        let i = match self.holders.iter().position(|h| h.who == who) {
+            Some(i) => i,
+            None => {
+                self.holders.push(Holder::new(who));
+                self.holders.len() - 1
+            }
+        };
+        &mut self.holders[i]
+    }
+    /// The holders that no longer carry the map nor see it framed go, and
+    /// their markers with them (`tickCarriedBy`'s removeDecoration).
+    fn drop_holders(&mut self, now: i64) {
+        self.holders.retain(|h| h.holds(now));
+        let holders = &self.holders;
+        let before = self.decorations.len();
+        self.decorations
+            .retain(|d| d.holder.is_none_or(|w| holders.iter().any(|h| h.who == w)));
+        if self.decorations.len() != before {
+            self.decorations_changed();
+        }
+    }
+    /// setDecorationsDirty.
+    fn decorations_changed(&mut self) {
+        for h in &mut self.holders {
+            h.decorations = true;
+        }
+    }
+    /// `addDecoration` / `removeDecoration` for `holder`'s marker: in place,
+    /// so that the order (the drawing order) stays.
+    fn set_marker(&mut self, holder: u32, marker: Option<Decoration>) {
+        let i = self
+            .decorations
+            .iter()
+            .position(|d| d.holder == Some(holder));
+        let changed = match (i, marker) {
+            (Some(i), Some(d)) if self.decorations[i] == d => false,
+            (Some(i), Some(d)) => {
+                self.decorations[i] = d;
+                true
+            }
+            (Some(i), None) => {
+                self.decorations.remove(i);
+                true
+            }
+            (None, Some(d)) => {
+                self.decorations.push(d);
+                true
+            }
+            (None, None) => false,
+        };
+        if changed {
+            self.decorations_changed();
+        }
+    }
+    /// `HoldingPlayer.nextUpdatePacket` for `who`: the changed pixels, and
+    /// the decorations (at most every 5th call while they changed).
+    fn update_packet(
+        &mut self,
+        id: i32,
+        who: u32,
+        kind: impl Fn(&str) -> Option<i32>,
+    ) -> Option<horizon_protocol::packets::play::MapItemData> {
+        use horizon_protocol::packets::play::{MapDecoration, MapItemData, MapPatch};
+        let h = self.holders.iter_mut().find(|h| h.who == who)?;
+        let patch = h.dirty.take().map(|[x0, y0, x1, y1]| {
+            let (width, height) = (x1 + 1 - x0, y1 + 1 - y0);
+            let mut colors = Vec::with_capacity((width * height) as usize);
+            for y in 0..height {
+                for x in 0..width {
+                    colors.push(self.colors[(x0 + x + (y0 + y) * 128) as usize]);
+                }
+            }
+            MapPatch {
+                start_x: x0,
+                start_y: y0,
+                width,
+                height,
+                colors,
+            }
+        });
+        let decorations = if h.decorations && {
+            let due = h.tick % 5 == 0;
+            h.tick += 1;
+            due
+        } {
+            h.decorations = false;
+            Some(
+                self.decorations
+                    .iter()
+                    .filter_map(|d| {
+                        Some(MapDecoration {
+                            kind: kind(decoration_type(d.sprite)?)?,
+                            x: d.x,
+                            y: d.y,
+                            rot: d.rot as i8,
+                            name: None,
+                        })
+                    })
+                    .collect(),
+            )
+        } else {
+            None
+        };
+        (patch.is_some() || decorations.is_some()).then_some(MapItemData {
+            map_id: id,
+            scale: self.scale as i8,
+            locked: self.locked,
+            decorations,
+            patch,
+        })
+    }
    fn to_nbt(&self) -> Tag {
        let flag = |b: bool| Tag::Byte(i8::from(b));
        Tag::compound([
@@ -112,7 +266,7 @@ impl MapData {
            unlimited: int("unlimitedTracking").unwrap_or(0) != 0,
            colors,
            decorations: Vec::new(),
-            step: 0,
+            holders: Vec::new(),
            dirty: false,
            texture_dirty: true,
        })
@@ -143,36 +297,48 @@ fn packed_rgba(packed: u8) -> [u8; 4] {
 pub(super) fn map_id(stack: &ItemStack) -> Option<i32> {
    stack.data().and_then(|d| d.map_id)
 }
-/// `MapDecorationTypes`: the sprite of a decoration type that a
-/// `minecraft:map_decorations` entry can name.
+/// `MapDecorationTypes` Horizon draws: (type, sprite).
+const DECORATION_TYPES: [(&str, &str); 24] = [
+    ("player", "map/decorations/player"),
+    ("frame", "map/decorations/frame"),
+    ("red_marker", "map/decorations/red_marker"),
+    ("blue_marker", "map/decorations/blue_marker"),
+    ("target_x", "map/decorations/target_x"),
+    ("target_point", "map/decorations/target_point"),
+    ("player_off_map", "map/decorations/player_off_map"),
+    ("player_off_limits", "map/decorations/player_off_limits"),
+    ("mansion", "map/decorations/woodland_mansion"),
+    ("monument", "map/decorations/ocean_monument"),
+    ("red_x", "map/decorations/red_x"),
+    ("village_desert", "map/decorations/desert_village"),
+    ("village_plains", "map/decorations/plains_village"),
+    ("village_savanna", "map/decorations/savanna_village"),
+    ("village_snowy", "map/decorations/snowy_village"),
+    ("village_taiga", "map/decorations/taiga_village"),
+    ("jungle_temple", "map/decorations/jungle_temple"),
+    ("swamp_hut", "map/decorations/swamp_hut"),
+    ("trial_chambers", "map/decorations/trial_chambers"),
+    ("abandoned_camp", "map/decorations/abandoned_camp"),
+    ("ancient_city", "map/decorations/ancient_city"),
+    ("desert_pyramid", "map/decorations/desert_pyramid"),
+    ("mineshaft", "map/decorations/mineshaft"),
+    ("ocean_ruin_warm", "map/decorations/warm_ocean_ruins"),
+];
+/// The sprite of a decoration type that a `minecraft:map_decorations`
+/// entry or a server's packet names.
 fn decoration_sprite(id: &str) -> Option<&'static str> {
-    Some(match id.strip_prefix("minecraft:").unwrap_or(id) {
-        "player" => "map/decorations/player",
-        "frame" => "map/decorations/frame",
-        "red_marker" => "map/decorations/red_marker",
-        "blue_marker" => "map/decorations/blue_marker",
-        "target_x" => "map/decorations/target_x",
-        "target_point" => "map/decorations/target_point",
-        "player_off_map" => "map/decorations/player_off_map",
-        "player_off_limits" => "map/decorations/player_off_limits",
-        "mansion" => "map/decorations/woodland_mansion",
-        "monument" => "map/decorations/ocean_monument",
-        "red_x" => "map/decorations/red_x",
-        "village_desert" => "map/decorations/desert_village",
-        "village_plains" => "map/decorations/plains_village",
-        "village_savanna" => "map/decorations/savanna_village",
-        "village_snowy" => "map/decorations/snowy_village",
-        "village_taiga" => "map/decorations/taiga_village",
-        "jungle_temple" => "map/decorations/jungle_temple",
-        "swamp_hut" => "map/decorations/swamp_hut",
-        "trial_chambers" => "map/decorations/trial_chambers",
-        "abandoned_camp" => "map/decorations/abandoned_camp",
-        "ancient_city" => "map/decorations/ancient_city",
-        "desert_pyramid" => "map/decorations/desert_pyramid",
-        "mineshaft" => "map/decorations/mineshaft",
-        "ocean_ruin_warm" => "map/decorations/warm_ocean_ruins",
-        _ => return None,
-    })
+    let name = id.strip_prefix("minecraft:").unwrap_or(id);
+    DECORATION_TYPES
+        .iter()
+        .find(|(n, _)| *n == name)
+        .map(|(_, sprite)| *sprite)
+}
+/// The type a decoration's sprite stands for, as its registry names it.
+fn decoration_type(sprite: &str) -> Option<&'static str> {
+    DECORATION_TYPES
+        .iter()
+        .find(|(_, s)| *s == sprite)
+        .map(|(name, _)| *name)
 }
 /// `minecraft:map_decorations` of a map item: (sprite, x, z, rotation), in
 /// the component's order.
@@ -275,12 +441,29 @@ impl Game<'_> {
        }
        self.maps.data.get_mut(&id)
    }
-    /// `ClientboundMapItemDataPacket.handle`: the server's colours for a map
-    /// this client does not own (lobby map art, a framed map on a wall).
+    /// `ClientboundMapItemDataPacket.handle`: the server's colours and
+    /// decorations for a map (one carried or framed on a server).
    pub(super) fn remote_map_item_data(
        &mut self,
        p: &horizon_protocol::packets::play::MapItemData,
    ) {
+        let decorations = p.decorations.as_ref().map(|list| {
+            let types = self
+                .remote
+                .as_ref()
+                .and_then(|r| r.builtin.get("minecraft:map_decoration_type"));
+            list.iter()
+                .filter_map(|d| {
+                    Some(Decoration {
+                        sprite: decoration_sprite(types?.name(d.kind)?)?,
+                        x: d.x,
+                        y: d.y,
+                        rot: (d.rot & 15) as u8,
+                        holder: None,
+                    })
+                })
+                .collect()
+        });
        let dimension = self.dimension_id();
        let map = self
            .maps
@@ -288,6 +471,9 @@ impl Game<'_> {
            .entry(p.map_id)
            .or_insert_with(|| MapData::fresh(0.0, 0.0, p.scale.max(0) as u8, dimension));
        map.locked = p.locked;
+        if let Some(decorations) = decorations {
+            map.decorations = decorations;
+        }
        let Some(patch) = &p.patch else {
            map.dirty = false;
            return;
@@ -566,10 +752,14 @@ impl Game<'_> {
            .collect();
        let (yaw, dim) = (self.yaw, self.dimension_id());
        let (nether, game_time) = (self.dim == super::Dim::Nether, self.world.game_time);
+        // The guest whose turn it is, else the host.
+        let me = self.lan_acting.unwrap_or(HOST);
        for (id, targets) in carried {
            let Some(m) = self.map(id) else { continue };
+            m.holder(me).carried = game_time;
+            m.drop_holders(game_time);
            // tickCarriedBy: the player marker while tracking in this dimension.
-            m.decorations.clear();
+            let mut marker = None;
            if m.tracking && m.dimension == dim {
                let s = f64::from(1 << m.scale);
                let dx = ((p.x - f64::from(m.center[0])) / s) as f32;
@@ -596,18 +786,19 @@ impl Game<'_> {
                } else {
                    None
                };
-                if let Some(sprite) = sprite {
-                    m.decorations.push(Decoration {
-                        sprite,
-                        x: clamp(dx),
-                        y: clamp(dz),
-                        rot,
-                    });
-                }
+                marker = sprite.map(|sprite| Decoration {
+                    sprite,
+                    x: clamp(dx),
+                    y: clamp(dz),
+                    rot,
+                    holder: Some(me),
+                });
            }
+            m.set_marker(me, marker);
            // The item's MAP_DECORATIONS (an explorer map's target), added
            // after the players as addDecoration would.
            let s = (1 << m.scale) as f32;
+            let mut items: Vec<Decoration> = Vec::new();
            for (sprite, x, z, rotation) in targets {
                let dx = (x - f64::from(m.center[0])) as f32 / s;
                let dz = (z - f64::from(m.center[1])) as f32 / s;
@@ -620,16 +811,95 @@ impl Game<'_> {
                    x: clamp_map_coordinate(dx),
                    y: clamp_map_coordinate(dz),
                    rot: decoration_rotation(nether, game_time, f64::from(rotation)),
+                    holder: None,
                };
-                if !m.decorations.contains(&d) {
-                    m.decorations.push(d);
+                if !items.contains(&d) {
+                    items.push(d);
                }
            }
+            if !m
+                .decorations
+                .iter()
+                .filter(|d| d.holder.is_none())
+                .eq(items.iter())
+            {
+                m.decorations.retain(|d| d.holder.is_some());
+                m.decorations.extend(items);
+                m.decorations_changed();
+            }
        }
        for id in held {
            self.update_map(id);
        }
    }
+    /// The maps the player carries, for `status`: how many of their pixels
+    /// are drawn, and their decorations.
+    pub(super) fn maps_status(&self) -> Vec<serde_json::Value> {
+        self.inventory
+            .iter()
+            .chain(std::iter::once(&self.offhand))
+            .flatten()
+            .filter_map(map_id)
+            .filter_map(|id| {
+                let m = self.maps.data.get(&id)?;
+                Some(serde_json::json!({
+                    "id": id,
+                    "pixels": m.colors.iter().filter(|&&c| c != 0).count(),
+                    "decorations": m.decorations.iter().map(|d| d.sprite).collect::<Vec<_>>(),
+                }))
+            })
+            .collect()
+    }
+    /// `ServerPlayer.synchronizeSpecialItemUpdates` for each map the guest
+    /// carries, and every 10 ticks (`ServerEntity.sendChanges`) for each map
+    /// framed in the level: a `ClientboundMapItemDataPacket` when something
+    /// changed since the guest's last one.
+    pub(super) fn lan_map_updates(&mut self, host: &LanHost, conn: u32) {
+        let Some(g) = host.hub.guest(conn) else {
+            return;
+        };
+        let mut ids: Vec<i32> = g
+            .inventory
+            .iter()
+            .chain(std::iter::once(&g.offhand))
+            .flatten()
+            .filter_map(map_id)
+            .collect();
+        let now = self.world.game_time;
+        if now % 10 == 0 && host.hub.here(g) {
+            let framed: Vec<i32> = self
+                .item_frames
+                .iter()
+                .filter_map(|f| f.item.as_ref().and_then(map_id))
+                .collect();
+            for id in framed {
+                if let Some(m) = self.map(id) {
+                    m.holder(conn).framed = now;
+                    ids.push(id);
+                }
+            }
+        }
+        ids.sort_unstable();
+        ids.dedup();
+        let kind = |name: &str| {
+            host.hub.registry_id(
+                "minecraft:map_decoration_type",
+                &format!("minecraft:{name}"),
+            )
+        };
+        for id in ids {
+            if let Some(p) = self
+                .maps
+                .data
+                .get_mut(&id)
+                .and_then(|m| m.update_packet(id, conn, kind))
+            {
+                g.send(&horizon_protocol::packets::play::Clientbound::MapItemData(
+                    p,
+                ));
+            }
+        }
+    }
    /// `MapItem.update` for the player holding map `id`.
    fn update_map(&mut self, id: i32) {
        let dim = self.dimension_id();
@@ -651,8 +921,9 @@ impl Game<'_> {
        if nether {
            radius /= 2;
        }
-        m.step += 1;
-        let step = m.step;
+        let h = m.holder(self.lan_acting.unwrap_or(HOST));
+        h.step += 1;
+        let step = h.step;
        let mut changes: Vec<(i32, i32, u8)> = Vec::new();
        let mut consecutive = false;
        for img_x in px - radius + 1..px + radius {
@@ -686,40 +686,53 @@ impl Game<'_> {
            }
        }
    }
-    /// `AbstractMinecart.push(player)` when the player walks into a cart.
+    /// `AbstractMinecart.push` from each player walking into a cart
+    /// (`LivingEntity.pushEntities`): the window's player and every server
+    /// player (single player's own on its server thread, LAN guests). A
+    /// player in a vehicle pushes nothing here. The quarter push the player
+    /// gets back only moves the server's copy of it (`Entity.push` marks
+    /// `needsSync`, which `ServerEntity` sends to the other players only),
+    /// so no player feels it.
    fn push_carts(&mut self) {
-        let player = self.player.as_ref().map(|p| p.position);
-        let riding = self.riding;
-        for i in 0..self.carts.len() {
-            if Some(self.carts[i].id) == riding {
-                continue;
+        if self.carts.is_empty() {
+            return;
+        }
+        // (feet, box)
+        let mut pushers: Vec<(Vec3, Aabb)> = Vec::new();
+        if self.riding.is_none()
+            && let Some(p) = self.player.as_ref()
+        {
+            pushers.push((p.position, p.bounds()));
+        }
+        if let Some(host) = self.lan.as_ref() {
+            for g in host.hub.guests.iter().filter(|g| {
+                host.hub.here(g) && g.loaded && !g.dead && !g.spectator() && g.vehicle.is_none()
+            }) {
+                let [x, y, z] = g.position;
+                let height = if g.sneaking { 1.5 } else { 1.8 };
+                let bb = Aabb::new(
+                    Vec3::new(x - 0.3, y, z - 0.3),
+                    Vec3::new(x + 0.3, y + height, z + 0.3),
+                );
+                pushers.push((Vec3::new(x, y, z), bb));
            }
-            if let Some(pp) = player {
-                let bb = self.carts[i].bounds();
-                let (lo, hi) = (bb.min_position(), bb.max_position());
-                let touching = pp.x + 0.3 > lo.x
-                    && pp.x - 0.3 < hi.x
-                    && pp.z + 0.3 > lo.z
-                    && pp.z - 0.3 < hi.z
-                    && pp.y + 1.8 > lo.y
-                    && pp.y < hi.y;
-                if touching && riding.is_none() {
-                    let c = &mut self.carts[i];
-                    let (mut xa, mut za) = (pp.x - c.position.x, pp.z - c.position.z);
-                    let dd = xa * xa + za * za;
-                    if dd >= 1.0e-4 {
-                        let d = dd.sqrt();
-                        let pow = (1.0 / d).min(1.0);
-                        xa = xa / d * pow * f64::from(0.1f32) * 0.5;
-                        za = za / d * pow * f64::from(0.1f32) * 0.5;
-                        c.velocity.x -= xa;
-                        c.velocity.z -= za;
-                        if let Some(p) = self.player.as_mut() {
-                            p.velocity.x += xa / 4.0;
-                            p.velocity.z += za / 4.0;
-                        }
-                    }
+        }
+        for (feet, bb) in pushers {
+            for c in &mut self.carts {
+                if !bb.intersects(c.bounds()) {
+                    continue;
                }
+                let (mut xa, mut za) = (feet.x - c.position.x, feet.z - c.position.z);
+                let dd = xa * xa + za * za;
+                if dd < f64::from(1.0e-4f32) {
+                    continue;
+                }
+                let d = dd.sqrt();
+                let pow = (1.0 / d).min(1.0);
+                xa = xa / d * pow * f64::from(0.1f32) * 0.5;
+                za = za / d * pow * f64::from(0.1f32) * 0.5;
+                c.velocity.x -= xa;
+                c.velocity.z -= za;
            }
        }
    }
@@ -797,7 +810,7 @@ impl Game<'_> {
        let ridden = self.guest_vehicles();
        // By id: an exploding cart can destroy or prime others mid-loop.
        let ids: Vec<u32> = self.carts.iter().map(|c| c.id).collect();
-        for id in ids {
+        for &id in &ids {
            let Some(i) = self.carts.iter().position(|c| c.id == id) else {
                continue;
            };
@@ -823,6 +836,33 @@ impl Game<'_> {
                self.carts.remove(i);
            }
        }
+        // On the server for every cart, the ridden ones too.
+        for id in ids {
+            if let Some(i) = self.carts.iter().position(|c| c.id == id) {
+                let p = self.carts[i].position;
+                if ticking(p.x.floor() as i32, p.z.floor() as i32) {
+                    self.cart_lava_tick(id);
+                }
+            }
+        }
+    }
+    /// `lavaHurt` twice a tick in lava: from `LavaFluid.entityInside` in the
+    /// behaviour's `applyEffectsFromBlocks`, then from `AbstractMinecart.tick`'s
+    /// own `isInLava`. The second breaks the cart, or primes a TNT minecart
+    /// (`MinecartTNT.destroy` for a fire source). A cart has no `baseTick`,
+    /// so the fire `lavaIgnite` lights never burns it.
+    fn cart_lava_tick(&mut self, id: u32) {
+        for _ in 0..2 {
+            let Some(i) = self.carts.iter().position(|c| c.id == id) else {
+                return;
+            };
+            if !self.in_lava(self.carts[i].bounds()) {
+                return;
+            }
+            let p = self.carts[i].position;
+            self.hurt_cart(i, 4.0, false, true);
+            self.lava_hurt_sound([p.x, p.y, p.z]);
+        }
    }
    /// `ClientPacketListener.postAddEntitySoundInstance` for the carts that
    /// joined the level since the last tick, and `LocalPlayer.startRiding`'s
@@ -237,15 +237,7 @@ impl Game<'_> {
                    let _ = std::fs::create_dir_all(&dir);
                    super::packs::open_folder(&dir);
                }
-                Event::OpenShaderPackFolder => {
-                    let dir = horizon_client::shader_pack::folder();
-                    let _ = std::fs::create_dir_all(&dir);
-                    super::packs::open_folder(&dir);
-                }
                Event::Credits => self.open_win_screen(false, super::win::Finish::Options),
-                Event::ReloadShaderPack => {
-                    self.load_shader_pack();
-                }
            }
        }
        Ok(())
@@ -294,14 +286,6 @@ impl Game<'_> {
            font.reset_cache();
            self.ui.chat.rescale(&self.gui.atlas);
        }
-        // A new renderer (resource reload, first window) takes the loaded pack.
-        let stale = self
-            .renderer
-            .as_ref()
-            .is_some_and(|r| r.shader_pack_id() != self.shader_packs.id());
-        if stale && let Err(e) = self.apply_shader_pack() {
-            log::warn!("Horizon: shader pack: {e}");
-        }
    }
    /// `Window.updateFullscreenState`: a fullscreen change made by the window
    /// system is adopted by the option (`Minecraft.fullscreenStateChanged`).
@@ -544,7 +544,7 @@ impl Game<'_> {
    /// (`LivingEntity.forceAddEffect`): the effect replaces any of its kind.
    /// Other entities' effects are not shown.
    fn remote_effect(&mut self, p: &play::UpdateMobEffect) {
-        if !self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) {
+        if self.remote.as_ref().is_none_or(|r| r.entity_id != p.id) {
            return;
        }
        let Some(id) = self.remote_effect_id(p.effect) else {
@@ -641,6 +641,22 @@ impl Game<'_> {
                    ("mob_factor", Tag::Float(v[5].to_bits())),
                ]),
                Component::Profile(p) => profile_tag(p),
+                // ItemStackTemplate.CODEC: id, count and components.
+                Component::Stacks(stacks) => Tag::List(
+                    stacks
+                        .iter()
+                        .map(|t| {
+                            let mut entries = vec![
+                                ("id", Tag::String(self.item_name(t.item).as_ref().into())),
+                                ("count", Tag::Int(t.count)),
+                            ];
+                            if let Some(c) = self.protocol_components(t) {
+                                entries.push(("components", c));
+                            }
+                            Tag::compound(entries)
+                        })
+                        .collect(),
+                ),
                Component::CustomModelData {
                    floats,
                    flags,
@@ -1974,6 +1990,15 @@ impl Game<'_> {
                                }
                                self.sleeping = *bed;
                            }
+                            // Entity.DATA_SHARED_FLAGS_ID's sprinting bit: the
+                            // server stops the sprint after a hit's extra
+                            // knockback (the flag only, as assignValues sets
+                            // it: the speed modifier and wasSprinting stay).
+                            (0, Value::Byte(flags)) => {
+                                if let Some(pl) = self.player.as_mut() {
+                                    pl.sprinting = flags & 0x08 != 0;
+                                }
+                            }
                            // Entity.DATA_AIR_SUPPLY_ID and
                            // Player.DATA_PLAYER_ABSORPTION_ID: the bubbles
                            // and golden hearts the server's player has.
@@ -3056,7 +3081,7 @@ impl Game<'_> {
        self.sleep_timer = super::tick_sleep_timer(self.sleep_timer, self.sleeping.is_some());
        // Gui.tick: the titles, the action bar and the held item's name.
        self.tick_hud();
-        let ghast_collisions = self.happy_ghast_player_collisions();
+        let entity_collisions = self.player_entity_collisions();
        let pushed = self.remote_pushes();
        let Some(player) = self.player.as_mut() else {
            return Ok(());
@@ -3123,14 +3148,11 @@ impl Game<'_> {
            [player.position.x, player.position.y, player.position.z],
        );
        let was_flying = player.flying;
-        player.yaw = self.yaw;
-        // As the window's own tick has them: the helmet's Respiration
-        // (decreaseAirSupply) and the dimension's FAST_LAVA, the Nether's
-        // stronger lava current.
-        player.respiration = self.armor[0]
-            .as_ref()
-            .map_or(0, |s| s.enchantment_level("minecraft:respiration") as i32);
-        player.fluids.fast_lava = self.dim == Dim::Nether;
+        self.sync_player_body();
+        let Some(player) = self.player.as_mut() else {
+            return Ok(());
+        };
+        let was_gliding = player.fall_flying;
        let dead = self.screen == Screen::Dead;
        // LivingEntity.isImmobile: a sleeper lies still in the bed.
        if let Some(head) = self.sleeping {
@@ -3143,7 +3165,7 @@ impl Game<'_> {
        } else if !dead && !riding {
            player.velocity = player.velocity.add_vector(pushed);
            MotionWorld {
-                entities: &ghast_collisions,
+                entities: &entity_collisions,
                player,
                scene: &mut self.world,
                assets: &self.pack.assets,
@@ -3155,6 +3177,9 @@ impl Game<'_> {
        // LocalPlayer.onUpdateAbilities: flight turned on or off (a double
        // jump, a spectator, landing) is sent to the server.
        let flying = player.flying;
+        // LocalPlayer.aiStep: a glide this client started is sent to the
+        // server (ServerboundPlayerCommandPacket START_FALL_FLYING).
+        let started_gliding = player.fall_flying && !was_gliding;
        let events = std::mem::take(&mut player.events);
        self.previous_eye = self.eye;
        self.eye += (player.dimensions.eye_height - self.eye) * 0.5;
@@ -3194,6 +3219,14 @@ impl Game<'_> {
                flags: if flying { 2 } else { 0 },
            }));
        }
+        if started_gliding {
+            let id = self.remote.as_ref().map_or(0, |r| r.entity_id);
+            self.send(S::PlayerCommand(play::PlayerCommand {
+                id,
+                action: 6,
+                data: 0,
+            }));
+        }
        self.remote_send_state(input);
        Ok(())
    }
@@ -4017,19 +4050,55 @@ impl Game<'_> {
        if self.with_hand(hand, |g| g.remote_use_book(&held)) {
            return true;
        }
-        // BowItem.use: startUsingItem here too (with an arrow, or in creative), so that letting
-        // go sends RELEASE_USE_ITEM (Minecraft.handleKeybinds) and the server shoots.
-        if &*held.item == "minecraft:bow" {
-            self.with_hand(hand, |g| {
-                if g.using.is_none() && (g.creative || g.projectile_slot("minecraft:bow").is_some())
-                {
-                    g.using = Some((g.held_slot(), 0));
-                }
-            });
-        }
+        self.with_hand(hand, |g| g.remote_start_held_use(&held));
        item_has_use(&info)
    }

+    /// `Item.use` runs on the client too (MultiPlayerGameMode.useItem): an
+    /// item held in use until the button lets go starts being used here, so
+    /// that letting go sends RELEASE_USE_ITEM (Minecraft.handleKeybinds) and
+    /// the server ends the use: a bow or a trident is let go, a crossbow's
+    /// charge ends, a shield is lowered, a spyglass stops scoping. Their
+    /// sounds, loaded arrows and thrown tridents come from the server.
+    fn remote_start_held_use(&mut self, held: &ItemStack) {
+        if self.using.is_some() {
+            return;
+        }
+        let start = match &*held.item {
+            // BowItem.use: with an arrow, or in creative.
+            "minecraft:bow" => self.creative || self.projectile_slot("minecraft:bow").is_some(),
+            // CrossbowItem.use: charging when not charged and with ammunition;
+            // a charged one shoots on the server.
+            "minecraft:crossbow" => {
+                held.data().is_none_or(|d| d.charged.is_empty())
+                    && (self.creative || self.projectile_slot("minecraft:crossbow").is_some())
+            }
+            // TridentItem.use: not about to break, Riptide only in water or rain.
+            "minecraft:trident" => {
+                self.use_trident(held);
+                return;
+            }
+            // SpyglassItem.use (its sound is the server's).
+            "minecraft:spyglass" => true,
+            // ShieldItem.use: anything that blocks attacks, off cooldown.
+            _ => {
+                self.raise_shield(self.held_slot());
+                return;
+            }
+        };
+        if start {
+            self.using = Some((self.held_slot(), 0));
+        }
+    }
+    /// Whether `stack` stays in use until the button lets go (bows,
+    /// crossbows, tridents, spyglasses, shields): its use only counts ticks here.
+    fn held_until_released(&self, stack: &ItemStack) -> bool {
+        matches!(
+            &*stack.item,
+            "minecraft:bow" | "minecraft:crossbow" | "minecraft:trident" | "minecraft:spyglass"
+        ) || self.blocks_attacks(stack).is_some()
+    }
+
    /// The rest of Minecraft.startUseItem once the main hand's target passed:
    /// the main hand's item, then the off hand's turn (its block, its item).
    /// The server does each packet's part with that packet's hand only.
@@ -4048,7 +4117,8 @@ impl Game<'_> {
        }
        self.remote_use_item(Hand::Off);
    }
-    /// `LivingEntity.updatingUsingItem` on a server client: a drawn bow, and a
+    /// `LivingEntity.updatingUsingItem` on a server client: an item held in
+    /// use (`held_until_released`), and a
    /// consumable's eating animation and its crumbs. The server eats it and
    /// sends the stack, the hunger and the sounds.
    fn remote_tick_using(&mut self) {
@@ -4056,8 +4126,9 @@ impl Game<'_> {
            return;
        };
        let stack = self.stack_in(slot).cloned();
-        // A drawn bow: held until the button lets go (or another slot is picked).
-        if stack.as_ref().is_some_and(|s| &*s.item == "minecraft:bow") {
+        // A drawn bow, a charging crossbow, a raised shield...: held until
+        // the button lets go (or another slot is picked).
+        if stack.as_ref().is_some_and(|s| self.held_until_released(s)) {
            self.using = (slot == self.selected || slot == super::shield::OFFHAND_SLOT)
                .then_some((slot, ticks + 1));
            return;
@@ -4247,8 +4318,7 @@ impl Game<'_> {
    /// Keys with a multiplayer meaning; returns true when consumed.
    pub(super) fn remote_key(&mut self, key: KeyCode) -> Result<bool> {
        if self.screen != Screen::Playing {
-            if key == KeyCode::KeyE && self.screen == Screen::Inventory
-                || key == KeyCode::Escape && self.screen == Screen::Inventory
+            if (key == KeyCode::KeyE || key == KeyCode::Escape) && self.screen == Screen::Inventory
            {
                self.remote_close_container();
                self.screen = Screen::Playing;
@@ -88,6 +88,8 @@ impl Game<'_> {
                self.end
                    .add_remote_eye(id, position, [velocity.x, velocity.y, velocity.z])
            }
+            // FishingHook.recreateFromPacket: the owner's id is the data.
+            "minecraft:fishing_bobber" => self.spawn_remote_hook(id, at, data),
            "minecraft:end_crystal" => self.crystals.push(super::dragon::Crystal {
                id,
                position: at,
@@ -114,6 +116,7 @@ impl Game<'_> {
    /// `handleSetEntityData` for these types: what changes how they look.
    pub(super) fn remote_projectile_data(&mut self, id: i32, values: &[(u8, i32, Value)]) {
        let id = id as u32;
+        self.remote_hook_data(id, values);
        if self.potions.has_thrown(id) {
            // ThrowableItemProjectile.DATA_ITEM_STACK: the potion it is.
            for (index, _, value) in values {
@@ -205,6 +208,7 @@ impl Game<'_> {
            c.position = step(c.id, c.position);
        }
        self.potions.step_remote_thrown(&mut step);
+        self.step_remote_hooks(&mut step);
        self.end.step_remote_eyes(|id, at| {
            let at = step(id, Vec3::new(at[0], at[1], at[2]));
            [at.x, at.y, at.z]
@@ -220,6 +224,7 @@ impl Game<'_> {
        self.crystals.retain(|c| c.id != id);
        self.potions.remove_remote_thrown(id);
        self.end.remove_remote_eye(id);
+        self.remove_remote_hook(id);
    }

    /// Every one a server sent (a new connection, level or dimension).
@@ -232,6 +237,7 @@ impl Game<'_> {
        self.crystals.clear();
        self.potions.clear_thrown();
        self.end.clear_remote_eyes();
+        self.clear_remote_hooks();
    }

    /// Their kind and place, for `status`.
@@ -260,6 +266,7 @@ impl Game<'_> {
        for (id, p) in self.end.eye_positions() {
            out.push(json!({"id": id, "kind": "minecraft:eye_of_ender", "position": p}));
        }
+        out.extend(self.hooks_status());
        out
    }
 }
@@ -104,45 +104,6 @@ impl Game<'_> {
            },
        )
    }
-    /// What a shader pack's `Frame` uniform reads of the game this frame.
-    pub(super) fn shader_inputs(
-        &self,
-        camera: glam::DVec3,
-        partial_tick: f32,
-    ) -> horizon_client::gfx::ShaderInputs {
-        let (rain, thunder) = if self.dim == Dim::Overworld {
-            self.world.weather.levels(self.clock.fraction() as f32)
-        } else {
-            (0.0, 0.0)
-        };
-        let at = [camera.x, camera.y, camera.z];
-        let day = self.world.day_time;
-        let has_sky_light = self.dim == Dim::Overworld;
-        // CommonUniforms.getEyeBrightness: the camera entity's eye block.
-        let eye = self.eye_position().unwrap_or(at).map(|v| v.floor() as i32);
-        let light = self.world.light(eye[0], eye[1], eye[2]);
-        let eye_light = [light & 15, if has_sky_light { light >> 4 } else { 0 }];
-        horizon_client::gfx::ShaderInputs {
-            rain,
-            thunder,
-            submerged: match fog_type(&self.world, self.res.facts(), at, self.forward()) {
-                FogType::Atmospheric => 0,
-                FogType::Water => 1,
-                FogType::Lava => 2,
-                FogType::PowderSnow => 3,
-            },
-            dimension: match self.dim {
-                Dim::Overworld => 0,
-                Dim::Nether => -1,
-                Dim::End => 1,
-            },
-            has_sky_light,
-            moon_phase: day.div_euclid(24_000).rem_euclid(8) as u8,
-            day_fraction: (day.rem_euclid(24_000) as f32 + partial_tick) / 24_000.0,
-            partial_tick,
-            eye_light,
-        }
-    }
    /// `SkyRenderer.shouldRenderDarkDisc`: eye below the horizon (y 63) and not under water.
    pub(super) fn dark_disc(&self, camera: glam::DVec3) -> bool {
        camera.y < 63.0
@@ -1054,6 +1054,7 @@ impl Game<'_> {
            let r = &mut self.world.random;
            let bonus = r.triangle(0.0, 0.11485000000000001);
            mob.attrs.follow_range += mob.kind.follow_range * bonus;
+            mob.update_max_visited_nodes();
            let _left_handed = r.next_float() < 0.05;
            if !self.warden_fits(&mob) {
                continue;
@@ -1,131 +0,0 @@
-//! The selected Horizon shader pack (`shaderPack` in `horizon-graphics.txt`,
-//! docs/shader-packs.md): loaded from `shaderpacks/`, given to the renderer,
-//! and loaded again when the selection changes, on F3 + T, or when its files
-//! change (checked twice a second). A pack that fails leaves the last good
-//! one (or the vanilla picture) on and says why in chat.
-use super::Game;
-use horizon_client::shader_pack::{self, ShaderPack, Stamp};
-use horizon_client::text::Text;
-use horizon_shaderpack::properties::SkyDirectives;
-use std::{
-    path::PathBuf,
-    time::{Duration, Instant},
-};
-
-#[derive(Default)]
-pub(super) struct ShaderPacks {
-    /// The pack the renderer runs.
-    pack: Option<ShaderPack>,
-    /// The selection and its files at the last load, success or not.
-    selected: String,
-    stamp: Stamp,
-    checked: Option<Instant>,
-}
-
-impl ShaderPacks {
-    /// The loaded pack's folder name.
-    pub(super) fn id(&self) -> Option<&str> {
-        self.pack.as_ref().map(|p| p.id.as_str())
-    }
-    /// What a loaded Java pack changes in the vanilla sky of `dimension`
-    /// (0 overworld, -1 the Nether, 1 the End): its `sunPathRotation`, and
-    /// whether it keeps the clouds, sun and moon (Iris's sky mixins).
-    pub(super) fn java_sky(&self, dimension: i8) -> Option<(f32, SkyDirectives)> {
-        let java = self.pack.as_ref()?.java.as_ref()?;
-        let folder = &java.folders[java.folder_for(dimension)?];
-        Some((folder.directives.sun_path_rotation, java.sky))
-    }
-}
-
-pub(super) fn dir() -> PathBuf {
-    shader_pack::folder()
-}
-
-impl Game<'_> {
-    /// Load the selected pack and give it to the renderer.
-    pub(super) fn load_shader_pack(&mut self) {
-        let id = self.settings.horizon.shader_pack.clone();
-        let dir = dir();
-        let state = &mut self.shader_packs;
-        state.selected = id.clone();
-        state.checked = Some(Instant::now());
-        let pack = if id.is_empty() {
-            state.stamp = Stamp::default();
-            None
-        } else {
-            state.stamp = Stamp::of(&dir.join(&id));
-            // Java packs are told which GPU they run on.
-            let (vendor, renderer) = self.renderer.as_ref().map_or(("Unknown", ""), |r| {
-                let name = r.info.name.as_str();
-                (
-                    horizon_client::java_pack::vendor_name(r.info.vendor, name),
-                    name,
-                )
-            });
-            let values = shader_pack::load_values(&dir, &id);
-            match ShaderPack::load_any(&dir.join(&id), &values, vendor, renderer) {
-                Ok(pack) => Some(pack),
-                Err(e) => return self.shader_pack_error(&id, &e),
-            }
-        };
-        if let Some(r) = self.renderer.as_mut()
-            && let Err(e) = r.set_shader_pack(pack.as_ref(), &self.pack.render.sprite_layers)
-        {
-            return self.shader_pack_error(&id, &e.to_string());
-        }
-        self.shader_packs.pack = pack;
-        self.ui.options.shader_pack_error = None;
-    }
-    /// Give the loaded pack to the renderer (also after it is rebuilt).
-    pub(super) fn apply_shader_pack(&mut self) -> horizon_client::Result<()> {
-        match self.renderer.as_mut() {
-            Some(r) => r.set_shader_pack(
-                self.shader_packs.pack.as_ref(),
-                &self.pack.render.sprite_layers,
-            ),
-            None => Ok(()),
-        }
-    }
-    /// Every frame: a new selection or edited pack files load it again.
-    pub(super) fn poll_shader_pack(&mut self) {
-        let state = &mut self.shader_packs;
-        if self.settings.horizon.shader_pack != state.selected {
-            return self.load_shader_pack();
-        }
-        if state.selected.is_empty()
-            || state
-                .checked
-                .is_some_and(|t| t.elapsed() < Duration::from_millis(500))
-        {
-            return;
-        }
-        state.checked = Some(Instant::now());
-        if Stamp::of(&dir().join(&state.selected)) != state.stamp {
-            self.load_shader_pack();
-        }
-    }
-    /// A file dropped on the window: a shader pack while the Shader Packs
-    /// page shows (`OptionsUi::drop_shader_pack`).
-    pub(super) fn drop_shader_pack(&mut self, path: &std::path::Path) {
-        match self.ui.options.drop_shader_pack(&mut self.settings, path) {
-            Some(Ok(())) => {
-                self.settings.save(&Self::options_path());
-                self.load_shader_pack();
-            }
-            Some(Err(e)) => {
-                log::warn!("Horizon: shader pack {}: {e}", path.display());
-                self.system_message(Text::literal(format!("Shader pack: {e}")));
-            }
-            None => {}
-        }
-    }
-    fn shader_pack_error(&mut self, id: &str, error: &str) {
-        log::warn!("Horizon: shader pack {id}: {error}");
-        // The Shader Packs page says why on the pack's row: the first line,
-        // since translator errors go on with a drawn source excerpt.
-        let first = error.lines().map(str::trim).find(|l| !l.is_empty());
-        self.ui.options.shader_pack_error =
-            Some((id.to_owned(), first.unwrap_or(error).to_owned()));
-        self.system_message(Text::literal(format!("Shader pack {id}: {error}")));
-    }
-}
@@ -367,11 +367,6 @@ impl Loading {
                    let _ = std::fs::create_dir_all(&dir);
                    packs::open_folder(&dir);
                }
-                Event::OpenShaderPackFolder => {
-                    let dir = horizon_client::shader_pack::folder();
-                    let _ = std::fs::create_dir_all(&dir);
-                    packs::open_folder(&dir);
-                }
                Event::Credits => {
                    if let Some(gui) = &self.gui {
                        let name = self.options.as_ref().map_or_else(
@@ -387,9 +382,6 @@ impl Loading {
                        self.menu.win = Some((screen, Instant::now()));
                    }
                }
-                Event::ReloadShaderPack => {
-                    self.save_menu_settings();
-                }
                // The startup menu runs before the game opens a control socket.
                Event::ButtonClick | Event::CopyAgentDetails => {}
            }
@@ -455,17 +447,6 @@ impl Loading {
                }
                self.apply_menu_settings();
            }
-            WindowEvent::DroppedFile(path) => {
-                match self
-                    .menu
-                    .options
-                    .drop_shader_pack(&mut self.settings, &path)
-                {
-                    Some(Ok(())) => self.save_menu_settings(),
-                    Some(Err(e)) => log::warn!("Horizon: shader pack {}: {e}", path.display()),
-                    None => {}
-                }
-            }
            WindowEvent::RedrawRequested => self.draw(),
            WindowEvent::ModifiersChanged(modifiers) => self.menu.modifiers = modifiers.state(),
            WindowEvent::Focused(false) => {
@@ -5,34 +5,13 @@ use super::Game;
 use horizon_client::{
    gossip::{self, GossipType},
    items::ItemStack,
-    mobs::{Mob, Species, spawning, villager},
+    mobs::{Mob, Species, spawning, villager, villager_brain},
 };
-use horizon_core::{geometry::Vec3, random::RandomSource};
+use horizon_core::geometry::Vec3;

 fn block_of(p: Vec3) -> [i32; 3] {
    [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32]
 }
-/// `SpawnUtil.Strategy.LEGACY_IRON_GOLEM`: what a golem will not land on.
-fn golem_floor_ok(name: &str) -> bool {
-    !matches!(
-        name,
-        "minecraft:cobweb"
-            | "minecraft:cactus"
-            | "minecraft:glass_pane"
-            | "minecraft:conduit"
-            | "minecraft:ice"
-            | "minecraft:tnt"
-            | "minecraft:glowstone"
-            | "minecraft:beacon"
-            | "minecraft:sea_lantern"
-            | "minecraft:frosted_ice"
-            | "minecraft:tinted_glass"
-            | "minecraft:glass"
-    ) && !name.ends_with("_stained_glass_pane")
-        && !name.ends_with("_stained_glass")
-        && !name.ends_with("leaves")
-}
-
 impl Game<'_> {
    fn villager_index(&self, id: u32) -> Option<usize> {
        self.mobs
@@ -76,88 +55,46 @@ impl Game<'_> {
            return;
        };
        let now = self.world.game_time;
-        if !villager::ext(&self.mobs[i]).is_some_and(|e| e.wants_golem(now)) {
+        let Some(near) = villager::golem_summoners(&self.mobs, i, now, needed) else {
            return;
-        }
-        let at = self.mobs[i].position;
-        let nearby: Vec<usize> = self
-            .mobs
-            .iter()
-            .enumerate()
-            .filter(|(_, m)| {
-                m.species() == Species::Villager
-                    && m.alive()
-                    && (m.position.x - at.x).abs() <= 10.0
-                    && (m.position.y - at.y).abs() <= 10.0
-                    && (m.position.z - at.z).abs() <= 10.0
-            })
-            .map(|(j, _)| j)
-            .collect();
-        let wanting = nearby
-            .iter()
-            .filter(|j| villager::ext(&self.mobs[**j]).is_some_and(|e| e.wants_golem(now)))
-            .take(5)
-            .count();
-        if wanting < needed {
-            return;
-        }
-        if self.try_spawn_iron_golem(block_of(at)) {
-            for j in nearby {
-                villager::ext_mut(&mut self.mobs[j]).golem_until = now + 599;
+        };
+        if self.try_spawn_iron_golem(block_of(self.mobs[i].position)) {
+            for j in near {
+                villager_brain::golem_detected(&mut self.mobs[j], now);
            }
        }
    }
-    /// `SpawnUtil.trySpawnMob(IRON_GOLEM, ..., 10 attempts, 8 across, 6 up
-    /// and down, LEGACY_IRON_GOLEM)`.
+    /// `SpawnUtil.trySpawnMob(IRON_GOLEM, ...)`: a golem near `start`, with
+    /// the ambient sound `trySpawnMob` plays.
    fn try_spawn_iron_golem(&mut self, start: [i32; 3]) -> bool {
-        for _ in 0..10 {
-            let r = &mut self.world.random;
-            let dx = r.next_int_bound(17).unwrap_or(8) - 8;
-            let dz = r.next_int_bound(17).unwrap_or(8) - 8;
-            let (x, z) = (start[0] + dx, start[2] + dz);
-            let mut y = start[1] + 6;
-            let mut above = self.world.block(x, y, z);
-            let mut found = None;
-            for _ in 0..=12 {
-                y -= 1;
-                let here = self.world.block(x, y, z);
-                let f = self.res.facts().get(here);
-                let above_f = self.res.facts().get(above);
-                let air_or_liquid = self.res.facts().is_air(above)
-                    || above_f.fluid != horizon_client::blocks::Fluid::None;
-                let solid =
-                    self.res.mob_data().state(here).flags & horizon_client::mobs::data::SOLID != 0
-                        || f.name.as_ref() == "minecraft:powder_snow";
-                if golem_floor_ok(&f.name) && air_or_liquid && solid {
-                    found = Some(y + 1);
-                    break;
-                }
-                above = here;
-            }
-            let Some(y) = found else { continue };
-            // IronGolem.checkSpawnRules: a floor and three free blocks.
-            let free = |g: &Self, yy: i32| {
-                g.res.mob_data().state(g.world.block(x, yy, z)).flags
-                    & horizon_client::mobs::data::VALID_EMPTY_SPAWN
-                    != 0
-            };
-            if !(0..4).all(|k| free(self, y + k)) {
-                continue;
-            }
-            let at = [f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5];
-            if let Some(id) = self.spawn_mob_for("minecraft:iron_golem", at, false, true)
-                && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
-            {
-                let sound = m.kind.sounds[0];
-                if !sound.is_empty() {
-                    let at = m.center();
-                    self.audio
-                        .play(&format!("minecraft:{sound}"), Some(at), 1.0, 1.0);
-                }
-                return true;
-            }
+        let Some(kind) = self.res.mob_types().get("minecraft:iron_golem").cloned() else {
+            return false;
+        };
+        let id = self.next_entity + 1;
+        let mut random = self.world.random.clone();
+        let golem = villager::summon_golem(
+            &self.mob_world_base(&[]),
+            start,
+            &mut random,
+            |random, at, yaw| {
+                let mut m = Mob::new(id, kind.clone(), at, yaw);
+                villager::finalize_summoned_golem(&mut m, random);
+                m
+            },
+        );
+        self.world.random = random;
+        let Some(golem) = golem else {
+            return false;
+        };
+        self.next_entity = id;
+        let sound = golem.kind.sounds[0];
+        if !sound.is_empty() {
+            let at = golem.center();
+            self.audio
+                .play(&format!("minecraft:{sound}"), Some(at), 1.0, 1.0);
        }
-        false
+        self.mobs.push(golem);
+        true
    }

    /// `VillagerMakeLove.tryToGiveBirth`: both eat, a free bed within 48
@@ -22,6 +22,14 @@ const PLAYER_KNOCKBACK: f32 = 1.22;
 /// `BreezeWindCharge.RADIUS`.
 const BREEZE_RADIUS: f32 = 3.0;

+/// A burst `wind_burst` puts off until a guest's turn is over.
+pub(super) struct Burst {
+    center: [f64; 3],
+    radius: f32,
+    multiplier: f32,
+    breeze: bool,
+    wind_charge: bool,
+}
 /// `Projectile.deflect` with `ProjectileDeflection.REVERSE`.
 pub(super) fn reverse(p: &mut Projectile, jitter: f32) {
    p.velocity = Vec3::new(
@@ -196,7 +204,9 @@ impl Game<'_> {
        set.into_iter().collect()
    }
    /// `ServerExplosion.hurtEntities` for a calculator that damages nothing:
-    /// knockback scaled by distance, exposure and the multiplier.
+    /// knockback scaled by distance, exposure and the multiplier. Returns the
+    /// guests it pushed and by how much (`hitPlayers`), which their clients
+    /// apply from the burst's packet.
    fn wind_knockback(
        &mut self,
        center: [f64; 3],
@@ -204,7 +214,7 @@ impl Game<'_> {
        multiplier: f32,
        wind_charge: bool,
        blocklike: bool,
-    ) {
+    ) -> Vec<(u32, [f64; 3])> {
        let diameter = f64::from(radius * 2.0);
        let distance = |p: [f64; 3]| {
            ((p[0] - center[0]).powi(2) + (p[1] - center[1]).powi(2) + (p[2] - center[2]).powi(2))
@@ -223,42 +233,30 @@ impl Game<'_> {
                [d[0] / l, d[1] / l, d[2] / l]
            }
        };
-        let multiplier = f64::from(multiplier);
-        // The player (not a spectator; a flying creative player takes none).
-        if let Some(p) = self.player.as_ref()
-            && !self.spectator()
-        {
-            let feet = [p.position.x, p.position.y, p.position.z];
-            let dist = distance(feet) / diameter;
-            let flying = self.creative && p.flying;
-            if dist <= 1.0 && !flying {
-                let w = f64::from(p.dimensions.width) / 2.0;
-                let h = f64::from(p.dimensions.height);
-                let eye = [
-                    feet[0],
-                    feet[1] + f64::from(p.dimensions.eye_height),
-                    feet[2],
-                ];
-                let exposure = self.seen_percent(
-                    center,
-                    [feet[0] - w, feet[1], feet[2] - w],
-                    [feet[0] + w, feet[1] + h, feet[2] + w],
-                );
-                let power = (1.0 - dist) * f64::from(exposure) * multiplier;
-                let dir = direction(eye);
-                if let Some(p) = self.player.as_mut() {
-                    p.velocity = Vec3::new(
-                        p.velocity.x + dir[0] * power,
-                        p.velocity.y + dir[1] * power,
-                        p.velocity.z + dir[2] * power,
-                    );
-                    // ServerPlayer.onExplosionHit: a wind charge's burst cancels the
-                    // fall; any other burst ends the grace of the last impulse.
-                    let at = p.position;
-                    p.impulse.set_ignore_fall_damage(wind_charge, Some(at));
+        // The player, then every other player in the level (LAN guests),
+        // each swapped in as the player. In a guest's turn (a mace's wind
+        // burst) the player is that guest.
+        let own = self.wind_push_player(center, radius, multiplier, wind_charge);
+        let mut pushed: Vec<_> = self.lan_acting.zip(own).into_iter().collect();
+        if let Some(mut host) = self.lan.take() {
+            let guests: Vec<u32> = host
+                .hub
+                .guests
+                .iter()
+                .filter(|g| host.hub.here(g) && g.loaded && !g.dead)
+                .map(|g| g.conn)
+                .collect();
+            for conn in guests {
+                let push = self.as_guest(&mut host, conn, |g| {
+                    g.wind_push_player(center, radius, multiplier, wind_charge)
+                });
+                if let Some(Some(push)) = push {
+                    pushed.push((conn, push));
                }
            }
+            self.lan = Some(host);
        }
+        let multiplier = f64::from(multiplier);
        let mut mobs = std::mem::take(&mut self.mobs);
        for m in mobs.iter_mut().filter(|m| m.alive()) {
            let feet = [m.position.x, m.position.y, m.position.z];
@@ -351,6 +349,67 @@ impl Game<'_> {
            push(t.position, &mut t.velocity, self);
        }
        self.tnts = tnts;
+        pushed
+    }
+    /// `ServerExplosion.hurtEntities` for the player (not a spectator, nor a
+    /// creative player flying): the push, less with explosion knockback
+    /// resistance, and `ServerPlayer.onExplosionHit`. Returns the push.
+    fn wind_push_player(
+        &mut self,
+        center: [f64; 3],
+        radius: f32,
+        multiplier: f32,
+        wind_charge: bool,
+    ) -> Option<[f64; 3]> {
+        if self.spectator() {
+            return None;
+        }
+        let resistance = self
+            .player
+            .as_mut()
+            .and_then(|p| p.attribute("minecraft:explosion_knockback_resistance").ok())
+            .unwrap_or(0.0);
+        let creative = self.creative;
+        let p = self.player.as_ref()?;
+        let feet = [p.position.x, p.position.y, p.position.z];
+        let dist = ((feet[0] - center[0]).powi(2)
+            + (feet[1] - center[1]).powi(2)
+            + (feet[2] - center[2]).powi(2))
+        .sqrt()
+            / f64::from(radius * 2.0);
+        if dist > 1.0 || creative && p.flying {
+            return None;
+        }
+        let w = f64::from(p.dimensions.width) / 2.0;
+        let h = f64::from(p.dimensions.height);
+        let eye = [
+            feet[0] - center[0],
+            feet[1] + f64::from(p.dimensions.eye_height) - center[1],
+            feet[2] - center[2],
+        ];
+        let exposure = self.seen_percent(
+            center,
+            [feet[0] - w, feet[1], feet[2] - w],
+            [feet[0] + w, feet[1] + h, feet[2] + w],
+        );
+        let power = (1.0 - dist) * f64::from(exposure) * f64::from(multiplier) * (1.0 - resistance);
+        let l = (eye[0] * eye[0] + eye[1] * eye[1] + eye[2] * eye[2]).sqrt();
+        let push = if l < 1.0e-5 {
+            [0.0; 3]
+        } else {
+            eye.map(|d| d / l * power)
+        };
+        let p = self.player.as_mut()?;
+        p.velocity = Vec3::new(
+            p.velocity.x + push[0],
+            p.velocity.y + push[1],
+            p.velocity.z + push[2],
+        );
+        // ServerPlayer.onExplosionHit: a wind charge's burst cancels the
+        // fall; any other burst ends the grace of the last impulse.
+        let at = p.position;
+        p.impulse.set_ignore_fall_damage(wind_charge, Some(at));
+        Some(push)
    }
    /// The burst: knockback, the blocks that react, the gust and the sound.
    pub(super) fn wind_burst(
@@ -361,13 +420,27 @@ impl Game<'_> {
        breeze: bool,
        wind_charge: bool,
    ) -> Result<()> {
+        // In a guest's turn (their charge landing, their mace's burst) the
+        // host holds the other players (`as_guest`): the burst waits for the
+        // turn to end so that it reaches every player, the guest too.
+        if self.lan_acting.is_some() && self.lan.is_none() {
+            self.creatures.wind_bursts.push(Burst {
+                center,
+                radius,
+                multiplier,
+                breeze,
+                wind_charge,
+            });
+            return Ok(());
+        }
        // ServerExplosion.explode: the blast is heard first.
        let ctx = horizon_client::sculk::Context::default();
        self.post_game_event("minecraft:explode", center, ctx);
        let mut targets = self.wind_positions(center, radius);
        // ServerExplosion.shouldAffectBlocklikeEntities
        let blocklike = !breeze && !wind_charge && self.ui.rules.bool("mob_griefing");
-        self.wind_knockback(center, radius, multiplier, wind_charge, blocklike);
+        let pushed = self.wind_knockback(center, radius, multiplier, wind_charge, blocklike);
+        let block_count = targets.len();
        // Explosion.canTriggerBlocks: a breeze's charge needs mob griefing.
        if !breeze || self.ui.rules.bool("mob_griefing") {
            // Util.shuffle(list, level.random)
@@ -396,6 +469,14 @@ impl Game<'_> {
        };
        self.particles
            .add(&ParticleOptions::simple(ty), center, [1.0, 0.0, 0.0]);
+        self.lan_wind_burst(center, radius, sound, block_count, &pushed);
+        Ok(())
+    }
+    /// The bursts guests' turns put off.
+    pub(super) fn flush_wind_bursts(&mut self) -> Result<()> {
+        for b in std::mem::take(&mut self.creatures.wind_bursts) {
+            self.wind_burst(b.center, b.radius, b.multiplier, b.breeze, b.wind_charge)?;
+        }
        Ok(())
    }
    /// `BlockBehaviour.onExplosionHit` for `TRIGGER_BLOCK`: doors, gates,
@@ -35,7 +35,7 @@ fn entity_shader() -> String {
 mod entity_batch;
 mod weather;
 use entity_batch::EntityBatch;
-pub use entity_batch::WATER_MASK_OVERLAY;
+pub use entity_batch::{SHADOW_OVERLAY, WATER_MASK_OVERLAY};

 /// Window.getAppropriateLineWidth, in framebuffer pixels.
 pub fn outline_width(width: u32) -> f32 {
@@ -65,12 +65,9 @@ mod arena;
 mod cull;
 mod end_sky;
 mod flat;
-pub(crate) mod java_stages;
-pub(crate) mod java_terrain;
 pub mod lightning;
 mod lod;
 mod occlusion;
-mod pack_stages;
 mod page_runs;
 pub mod panorama;
 mod resident;
@@ -90,7 +87,6 @@ fn world_pass_after_culling<'e>(
    encoder: &'e mut wgpu::CommandEncoder,
    view: &wgpu::TextureView,
    depth: &wgpu::TextureView,
-    pack: bool,
 ) -> wgpu::RenderPass<'e> {
    encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
        label: Some("Horizon world, after culling"),
@@ -107,11 +103,7 @@ fn world_pass_after_culling<'e>(
            view: depth,
            depth_ops: Some(wgpu::Operations {
                load: wgpu::LoadOp::Load,
-                store: if pack {
-                    wgpu::StoreOp::Store
-                } else {
-                    wgpu::StoreOp::Discard
-                },
+                store: wgpu::StoreOp::Discard,
            }),
            stencil_ops: None,
        }),
@@ -279,28 +271,6 @@ pub struct Frame<'a> {
    /// `Screen.extractBlurredBackground`: blur the frame by this radius
    /// (`menuBackgroundBlurriness`) before the screen is drawn over it.
    pub menu_blur: Option<f32>,
-    /// What a shader pack's `Frame` uniform reads beyond the rest of the frame.
-    pub shader: ShaderInputs,
-}
-/// A shader pack's view of the game this frame (docs/shader-packs.md, `Frame`).
-#[derive(Clone, Copy, Debug, Default)]
-pub struct ShaderInputs {
-    /// `Level.getRainLevel` and `getThunderLevel` at the partial tick.
-    pub rain: f32,
-    pub thunder: f32,
-    /// The camera's fog type: 0 air, 1 water, 2 lava, 3 powder snow.
-    pub submerged: u8,
-    /// 0 overworld, -1 the Nether, 1 the End.
-    pub dimension: i8,
-    pub has_sky_light: bool,
-    /// `DimensionType.moonPhase`, 0..=7.
-    pub moon_phase: u8,
-    /// The time of day as a fraction (0 sunrise, 0.25 noon) and the partial tick.
-    pub day_fraction: f32,
-    pub partial_tick: f32,
-    /// The block and sky light (0..15) of the block holding the camera
-    /// entity's eyes; no sky light without a sky.
-    pub eye_light: [u8; 2],
 }
 /// One frame of the world border wall (`WorldBorderRenderer.render`).
 #[derive(Clone, Debug)]
@@ -368,14 +338,10 @@ pub struct Renderer {
    /// (`crosshair_globals`).
    crosshair_group: wgpu::BindGroup,
    crosshair_globals: wgpu::Buffer,
-    shadow_pipeline: wgpu::RenderPipeline,
-    shadow_entity_pipeline: wgpu::RenderPipeline,
-    shadow_globals: wgpu::Buffer,
-    shadow_group: wgpu::BindGroup,
-    shadow_entity_group: wgpu::BindGroup,
    entity_pipeline: wgpu::RenderPipeline,
    weather: weather::Weather,
    crumbling_pipeline: wgpu::RenderPipeline,
+    shadow_blob_pipeline: wgpu::RenderPipeline,
    /// `RenderPipelines.WATER_MASK`: depth writes only, no colour.
    water_mask_pipeline: wgpu::RenderPipeline,
    cloud_pipeline: wgpu::RenderPipeline,
@@ -490,17 +456,6 @@ pub struct Renderer {
    occlusion: occlusion::Occlusion,
    /// Resolution scale and FXAA (Horizon settings).
    world_post: world_post::Post,
-    /// The selected shader pack's stages (Horizon setting; none by default).
-    pack: Option<Pack>,
-    /// A Java pack's terrain programs (`gfx/java_terrain.rs`): their page
-    /// groups' layout, the glue's table, each arena page's group.
-    java_page_layout: wgpu::BindGroupLayout,
-    /// The device renders to and filters 16-bit normalized formats.
-    java_norm16: bool,
-    java_table: Option<wgpu::Buffer>,
-    java_pages: Vec<Option<(wgpu::Buffer, wgpu::BindGroup)>>,
-    /// The sprite layers and mip levels `animate` wrote this frame.
-    animated: Vec<(u32, u32)>,
    pub hud: HudRenderer,
    /// Vanilla's menu background blur, made on first use.
    menu_blur: Option<crate::menu_blur::MenuBlur>,
@@ -849,10 +804,7 @@ async fn open_device(
            | cull::Cull::features(&adapter)
            | (adapter.features()
                & (wgpu::Features::INDIRECT_FIRST_INSTANCE
-                    | wgpu::Features::MAPPABLE_PRIMARY_BUFFERS
-                    // Java shader packs' 16-bit colour targets.
-                    | wgpu::Features::TEXTURE_FORMAT_16BIT_NORM
-                    | wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES));
+                    | wgpu::Features::MAPPABLE_PRIMARY_BUFFERS));
        let driver = format!("{} {}", info.driver, info.driver_info);
        startup_step(format_args!(
            "requesting the device (driver {}) with features [{features}] and the adapter's \
@@ -1325,38 +1277,6 @@ impl Renderer {
            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });
-        let shadow_globals = device.create_buffer(&wgpu::BufferDescriptor {
-            label: Some("Shader pack shadow globals"),
-            size: std::mem::size_of::<Globals>() as u64,
-            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-            mapped_at_creation: false,
-        });
-        let shadow_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-            label: Some("Terrain shadow"),
-            layout: Some(&layout),
-            vertex: wgpu::VertexState {
-                module: &shader,
-                entry_point: Some("vs_terrain"),
-                compilation_options: Default::default(),
-                buffers: &terrain_buffers,
-            },
-            primitive: wgpu::PrimitiveState {
-                topology: tri,
-                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: None,
-            multiview_mask: None,
-            cache: None,
-        });
        let prepared = prepared.unwrap_or_else(|| {
            PreparedTextures::new(sprite_pixels, sprite_size, layers, sprite_mips, forcefield)
        });
@@ -1382,10 +1302,8 @@ impl Renderer {
                        sample_count: 1,
                        dimension: wgpu::TextureDimension::D2,
                        format: wgpu::TextureFormat::Rgba8Unorm,
-                        // COPY_SRC: animated sprites into a Java pack's atlas.
                        usage: wgpu::TextureUsages::TEXTURE_BINDING
                            | wgpu::TextureUsages::COPY_DST
-                            | wgpu::TextureUsages::COPY_SRC
                            | wgpu::TextureUsages::STORAGE_BINDING,
                        view_formats: &[],
                    },
@@ -1472,16 +1390,6 @@ impl Renderer {
            &lightmap_view,
            &lightmap_sampler,
        );
-        let shadow_group = terrain_group(
-            &device,
-            "Shader pack shadow terrain resources",
-            &bindings,
-            &shadow_globals,
-            &sprite_views,
-            &sprite_sampler,
-            &lightmap_view,
-            &lightmap_sampler,
-        );
        let index_quads = 1 << 16;
        let indices = Self::quad_indices(&device, index_quads);
        let instance_capacity = 4096;
@@ -1643,32 +1551,6 @@ impl Renderer {
                },
            ],
        });
-        let shadow_entity_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("Shader pack shadow entity resources"),
-            layout: &entity_bindings,
-            entries: &[
-                wgpu::BindGroupEntry {
-                    binding: 0,
-                    resource: shadow_globals.as_entire_binding(),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 1,
-                    resource: wgpu::BindingResource::TextureView(&atlas_view),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 2,
-                    resource: wgpu::BindingResource::Sampler(&atlas_sampler),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 3,
-                    resource: wgpu::BindingResource::TextureView(&lightmap_view),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 4,
-                    resource: wgpu::BindingResource::Sampler(&lightmap_sampler),
-                },
-            ],
-        });
        let entity_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("Entity layout"),
            bind_group_layouts: &[Some(&entity_bindings)],
@@ -1779,32 +1661,6 @@ impl Renderer {
                wgpu::ColorWrites::ALL,
            )
        };
-        let shadow_entity_pipeline =
-            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                label: Some("Entity shadow"),
-                layout: Some(&entity_layout),
-                vertex: wgpu::VertexState {
-                    module: &entity_shader,
-                    entry_point: Some("vs_entity"),
-                    compilation_options: Default::default(),
-                    buffers: &entity_vertex,
-                },
-                primitive: wgpu::PrimitiveState {
-                    cull_mode: None,
-                    ..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: None,
-                multiview_mask: None,
-                cache: None,
-            });
        // RenderPipelines.WATER_MASK: the boat's water patch writes depth only.
        let water_mask_pipeline = entity_pipeline_with(
            "Water mask",
@@ -1830,6 +1686,26 @@ impl Renderer {
            CRUMBLING_BLEND,
            false,
        );
+        // RenderPipelines.ENTITY_SHADOW: translucent, depth test without
+        // writes. The quads lie on the block tops like vanilla's, but the
+        // terrain under them snaps to the subpixel grid at other vertices, so
+        // at a slant their depths differ by up to 1/256 of a pixel's depth
+        // slope and whole shadows failed the test. The bias covers that and
+        // the rounding, and stays below the 0.001 a model's feet sit higher
+        // (1/27 of a pixel's slope at the 16-block shadow range in 720p).
+        let shadow_blob_pipeline = entity_pipeline(
+            "Entity shadows",
+            None,
+            false,
+            wgpu::CompareFunction::GreaterEqual,
+            wgpu::DepthBiasState {
+                constant: 16,
+                slope_scale: 0.015,
+                clamp: 0.0,
+            },
+            alpha_blend,
+            false,
+        );
        let cloud_pipeline = entity_pipeline(
            "Clouds",
            Some(wgpu::Face::Back),
@@ -2229,8 +2105,6 @@ impl Renderer {
            std::mem::size_of::<TerrainVertex>() as u64,
            1 << 20,
        );
-        let java_page_layout = java_terrain::page_layout(&device);
-        let java_norm16 = java_terrain::norm16_targets(&adapter, &device);
        // Sections as one index list per frame where multi-draw is emulated.
        let flat = flat::wanted(&adapter, &device).then(|| {
            let buffers = [Some(wgpu::VertexBufferLayout {
@@ -2341,14 +2215,10 @@ impl Renderer {
            debug_line_capacity: 4096,
            crosshair_group,
            crosshair_globals,
-            shadow_pipeline,
-            shadow_entity_pipeline,
-            shadow_globals,
-            shadow_group,
-            shadow_entity_group,
            entity_pipeline,
            weather,
            crumbling_pipeline,
+            shadow_blob_pipeline,
            water_mask_pipeline,
            cloud_pipeline,
            cloud_mesh: Default::default(),
@@ -2430,12 +2300,6 @@ impl Renderer {
            block_entity_revision: next_block_entity_revision(),
            occlusion: occlusion::Occlusion::new(crate::chunk::MIN_Y, crate::chunk::HEIGHT / 16),
            world_post,
-            pack: None,
-            java_page_layout,
-            java_norm16,
-            java_table: None,
-            java_pages: Vec::new(),
-            animated: Vec::new(),
            hud,
            menu_blur: None,
            info,
@@ -2745,122 +2609,28 @@ impl Renderer {
        first: u32,
        count: u32,
    ) {
-        self.draw_sections_with(pass, indirect, base, first, count, |_, _| {});
-    }
-    /// [`Self::draw_sections`]; `page` binds what else a page's draws need.
-    fn draw_sections_with(
-        &self,
-        pass: &mut wgpu::RenderPass<'_>,
-        indirect: &wgpu::Buffer,
-        base: u32,
-        first: u32,
-        count: u32,
-        page_group: impl Fn(&mut wgpu::RenderPass<'_>, u32),
-    ) {
+        let (draws, pages) = (&self.draws[..], &self.draw_pages[..]);
        let (mut i, end) = (first as usize, (first + count) as usize);
        while i < end {
-            let (page, index_page) = self.draw_pages[i];
-            let run = self.draw_pages[i..end]
+            let (page, index_page) = pages[i];
+            let run = pages[i..end]
                .iter()
                .take_while(|&&p| p == (page, index_page))
                .count();
            pass.set_vertex_buffer(0, self.arena.buffer(page).slice(..));
-            page_group(pass, page);
            let indices = index_page.map_or(&self.indices, |p| self.sorted_indices.buffer(p));
            pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32);
            if self.multi_draw {
                let offset = (i - base as usize) as u64 * 20;
                pass.multi_draw_indexed_indirect(indirect, offset, run as u32);
            } else {
-                for d in &self.draws[i..i + run] {
+                for d in &draws[i..i + run] {
                    pass.draw_indexed(d[2]..d[2] + d[0], d[3] as i32, d[4]..d[4] + 1);
                }
            }
            i += run;
        }
    }
-    /// Horizon's terrain, solid or `translucent`, with a Java pack's
-    /// geometry pipelines (`java_terrain::DrawTerrain`): the frame's flat
-    /// draws or its section draws, each page with its group 3.
-    fn draw_java_terrain(
-        &self,
-        pass: &mut wgpu::RenderPass<'_>,
-        translucent: bool,
-        pipelines: &java_terrain::TerrainPipelines,
-        flat_frame: bool,
-        draws: [u32; 2],
-    ) {
-        let page = |pass: &mut wgpu::RenderPass<'_>, page: u32| {
-            if let Some(Some((_, group))) = self.java_pages.get(page as usize) {
-                pass.set_bind_group(3, group, &[]);
-            }
-        };
-        pass.set_bind_group(2, pipelines.group, &[]);
-        match (self.flat.as_ref().filter(|_| flat_frame), pipelines.flat) {
-            (Some(flat), Some(pipeline)) => {
-                pass.set_pipeline(pipeline);
-                let calls = if translucent {
-                    &flat.calls[flat.solid_calls..]
-                } else {
-                    &flat.calls[..flat.solid_calls]
-                };
-                flat.draw(pass, calls, |p| self.arena.buffer(p), page);
-            }
-            (Some(_), None) => {}
-            (None, _) => {
-                pass.set_pipeline(pipelines.instanced);
-                pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
-                pass.set_vertex_buffer(1, self.instances.slice(..));
-                let [solid, translucent_draws] = draws;
-                let (first, count) = if translucent {
-                    (solid, translucent_draws)
-                } else {
-                    (0, solid)
-                };
-                self.draw_sections_with(pass, &self.indirect, 0, first, count, page);
-            }
-        }
-    }
-    /// Each arena page's group for a Java pack's terrain programs: its
-    /// vertices and the glue's table.
-    fn prepare_java_pages(&mut self) {
-        let Some(table) = &self.java_table else {
-            return;
-        };
-        let count = self.arena.page_count() as usize;
-        self.java_pages.resize_with(count, || None);
-        let limit = self.device.limits().max_storage_buffer_binding_size;
-        for page in 0..count {
-            if !self.arena.has_page(page as u32) {
-                self.java_pages[page] = None;
-                continue;
-            }
-            let buffer = self.arena.buffer(page as u32);
-            if matches!(&self.java_pages[page], Some((b, _)) if b == buffer) {
-                continue;
-            }
-            let size = buffer.size().min(limit / 4 * 4);
-            let group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
-                label: Some("Java shader pack terrain page"),
-                layout: &self.java_page_layout,
-                entries: &[
-                    wgpu::BindGroupEntry {
-                        binding: 0,
-                        resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
-                            buffer,
-                            offset: 0,
-                            size: std::num::NonZeroU64::new(size),
-                        }),
-                    },
-                    wgpu::BindGroupEntry {
-                        binding: 1,
-                        resource: table.as_entire_binding(),
-                    },
-                ],
-            });
-            self.java_pages[page] = Some((buffer.clone(), group));
-        }
-    }
    fn release_section(&mut self, key: SectionKey) {
        if let Some(s) = self.sections.remove(key) {
            self.release_mesh(s);
@@ -2943,61 +2713,6 @@ impl Renderer {
            self.release_section(key);
        }
    }
-    /// Run `pack`'s stages over the world from now on (`None`: no pack, the
-    /// vanilla frame). On error the previous pack stays. `sprite_layers`
-    /// names the block sprites, for a Java pack's `block.properties`.
-    pub fn set_shader_pack(
-        &mut self,
-        pack: Option<&crate::shader_pack::ShaderPack>,
-        sprite_layers: &std::collections::BTreeMap<String, u32>,
-    ) -> Result<()> {
-        let format = self.config.format.remove_srgb_suffix();
-        let layouts = java_stages::GeometryLayouts {
-            flat: self.flat.as_ref().map(|f| f.draw_layout()),
-            page: &self.java_page_layout,
-        };
-        let table = pack.and_then(|p| p.java.as_ref()).map(|java| {
-            let table = java_terrain::table(sprite_layers, &java.block_ids);
-            wgpu::util::DeviceExt::create_buffer_init(
-                &self.device,
-                &wgpu::util::BufferInitDescriptor {
-                    label: Some("Java shader pack terrain table"),
-                    contents: bytemuck::cast_slice(&table),
-                    usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
-                },
-            )
-        });
-        self.pack = match pack {
-            Some(pack) => Some(match &pack.java {
-                Some(java) => Pack::Java(java_stages::JavaStages::new(
-                    &self.device,
-                    &self.queue,
-                    format,
-                    &pack.id,
-                    java,
-                    &layouts,
-                    self.java_norm16,
-                )?),
-                None => Pack::Horizon(pack_stages::PackStages::new(
-                    &self.device,
-                    &self.queue,
-                    format,
-                    pack,
-                )?),
-            }),
-            None => None,
-        };
-        self.java_table = table;
-        self.java_pages.clear();
-        Ok(())
-    }
-    /// The folder name of the pack `set_shader_pack` gave.
-    pub fn shader_pack_id(&self) -> Option<&str> {
-        self.pack.as_ref().map(|p| match p {
-            Pack::Horizon(p) => p.id.as_str(),
-            Pack::Java(p) => p.id.as_str(),
-        })
-    }
    /// Horizon's resolution scale (world pixels per window pixel) and FXAA.
    pub fn set_world_post(&mut self, scale: f32, antialias: bool) {
        self.world_post.scale = scale.clamp(0.25, 2.0);
@@ -3027,16 +2742,6 @@ impl Renderer {
            &self.lightmap_view,
            &self.lightmap_sampler,
        );
-        self.shadow_group = terrain_group(
-            &self.device,
-            "Shader pack shadow terrain resources",
-            &self.terrain_layout,
-            &self.shadow_globals,
-            &views,
-            &self.sprite_sampler,
-            &self.lightmap_view,
-            &self.lightmap_sampler,
-        );
    }
    pub fn view_projection(&self, frame: &Frame) -> Mat4 {
        self.projection(
@@ -3129,15 +2834,6 @@ impl Renderer {
    }
    fn animate(&mut self, encoder: &mut wgpu::CommandEncoder, tick: u64) {
        self.animations.animate(encoder, &mut self.uploads, tick);
-        // A Java pack's atlas copies what changed, every level.
-        let levels = self.mip_levels;
-        self.animated.clear();
-        self.animated.extend(
-            self.animations
-                .changed
-                .iter()
-                .flat_map(|&layer| (0..levels).map(move |level| (layer, level))),
-        );
    }
    pub fn render(&mut self, frame: &Frame) -> Result<bool> {
        let rendered = self.draw_frame(frame);
@@ -3309,15 +3005,6 @@ impl Renderer {
        };
        self.uploads
            .buffer(&mut encoder, &self.globals, 0, bytemuck::bytes_of(&globals));
-        let pack_uniform = shader_pack_uniform(
-            frame,
-            view,
-            world_projection(frame.fov_degrees, aspect, frame.depth_far) * frame.bob,
-            sun,
-            fog_color,
-            globals.fog,
-            globals.fog_ends,
-        );
        // GameRenderer.render3dHud: the hand's projection at hudFov, with the
        // bob in its pose rather than the projection (same product).
        let hand_projection = Mat4::from_cols_array(&crate::camera::hand_projection(
@@ -3388,8 +3075,9 @@ impl Renderer {
            visible_lods.sort_unstable_by_key(|v| (v.distance, v.key));
        }
        self.drawn_sections = visible.len() + visible_lods.len();
-        if self.drawn_sections as u64 > self.instance_capacity {
-            self.instance_capacity = (self.drawn_sections as u64).next_power_of_two();
+        let instances = self.drawn_sections;
+        if instances as u64 > self.instance_capacity {
+            self.instance_capacity = (instances as u64).next_power_of_two();
            self.instances = self.device.create_buffer(&wgpu::BufferDescriptor {
                label: Some("Section origins"),
                size: self.instance_capacity * 16,
@@ -3422,12 +3110,6 @@ impl Renderer {
        let eye = (frame.bob * crate::camera::view_matrix(frame.yaw, frame.pitch))
            .inverse()
            .transform_point3(Vec3::ZERO);
-        // A Java pack that draws the terrain (`gfx/java_terrain.rs`): the
-        // world pass leaves it out, and occlusion culling (which tests
-        // against its depth) is off.
-        let java_terrain = !frame.title
-            && self.java_table.is_some()
-            && matches!(&self.pack, Some(Pack::Java(j)) if j.draws_terrain(frame.shader.dimension));
        // Occlusion culling leaves the sections its last result did not see
        // to phase 2, after the others, with instance counts of 0. Whether
        // the frame has draws enough goes by the last one's.
@@ -3435,11 +3117,7 @@ impl Renderer {
            .cull
            .as_mut()
            .filter(|c| {
-                self.cull_on
-                    && !frame.title
-                    && self.multi_draw
-                    && self.section_draws >= c.min_draws
-                    && !java_terrain
+                self.cull_on && !frame.title && self.multi_draw && self.section_draws >= c.min_draws
            })
            .and_then(|cull| cull.begin(&self.device).then_some(cull));
        self.phase2_draws.clear();
@@ -3670,6 +3348,7 @@ impl Renderer {
            crumbling_quads,
            translucent_crumbling_quads,
            water_mask_quads,
+            shadow_quads,
        ] = self.entity_batch.update(
            frame.entities,
            frame.additive,
@@ -3677,8 +3356,11 @@ impl Renderer {
            frame.see_through,
        );
        let weather_quads = frame.weather.len() as u32 / 4;
-        let world_quads =
-            entity_quads + crumbling_quads + translucent_crumbling_quads + water_mask_quads;
+        let world_quads = entity_quads
+            + crumbling_quads
+            + translucent_crumbling_quads
+            + water_mask_quads
+            + shadow_quads;
        let cloud_quads = if let Some(input) = &frame.clouds {
            let (rebuilt, uniform) =
                crate::spans::time("clouds", || self.cloud_mesh.prepare(input));
@@ -3889,14 +3571,6 @@ impl Renderer {
                bytemuck::cast_slice(&self.draws),
            );
        }
-        if java_terrain {
-            self.prepare_java_pages();
-            if let Some(table) = &self.java_table {
-                let nether = i32::from(frame.shader.dimension == -1);
-                self.queue
-                    .write_buffer(table, 4, bytemuck::bytes_of(&nether));
-            }
-        }
        let view_target = target_texture.create_view(&wgpu::TextureViewDescriptor {
            format: Some(self.config.format.remove_srgb_suffix()),
            ..Default::default()
@@ -3905,44 +3579,9 @@ impl Renderer {
            timer.begin(&mut encoder);
        }
        // The world's targets: the screen, or the scaled target of `post`.
-        let pack = self.pack.is_some() && !frame.title;
-        // What the pack reads beyond the world's colour and depth: each costs
-        // a pass (the shadow map, the G-buffer) or a copy (the opaque depth).
-        let (shadow_cfg, gbuffer, opaque_depth) = match self.pack.as_ref().filter(|_| pack) {
-            Some(Pack::Horizon(s)) => (
-                s.needs_shadow.then_some((s.shadow_res, s.shadow_dist)),
-                s.needs_gbuffer,
-                s.needs_opaque_depth,
-            ),
-            Some(Pack::Java(s)) => (None, false, s.reads_opaque_depth),
-            None => (None, false, false),
-        };
-        if let Some((shadow_res, shadow_dist)) = shadow_cfg {
-            self.world_post
-                .prepare_shadow(&self.device, shadow_res, shadow_dist, sun, -sun);
-            let shadow_globals = Globals {
-                view_proj: (self.world_post.shadow_proj * self.world_post.shadow_view)
-                    .to_cols_array_2d(),
-                ..globals
-            };
-            self.uploads.buffer(
-                &mut encoder,
-                &self.shadow_globals,
-                0,
-                bytemuck::bytes_of(&shadow_globals),
-            );
-        } else {
-            self.world_post.shadow_active = false;
-        }
-        let scaled = self.world_post.prepare(
-            &self.device,
-            [self.config.width, self.config.height],
-            pack,
-            world_post::Extras {
-                opaque_depth,
-                gbuffer,
-            },
-        );
+        let scaled = self
+            .world_post
+            .prepare(&self.device, [self.config.width, self.config.height]);
        let (world_view, world_depth) = match &scaled {
            Some((color, depth)) => (color, depth),
            None => (&view_target, &self.depth),
@@ -3951,36 +3590,6 @@ impl Renderer {
            cull.bind_depth(&self.device, world_depth);
        }
        let cull = self.cull.as_ref().filter(|_| culling && solid_draws > 0);
-        if shadow_cfg.is_some() {
-            let shadow_view = self.world_post.shadow_depth().clone();
-            let mut shadow_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                label: Some("Horizon shadow"),
-                color_attachments: &[],
-                depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
-                    view: &shadow_view,
-                    depth_ops: Some(wgpu::Operations {
-                        load: wgpu::LoadOp::Clear(0.0),
-                        store: wgpu::StoreOp::Store,
-                    }),
-                    stencil_ops: None,
-                }),
-                ..Default::default()
-            });
-            if solid_draws > 0 && !flat_frame {
-                shadow_pass.set_bind_group(0, &self.shadow_group, &[]);
-                shadow_pass.set_pipeline(&self.shadow_pipeline);
-                shadow_pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
-                shadow_pass.set_vertex_buffer(1, self.instances.slice(..));
-                self.draw_sections(&mut shadow_pass, &self.indirect, 0, 0, solid_draws);
-            }
-            if entity_quads > 0 {
-                shadow_pass.set_pipeline(&self.shadow_entity_pipeline);
-                shadow_pass.set_bind_group(0, &self.shadow_entity_group, &[]);
-                shadow_pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
-                shadow_pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
-                shadow_pass.draw_indexed(0..entity_quads * 6, 0, 0..1);
-            }
-        }
        {
            let attachments = [Some(wgpu::RenderPassColorAttachment {
                view: world_view,
@@ -4009,9 +3618,8 @@ impl Renderer {
                    view: world_depth,
                    depth_ops: Some(wgpu::Operations {
                        load: wgpu::LoadOp::Clear(0.0),
-                        // A shader pack reads the world's depth, and
-                        // phase 2 of occlusion culling draws over it.
-                        store: if pack || cull.is_some() {
+                        // Phase 2 of occlusion culling draws over it.
+                        store: if cull.is_some() {
                            wgpu::StoreOp::Store
                        } else {
                            wgpu::StoreOp::Discard
@@ -4058,7 +3666,6 @@ impl Renderer {
                }
            }
            match self.flat.as_ref().filter(|_| flat_frame) {
-                _ if java_terrain => {}
                Some(flat) => {
                    pass.set_pipeline(&flat.solid);
                    let vertices = |p| self.arena.buffer(p);
@@ -4066,32 +3673,17 @@ impl Renderer {
                        // As below: phase 1, the test, then phase 2's draws
                        // that the test saw, copied after it.
                        Some(cull) => {
-                            flat.draw(
-                                &mut pass,
-                                &flat.calls[..flat.phase1_calls],
-                                vertices,
-                                |_, _| {},
-                            );
+                            flat.draw(&mut pass, &flat.calls[..flat.phase1_calls], vertices);
                            cull.test(&mut pass);
                            drop(pass);
                            cull.test_pass(&mut encoder);
                            flat.flatten_phase2(&mut encoder);
-                            pass = world_pass_after_culling(
-                                &mut encoder,
-                                world_view,
-                                world_depth,
-                                pack,
-                            );
+                            pass = world_pass_after_culling(&mut encoder, world_view, world_depth);
                            pass.set_bind_group(0, &self.group, &[]);
                            pass.set_pipeline(&flat.solid);
                            flat.draw_phase2(&mut pass, vertices);
                        }
-                        None => flat.draw(
-                            &mut pass,
-                            &flat.calls[..flat.solid_calls],
-                            vertices,
-                            |_, _| {},
-                        ),
+                        None => flat.draw(&mut pass, &flat.calls[..flat.solid_calls], vertices),
                    }
                    pass.set_bind_group(0, &self.group, &[]);
                    pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
@@ -4110,12 +3702,7 @@ impl Renderer {
                            cull.test(&mut pass);
                            drop(pass);
                            cull.test_pass(&mut encoder);
-                            pass = world_pass_after_culling(
-                                &mut encoder,
-                                world_view,
-                                world_depth,
-                                pack,
-                            );
+                            pass = world_pass_after_culling(&mut encoder, world_view, world_depth);
                            pass.set_bind_group(0, &self.group, &[]);
                            pass.set_pipeline(&self.solid);
                            pass.set_index_buffer(
@@ -4151,6 +3738,17 @@ impl Renderer {
                pass.draw_indexed(0..crumbling_quads * 6, (entity_quads * 4) as i32, 0..1);
                pass.set_bind_group(0, &self.group, &[]);
            }
+            if shadow_quads > 0 {
+                pass.set_pipeline(&self.shadow_blob_pipeline);
+                pass.set_bind_group(0, &self.entity_group, &[]);
+                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
+                pass.draw_indexed(
+                    0..shadow_quads * 6,
+                    ((world_quads - shadow_quads) * 4) as i32,
+                    0..1,
+                );
+                pass.set_bind_group(0, &self.group, &[]);
+            }
            // BoatRenderer's water patch (RenderTypes.waterMask): depth only,
            // before translucent terrain, so no water shows inside the boat.
            if water_mask_quads > 0 {
@@ -4192,43 +3790,12 @@ impl Renderer {
                pass.set_vertex_buffer(0, self.debug_line_buffer.slice(..));
                pass.draw(0..4, debug_depth..debug_depth + debug_top);
            }
-            if opaque_depth {
-                drop(pass);
-                self.world_post.capture_opaque_depth(&mut encoder);
-                let attachments = [Some(wgpu::RenderPassColorAttachment {
-                    view: world_view,
-                    resolve_target: None,
-                    depth_slice: None,
-                    ops: wgpu::Operations {
-                        load: wgpu::LoadOp::Load,
-                        store: wgpu::StoreOp::Store,
-                    },
-                })];
-                pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                    label: Some("Horizon world, translucent"),
-                    color_attachments: &attachments,
-                    depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
-                        view: world_depth,
-                        depth_ops: Some(wgpu::Operations {
-                            load: wgpu::LoadOp::Load,
-                            store: wgpu::StoreOp::Store,
-                        }),
-                        stencil_ops: None,
-                    }),
-                    ..Default::default()
-                });
-                pass.set_bind_group(0, &self.group, &[]);
-            }
            match self.flat.as_ref().filter(|_| flat_frame) {
-                _ if java_terrain => {}
                Some(flat) => {
                    pass.set_pipeline(&flat.translucent);
-                    flat.draw(
-                        &mut pass,
-                        &flat.calls[flat.solid_calls..],
-                        |p| self.arena.buffer(p),
-                        |_, _| {},
-                    );
+                    flat.draw(&mut pass, &flat.calls[flat.solid_calls..], |p| {
+                        self.arena.buffer(p)
+                    });
                    pass.set_bind_group(0, &self.group, &[]);
                    pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
                }
@@ -4294,67 +3861,7 @@ impl Renderer {
                );
            }
        }
-        if gbuffer && scaled.is_some() {
-            self.world_post.build_gbuffer(
-                &self.queue,
-                &mut encoder,
-                &pack_uniform,
-                frame.shader.eye_light,
-                frame.shader.rain,
-            );
-        }
-        if pack
-            && let (Some((color, depth)), Some(size)) = (&scaled, self.world_post.size())
-            && let Some(mut stages) = self.pack.take()
-        {
-            // The pack's terrain programs draw with the frame's draws.
-            let draws = [solid_draws, translucent_draws];
-            let draw = |render: &mut wgpu::RenderPass<'_>,
-                        translucent: bool,
-                        pipelines: &java_terrain::TerrainPipelines| {
-                self.draw_java_terrain(render, translucent, pipelines, flat_frame, draws);
-            };
-            let world = java_terrain::JavaWorld {
-                sprites: &self.sprite_textures,
-                split: sprite_split(),
-                levels: self.mipmaps,
-                animated: &self.animated,
-                lightmap: &self.lightmap_view,
-                draw: &draw,
-            };
-            let output = match &mut stages {
-                Pack::Horizon(stages) => stages.run(
-                    &self.device,
-                    &self.queue,
-                    &mut encoder,
-                    color,
-                    depth,
-                    size,
-                    &self.world_post,
-                    pack_uniform,
-                    frame.shader.eye_light,
-                ),
-                Pack::Java(stages) => stages.run(
-                    &self.device,
-                    &self.queue,
-                    &mut encoder,
-                    color,
-                    depth,
-                    size,
-                    &self.world_post,
-                    pack_uniform,
-                    java_stages::JavaFrame {
-                        eye_light: frame.shader.eye_light,
-                        sun_angle: frame.sky.sun_angle,
-                        moon_angle: frame.sky.moon_angle,
-                    },
-                    java_terrain.then_some(&world),
-                ),
-            };
-            self.world_post
-                .finish_with(&mut encoder, &view_target, output);
-            self.pack = Some(stages);
-        } else if scaled.is_some() {
+        if scaled.is_some() {
            self.world_post.finish(&mut encoder, &view_target);
        }
        if hand_quads > 0 {
@@ -4682,66 +4189,6 @@ impl Frustum {
 /// Vanilla's `Projection`: reversed depth (near maps to 1, far to 0, tests
 /// are GREATER_THAN_OR_EQUAL), which keeps far faces a hair apart, like
 /// fire_side's 0.01 pixel in front of its block, from z-fighting.
-/// The prelude's `Frame` (`shader_pack_prelude.wgsl`); `resolution` and the
-/// time are filled per stage.
-fn shader_pack_uniform(
-    frame: &Frame,
-    view: Mat4,
-    projection: Mat4,
-    sun: Vec3,
-    fog_color: [f32; 4],
-    fog: [f32; 4],
-    fog_ends: [f32; 4],
-) -> pack_stages::FrameUniform {
-    let s = frame.shader;
-    let sky = frame.sky.sky_color;
-    pack_stages::FrameUniform {
-        view: view.to_cols_array_2d(),
-        projection: projection.to_cols_array_2d(),
-        inverse_view: view.inverse().to_cols_array_2d(),
-        inverse_projection: projection.inverse().to_cols_array_2d(),
-        camera_position: [
-            frame.camera.x as f32,
-            frame.camera.y as f32,
-            frame.camera.z as f32,
-            0.0,
-        ],
-        time: [0.0, 0.0, s.day_fraction, s.partial_tick],
-        sun: [sun.x, sun.y, sun.z, frame.sky.sun_angle.to_radians()],
-        moon: [-sun.x, -sun.y, -sun.z, f32::from(s.moon_phase)],
-        sky_color: [sky[0], sky[1], sky[2], 1.0],
-        fog_color,
-        fog: [fog[0], fog[1], fog_ends[0], fog_ends[1]],
-        weather: [s.rain, s.thunder, 0.0, 0.0],
-        camera_state: [
-            f32::from(s.submerged),
-            frame.night_vision,
-            frame.darkness.1,
-            0.0,
-        ],
-        view_params: [
-            0.05,
-            frame.depth_far,
-            frame.distance,
-            frame.fov_degrees.to_radians(),
-        ],
-        dimension: [
-            f32::from(s.dimension),
-            f32::from(u8::from(s.has_sky_light)),
-            0.0,
-            0.0,
-        ],
-        ..Default::default()
-    }
-}
-
-/// The selected shader pack on the GPU: a Horizon pack's WGSL stages, or a
-/// Java pack's translated programs.
-enum Pack {
-    Horizon(pack_stages::PackStages),
-    Java(java_stages::JavaStages),
-}
-
 /// The section the camera is in.
 fn camera_section(camera: DVec3) -> SectionKey {
    (
@@ -4826,14 +4273,14 @@ mod tests {
                normal: [0; 4],
            }; 4]
        };
-        let entities: Vec<_> = [(0, 0), (4, 1), (11, 2), (7, 3), (4, 4), (12, 7)]
+        let entities: Vec<_> = [(0, 0), (14, 9), (4, 1), (11, 2), (7, 3), (4, 4), (12, 7)]
            .into_iter()
            .flat_map(|(layer, id)| quad(layer, id))
            .collect();
        let mut batch = super::EntityBatch::default();
        let counts = batch.update(&entities, &quad(3, 5), &quad(0, 6), &quad(0, 8));
        let vertices = &batch.combined;
-        assert_eq!(counts, [4, 1, 1, 0]);
+        assert_eq!(counts, [4, 1, 1, 0, 1]);
        assert_eq!(
            vertices
                .as_chunks::<4>()
@@ -4841,7 +4288,7 @@ mod tests {
                .iter()
                .map(|q| q[0].light)
                .collect::<Vec<_>>(),
-            [0, 1, 3, 4, 2, 7, 5, 6, 8]
+            [0, 1, 3, 4, 2, 7, 9, 5, 6, 8]
        );
    }
    #[test]
@@ -4887,11 +4334,7 @@ mod tests {
        );
        assert!(files.len() >= 10, "{files:?}");
        for path in files {
-            let mut text = std::fs::read_to_string(&path).unwrap();
-            // Api 2's prelude follows api 1's (`shader_pack::ShaderPack::load`).
-            if path.ends_with("shader_pack_prelude_api2.wgsl") {
-                text = format!("{}\n{text}", crate::shader_pack::PRELUDE);
-            }
+            let text = std::fs::read_to_string(&path).unwrap();
            // entity.wgsl comes after the overlay's constants (entity_shader).
            let module = naga::front::wgsl::parse_str(&text)
                .or_else(|_| {
@@ -51,9 +51,6 @@ pub(super) struct SpriteAnimator {
    pipeline: wgpu::ComputePipeline,
    /// Edge of the arrays' layers.
    size: u32,
-    /// The sprite layers (across the arrays) the last `animate` rewrote, at
-    /// every mip level: a Java pack's atlas copies them.
-    pub changed: Vec<u32>,
 }

 impl SpriteAnimator {
@@ -208,7 +205,6 @@ impl SpriteAnimator {
            jobs,
            pipeline,
            size,
-            changed: Vec::new(),
        }
    }

@@ -220,7 +216,6 @@ impl SpriteAnimator {
        uploads: &mut Uploads,
        tick: u64,
    ) {
-        self.changed.clear();
        if self.collect(tick) == 0 {
            return;
        }
@@ -256,7 +251,6 @@ impl SpriteAnimator {
                continue;
            }
            sprite.shown = Some(blend);
-            self.changed.push(sprite.animation.layer);
            let job = [
                sprite.layer,
                sprite.frames[blend.frame],
@@ -65,11 +65,8 @@ pub struct Arena {
 }

 impl Arena {
-    /// Vertices; also storage, which a Java shader pack's terrain programs
-    /// read a quad's corners from (`gfx/java_terrain.rs`).
    pub fn new(device: &wgpu::Device, stride: u64, capacity: u64) -> Self {
-        let usage = wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::STORAGE;
-        Self::with_usage(device, stride, capacity, usage)
+        Self::with_usage(device, stride, capacity, wgpu::BufferUsages::VERTEX)
    }
    /// Sorted translucent indices; `storage` when compute passes read them.
    pub fn indices(device: &wgpu::Device, capacity: u64, storage: bool) -> Self {
@@ -148,10 +145,6 @@ impl Arena {
    pub fn page_vertices(&self) -> u64 {
        self.page_limit
    }
-    /// One past the last page index.
-    pub fn page_count(&self) -> u32 {
-        self.pages.len() as u32
-    }
    pub fn has_page(&self, page: u32) -> bool {
        self.pages.get(page as usize).is_some_and(Option::is_some)
    }
@@ -261,16 +261,18 @@ impl Cull {
            bind_group_layouts: &[Some(&layout), depth_layout.as_ref()],
            ..Default::default()
        });
-        // In the shader: no colour target, and phase 1's depth attached read
-        // only (a pass needs an attachment), its test left to the shader.
+        // In the shader (`InShader`): no colour target, and the depth
+        // attached read only (a pass needs an attachment), its test left to
+        // the shader.
+        let color_target = [Some(wgpu::ColorTargetState {
+            format: color,
+            blend: None,
+            write_mask: wgpu::ColorWrites::empty(),
+        })];
        let (fragment_entry, targets, depth_compare) = match depth_test {
            DepthTest::Early => (
                "fs_box_early",
-                &[Some(wgpu::ColorTargetState {
-                    format: color,
-                    blend: None,
-                    write_mask: wgpu::ColorWrites::empty(),
-                })][..],
+                &color_target[..],
                wgpu::CompareFunction::GreaterEqual,
            ),
            DepthTest::InShader => ("fs_box", &[][..], wgpu::CompareFunction::Always),
@@ -2,11 +2,14 @@
 use super::Vertex;

 /// Entity materials by a quad's overlay (`Vertex::layer`), in draw order:
-/// ordinary entities, breaking cracks (11), translucent breaking cracks (12)
-/// and the boat water mask (13, `RenderPipelines.WATER_MASK`).
-const MATERIALS: usize = 4;
+/// ordinary entities, breaking cracks (11), translucent breaking cracks (12),
+/// the boat water mask (13, `RenderPipelines.WATER_MASK`) and entity shadows
+/// (14, `RenderPipelines.ENTITY_SHADOW`).
+const MATERIALS: usize = 5;
 /// The overlay of depth-only quads that hide water (`RenderTypes.waterMask`).
 pub const WATER_MASK_OVERLAY: u32 = 13;
+/// The overlay of entity shadow quads (`RenderTypes.entityShadow`).
+pub const SHADOW_OVERLAY: u32 = 14;

 #[derive(Default)]
 pub(super) struct EntityBatch {
@@ -37,6 +40,7 @@ impl EntityBatch {
                11 => 1,
                12 => 2,
                WATER_MASK_OVERLAY => 3,
+                SHADOW_OVERLAY => 4,
                _ => 0,
            };
            self.buckets[material][counts[material]] = index;
@@ -88,12 +92,13 @@ mod tests {
    ) -> (Vec<Vertex>, [u32; MATERIALS]) {
        let mut combined = Vec::with_capacity(entities.len() + additive.len() + hand.len());
        let mut counts = [0; MATERIALS];
-        for (i, layer) in [0, 11, 12, 13].into_iter().enumerate() {
+        for (i, layer) in [0, 11, 12, 13, 14].into_iter().enumerate() {
            for quad in entities.as_chunks::<4>().0 {
                let material = match quad[0].layer {
                    11 => 11,
                    12 => 12,
                    13 => 13,
+                    14 => 14,
                    _ => 0,
                };
                if material == layer {
@@ -113,7 +118,7 @@ mod tests {
                pos: [index as f32, 2.0, 3.0],
                uv: [index as f32, 5.0],
                layer: if mixed {
-                    [7, 11, 12, 4, 13, 0][index / 4 % 6]
+                    [7, 11, 14, 12, 4, 13, 0][index / 4 % 7]
                } else {
                    0
                },
@@ -640,26 +640,18 @@ impl Flat {
        pass.set_bind_group(0, group, &[]);
        pass.dispatch_workgroups((*count).min(GROUP_LIMIT), count.div_ceil(GROUP_LIMIT), 1);
    }
-    /// The bind group layout of the draws' group 1 (block slots, slot
-    /// origins).
-    pub fn draw_layout(&self) -> &wgpu::BindGroupLayout {
-        &self.draw_layout
-    }

    /// Draws `calls` with a flat pipeline set and `vertices` giving each
-    /// page's vertex buffer; `page` binds what else a page's draws need (a
-    /// Java pack's terrain reads the page's vertices).
+    /// page's vertex buffer.
    pub fn draw<'a>(
        &self,
        pass: &mut wgpu::RenderPass<'_>,
        calls: &[Call],
        vertices: impl Fn(u32) -> &'a wgpu::Buffer,
-        page: impl Fn(&mut wgpu::RenderPass<'_>, u32),
    ) {
        pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
        for call in calls {
            self.bind_page(pass, call.page, &vertices);
-            page(pass, call.page);
            pass.draw_indexed(call.first..call.first + call.count, 0, 0..1);
        }
    }
@@ -1,645 +0,0 @@
-//! Horizon's terrain drawn with a Java pack's `gbuffers_terrain` and
-//! `gbuffers_water` (docs/shader-packs.md). The pack's vertex program runs
-//! after a glue that rebuilds what Iris would feed it from Horizon's
-//! `TerrainVertex`: the camera-relative position, the quad's normal and
-//! tangent (from its four corners, read from the arena page as storage),
-//! the colour without vanilla's directional shade, the lightmap
-//! coordinates, the sprite's place in a block atlas laid out from Horizon's
-//! sprite arrays, and `mc_Entity` from the pack's `block.properties`, by
-//! sprite name.
-use horizon_shaderpack::translate::Geometry;
-use std::collections::BTreeMap;
-
-/// `TerrainVertex` in 32-bit words.
-const VERTEX_WORDS: u32 = 6;
-
-/// The glue's declarations and `hz_vertex`; `HZ_ORIGIN_DECL` and
-/// `HZ_ORIGIN` are the variant's (instanced or flat draws).
-const GLUE: &str = r#"
-layout(location = 0) in vec3 hz_position;
-layout(location = 1) in uvec2 hz_uv;
-layout(location = 2) in uint hz_layer;
-layout(location = 3) in vec4 hz_color;
-layout(location = 4) in uvec2 hz_light;
-HZ_ORIGIN_DECL
-layout(std430, set = 3, binding = 0) readonly buffer HzVertices { uint hz_vertices[]; };
-// [0]: atlas columns, [1]: 1 in the Nether, then each sprite layer's block id.
-layout(std430, set = 3, binding = 1) readonly buffer HzTable { int hz_table[]; };
-vec4 hz_pos;
-vec3 hz_normal;
-vec4 hz_tangent;
-vec4 hz_tint;
-vec2 hz_atlas;
-vec2 hz_mid;
-vec2 hz_lightmap;
-float hz_block;
-vec3 hz_mid_block;
-vec3 hz_corner(uint v) {
-    uint b = v * HZ_WORDSu;
-    return vec3(uintBitsToFloat(hz_vertices[b]), uintBitsToFloat(hz_vertices[b + 1u]),
-        uintBitsToFloat(hz_vertices[b + 2u]));
-}
-vec2 hz_corner_uv(uint v) {
-    uint w = hz_vertices[v * HZ_WORDSu + 3u];
-    return vec2(float(w & 65535u), float(w >> 16u));
-}
-void hz_vertex() {
-    vec4 origin = HZ_ORIGIN;
-    hz_pos = vec4(hz_position + origin.xyz, 1.0);
-    // The quad's corners: quads are four vertices from a multiple of four.
-    uint q = uint(gl_VertexIndex) & 4294967292u;
-    vec3 p0 = hz_corner(q);
-    vec3 e1 = hz_corner(q + 1u) - p0;
-    vec3 e2 = hz_corner(q + 2u) - p0;
-    vec3 n = cross(e1, e2);
-    if (dot(n, n) < 1e-12) {
-        n = cross(e2, hz_corner(q + 3u) - p0);
-    }
-    hz_normal = dot(n, n) > 0.0 ? normalize(n) : vec3(0.0, 1.0, 0.0);
-    vec2 t0 = hz_corner_uv(q);
-    vec2 d1 = hz_corner_uv(q + 1u) - t0;
-    vec2 d2 = hz_corner_uv(q + 2u) - t0;
-    float s = d1.x * d2.y - d2.x * d1.y < 0.0 ? -1.0 : 1.0;
-    vec3 t = (e1 * d2.y - e2 * d1.y) * s;
-    vec3 b = (e2 * d1.x - e1 * d2.x) * s;
-    t = t - hz_normal * dot(hz_normal, t);
-    t = dot(t, t) > 0.0 ? normalize(t) : vec3(1.0, 0.0, 0.0);
-    hz_tangent = vec4(t, dot(cross(hz_normal, t), b) < 0.0 ? -1.0 : 1.0);
-    // Iris turns vanilla's directional shade off: undo it on axis faces.
-    vec3 a = abs(hz_normal);
-    bool nether = hz_table[1] != 0;
-    float shade = 1.0;
-    if (a.y > 0.999) {
-        shade = nether ? 0.9 : (hz_normal.y > 0.0 ? 1.0 : 0.5);
-    } else if (a.z > 0.999) {
-        shade = 0.8;
-    } else if (a.x > 0.999) {
-        shade = 0.6;
-    }
-    hz_tint = vec4(min(hz_color.rgb / shade, vec3(1.0)), hz_color.a);
-    // The sprite's cell in the atlas, columns of square cells.
-    int layer = int(hz_layer & 16383u);
-    int cols = max(hz_table[0], 1);
-    vec2 cell = vec2(float(layer % cols), float(layer / cols));
-    vec2 uv = clamp(vec2(hz_uv) * origin.w, 0.0, 1.0);
-    hz_atlas = (cell + uv) / float(cols);
-    hz_mid = (cell + 0.5) / float(cols);
-    // Vanilla's UV2: block light, then sky light, 0..240.
-    hz_lightmap = vec2(float(hz_light.y), float(hz_light.x));
-    hz_block = float(hz_table[2 + layer]);
-    hz_mid_block = (floor(hz_position - hz_normal * 0.01) + 0.5 - hz_position) * 64.0;
-}
-"#;
-
-/// The glue of one draw path: instanced section draws (the origin is an
-/// instance attribute) or flat ones (`gfx/flat.rs`: from the block's slot).
-pub fn glue(flat: bool, alpha_test: Option<f32>) -> Geometry {
-    let (decl, origin) = if flat {
-        (
-            "layout(std430, set = 1, binding = 0) readonly buffer HzBlockSlots { uint hz_block_slots[]; };\n\
-             layout(std430, set = 1, binding = 1) readonly buffer HzSlotOrigins { vec4 hz_slot_origins[]; };",
-            "hz_slot_origins[hz_block_slots[uint(gl_VertexIndex) >> 8u]]",
-        )
-    } else {
-        ("layout(location = 5) in vec4 hz_origin;", "hz_origin")
-    };
-    let vertex_glue = GLUE
-        .replace("HZ_ORIGIN_DECL", decl)
-        .replace("HZ_ORIGIN", origin)
-        .replace("HZ_WORDS", &VERTEX_WORDS.to_string());
-    let lightmap = "vec4(hz_lightmap, 0.0, 1.0)";
-    let attributes: BTreeMap<String, String> = [
-        ("iris_Vertex", "hz_pos"),
-        ("vaPosition", "hz_pos"),
-        ("iris_Normal", "vec4(hz_normal, 0.0)"),
-        ("vaNormal", "vec4(hz_normal, 0.0)"),
-        ("iris_Color", "hz_tint"),
-        ("vaColor", "hz_tint"),
-        ("iris_MultiTexCoord0", "vec4(hz_atlas, 0.0, 1.0)"),
-        ("vaUV0", "vec4(hz_atlas, 0.0, 1.0)"),
-        ("iris_MultiTexCoord1", lightmap),
-        ("iris_MultiTexCoord2", lightmap),
-        ("vaUV2", lightmap),
-        // OverlayTexture.NO_OVERLAY.
-        ("vaUV1", "vec4(0.0, 10.0, 0.0, 0.0)"),
-        ("mc_Entity", "vec4(hz_block, -1.0, 0.0, 0.0)"),
-        ("mc_midTexCoord", "vec4(hz_mid, 0.0, 1.0)"),
-        ("at_tangent", "hz_tangent"),
-        ("at_midBlock", "vec4(hz_mid_block, 0.0)"),
-    ]
-    .into_iter()
-    .map(|(k, v)| (k.to_owned(), v.to_owned()))
-    .collect();
-    Geometry {
-        vertex_glue,
-        attributes,
-        alpha_test,
-    }
-}
-
-/// The glue's table: atlas columns, the Nether flag, then each sprite
-/// layer's block id from `block.properties` (-1 for blocks it doesn't
-/// list, as Iris).
-pub fn table(sprite_layers: &BTreeMap<String, u32>, block_ids: &BTreeMap<String, i32>) -> Vec<i32> {
-    let layers = sprite_layers.values().max().map_or(0, |&m| m as usize + 1);
-    let mut out = vec![-1; layers + 2];
-    out[0] = atlas_columns(layers as u32) as i32;
-    out[1] = 0;
-    for (name, &layer) in sprite_layers {
-        if let Some(id) = horizon_shaderpack::properties::sprite_block_id(name, block_ids) {
-            out[layer as usize + 2] = id;
-        }
-    }
-    out
-}
-
-/// The atlas's columns (and rows) of sprite cells for `layers` sprites.
-pub fn atlas_columns(layers: u32) -> u32 {
-    (f64::from(layers.max(1)).sqrt().ceil() as u32).max(1)
-}
-
-/// Whether `device` renders to and filters the 16-bit normalized formats
-/// a Java pack's `RGBA16` targets become (`java_stages::target_format`).
-pub fn norm16_targets(adapter: &wgpu::Adapter, device: &wgpu::Device) -> bool {
-    use wgpu::TextureFormat as F;
-    let wanted = wgpu::Features::TEXTURE_FORMAT_16BIT_NORM
-        | wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES;
-    device.features().contains(wanted)
-        && [
-            F::R16Unorm,
-            F::Rg16Unorm,
-            F::Rgba16Unorm,
-            F::R16Snorm,
-            F::Rg16Snorm,
-            F::Rgba16Snorm,
-        ]
-        .into_iter()
-        .all(|f| {
-            let features = adapter.get_texture_format_features(f);
-            features
-                .allowed_usages
-                .contains(wgpu::TextureUsages::RENDER_ATTACHMENT)
-                && features
-                    .flags
-                    .contains(wgpu::TextureFormatFeatureFlags::FILTERABLE)
-        })
-}
-
-/// The bind group layout of a page group: the page's vertices and the glue's
-/// table, read by the vertex stage.
-pub fn page_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
-    let storage = |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,
-    };
-    device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-        label: Some("Java shader pack terrain page"),
-        entries: &[storage(0), storage(1)],
-    })
-}
-
-/// Draws Horizon's terrain with a pack's pipelines: the solid layer or the
-/// translucent one. Set by the renderer, which owns the sections.
-pub type DrawTerrain<'a> = dyn Fn(&mut wgpu::RenderPass<'_>, bool, &TerrainPipelines<'_>) + 'a;
-
-/// What the renderer binds to draw with a pack's geometry program: the
-/// pipeline of its draw path and the pack's group (group 2). Group 1 is the
-/// flat path's, group 3 the page's ([`page_layout`]). `flat` is `None` when
-/// the renderer has no flat draws.
-pub struct TerrainPipelines<'a> {
-    pub instanced: &'a wgpu::RenderPipeline,
-    pub flat: Option<&'a wgpu::RenderPipeline>,
-    pub group: &'a wgpu::BindGroup,
-}
-
-/// What a Java pack's geometry reads from the renderer each frame.
-pub struct JavaWorld<'a> {
-    /// The block sprite arrays, [`super::SPRITE_SPLIT`]-layer each.
-    pub sprites: &'a [wgpu::Texture],
-    pub split: u32,
-    /// Mipmap levels the terrain samples.
-    pub levels: u32,
-    /// The sprite layers and mip levels animation rewrote this frame.
-    pub animated: &'a [(u32, u32)],
-    pub lightmap: &'a wgpu::TextureView,
-    pub draw: &'a DrawTerrain<'a>,
-}
-
-const ATLAS: &str = r#"
-struct Atlas { cols: u32, layers: u32, split: u32, pad: u32 }
-@group(0) @binding(0) var<uniform> atlas: Atlas;
-@group(0) @binding(1) var s0: texture_2d_array<f32>;
-@group(0) @binding(2) var s1: texture_2d_array<f32>;
-@group(0) @binding(3) var s2: texture_2d_array<f32>;
-@group(0) @binding(4) var s3: texture_2d_array<f32>;
-@group(0) @binding(5) var s4: texture_2d_array<f32>;
-@group(0) @binding(6) var s5: texture_2d_array<f32>;
-@group(0) @binding(7) var s6: texture_2d_array<f32>;
-@group(0) @binding(8) var s7: texture_2d_array<f32>;
-
-struct Out {
-    @builtin(position) p: vec4f,
-    @location(0) @interpolate(flat) mip: u32,
-}
-
-@vertex
-fn vs(@builtin(vertex_index) i: u32, @builtin(instance_index) mip: u32) -> Out {
-    let uv = vec2f(f32((i << 1u) & 2u), f32(i & 2u));
-    return Out(vec4f(uv * 2.0 - 1.0, 0.0, 1.0), mip);
-}
-
-// Each sprite layer into its cell, at mip level `mip`.
-@fragment
-fn fs(in: Out) -> @location(0) vec4f {
-    let cell = max(textureDimensions(s0, in.mip).x, 1u);
-    let px = vec2u(in.p.xy);
-    let c = px / cell;
-    let layer = c.y * atlas.cols + c.x;
-    if c.x >= atlas.cols || layer >= atlas.layers {
-        return vec4f(0.0);
-    }
-    let at = px % cell;
-    let l = i32(layer % atlas.split);
-    let m = i32(in.mip);
-    switch layer / atlas.split {
-        case 0u: { return textureLoad(s0, at, l, m); }
-        case 1u: { return textureLoad(s1, at, l, m); }
-        case 2u: { return textureLoad(s2, at, l, m); }
-        case 3u: { return textureLoad(s3, at, l, m); }
-        case 4u: { return textureLoad(s4, at, l, m); }
-        case 5u: { return textureLoad(s5, at, l, m); }
-        case 6u: { return textureLoad(s6, at, l, m); }
-        default: { return textureLoad(s7, at, l, m); }
-    }
-}
-"#;
-
-/// Horizon's block sprites as one 2D atlas, as Iris binds `gtexture`:
-/// square cells, [`atlas_columns`] to a row. Drawn from the sprite arrays
-/// once, then animated sprites are copied in as they change.
-pub struct Atlas {
-    texture: wgpu::Texture,
-    pub view: wgpu::TextureView,
-    mips: Vec<wgpu::TextureView>,
-    pipeline: wgpu::RenderPipeline,
-    layout: wgpu::BindGroupLayout,
-    uniform: wgpu::Buffer,
-    /// Layers, sprite size, mip levels it was made for.
-    key: (u32, u32, u32),
-    /// The first sprite array it was drawn from (resource reloads make
-    /// new ones).
-    source: wgpu::Texture,
-    drawn: bool,
-}
-
-impl Atlas {
-    /// The atlas for `world`'s sprites; `None` without any.
-    pub fn new(device: &wgpu::Device, queue: &wgpu::Queue, world: &JavaWorld) -> Option<Self> {
-        let key = Self::key(world)?;
-        let (layers, size, levels) = key;
-        let cols = atlas_columns(layers);
-        let texture = device.create_texture(&wgpu::TextureDescriptor {
-            label: Some("Java shader pack block atlas"),
-            size: wgpu::Extent3d {
-                width: cols * size,
-                height: cols * size,
-                depth_or_array_layers: 1,
-            },
-            mip_level_count: levels,
-            sample_count: 1,
-            dimension: wgpu::TextureDimension::D2,
-            format: wgpu::TextureFormat::Rgba8Unorm,
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT
-                | wgpu::TextureUsages::TEXTURE_BINDING
-                | wgpu::TextureUsages::COPY_DST,
-            view_formats: &[],
-        });
-        let mips = (0..levels)
-            .map(|level| {
-                texture.create_view(&wgpu::TextureViewDescriptor {
-                    base_mip_level: level,
-                    mip_level_count: Some(1),
-                    ..Default::default()
-                })
-            })
-            .collect();
-        let mut entries = vec![wgpu::BindGroupLayoutEntry {
-            binding: 0,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Buffer {
-                ty: wgpu::BufferBindingType::Uniform,
-                has_dynamic_offset: false,
-                min_binding_size: None,
-            },
-            count: None,
-        }];
-        entries.extend((1..=8).map(|binding| wgpu::BindGroupLayoutEntry {
-            binding,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Texture {
-                sample_type: wgpu::TextureSampleType::Float { filterable: false },
-                view_dimension: wgpu::TextureViewDimension::D2Array,
-                multisampled: false,
-            },
-            count: None,
-        }));
-        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            label: Some("Java shader pack block atlas"),
-            entries: &entries,
-        });
-        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-            label: Some("Java shader pack block atlas"),
-            source: wgpu::ShaderSource::Wgsl(ATLAS.into()),
-        });
-        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-            label: Some("Java shader pack block atlas"),
-            layout: Some(
-                &device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-                    label: Some("Java shader pack block atlas"),
-                    bind_group_layouts: &[Some(&layout)],
-                    ..Default::default()
-                }),
-            ),
-            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(wgpu::TextureFormat::Rgba8Unorm.into())],
-            }),
-            multiview_mask: None,
-            cache: None,
-        });
-        let uniform = device.create_buffer(&wgpu::BufferDescriptor {
-            label: Some("Java shader pack block atlas"),
-            size: 16,
-            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-            mapped_at_creation: false,
-        });
-        queue.write_buffer(
-            &uniform,
-            0,
-            bytemuck::cast_slice(&[cols, layers, world.split.max(1), 0]),
-        );
-        Some(Self {
-            view: texture.create_view(&Default::default()),
-            texture,
-            mips,
-            pipeline,
-            layout,
-            uniform,
-            key,
-            source: world.sprites[0].clone(),
-            drawn: false,
-        })
-    }
-
-    fn key(world: &JavaWorld) -> Option<(u32, u32, u32)> {
-        let first = world.sprites.first()?;
-        let layers = world
-            .sprites
-            .iter()
-            .map(|t| t.depth_or_array_layers())
-            .sum();
-        let levels = (world.levels + 1).min(first.mip_level_count()).max(1);
-        Some((layers, first.width(), levels))
-    }
-
-    /// Whether it was made for `world`'s sprites.
-    pub fn fits(&self, world: &JavaWorld) -> bool {
-        Self::key(world) == Some(self.key) && world.sprites.first() == Some(&self.source)
-    }
-
-    /// Bring it up to date: drawn the first time, then the sprites
-    /// animation rewrote copied into their cells.
-    pub fn update(
-        &mut self,
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        world: &JavaWorld,
-    ) {
-        if !self.drawn {
-            self.draw(device, encoder, world);
-            self.drawn = true;
-            return;
-        }
-        let (layers, size, levels) = self.key;
-        let cols = atlas_columns(layers);
-        let split = world.split.max(1);
-        for &(layer, level) in world.animated {
-            let Some(array) = world.sprites.get((layer / split) as usize) else {
-                continue;
-            };
-            if level >= levels || layer >= layers {
-                continue;
-            }
-            let edge = (size >> level).max(1);
-            encoder.copy_texture_to_texture(
-                wgpu::TexelCopyTextureInfo {
-                    texture: array,
-                    mip_level: level,
-                    origin: wgpu::Origin3d {
-                        x: 0,
-                        y: 0,
-                        z: layer % split,
-                    },
-                    aspect: wgpu::TextureAspect::All,
-                },
-                wgpu::TexelCopyTextureInfo {
-                    texture: &self.texture,
-                    mip_level: level,
-                    origin: wgpu::Origin3d {
-                        x: (layer % cols) * edge,
-                        y: (layer / cols) * edge,
-                        z: 0,
-                    },
-                    aspect: wgpu::TextureAspect::All,
-                },
-                wgpu::Extent3d {
-                    width: edge,
-                    height: edge,
-                    depth_or_array_layers: 1,
-                },
-            );
-        }
-    }
-
-    /// The atlas's size in pixels (`atlasSize`).
-    pub fn size(&self) -> [u32; 2] {
-        [self.texture.width(), self.texture.height()]
-    }
-
-    /// Draw the sprites into the atlas, every mip level.
-    fn draw(&self, device: &wgpu::Device, encoder: &mut wgpu::CommandEncoder, world: &JavaWorld) {
-        let views: Vec<wgpu::TextureView> = (0..8)
-            .map(|i| {
-                let t = world.sprites.get(i).unwrap_or(&world.sprites[0]);
-                t.create_view(&wgpu::TextureViewDescriptor {
-                    dimension: Some(wgpu::TextureViewDimension::D2Array),
-                    mip_level_count: Some(self.key.2),
-                    ..Default::default()
-                })
-            })
-            .collect();
-        let mut entries = vec![wgpu::BindGroupEntry {
-            binding: 0,
-            resource: self.uniform.as_entire_binding(),
-        }];
-        entries.extend(views.iter().enumerate().map(|(i, v)| wgpu::BindGroupEntry {
-            binding: i as u32 + 1,
-            resource: wgpu::BindingResource::TextureView(v),
-        }));
-        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("Java shader pack block atlas"),
-            layout: &self.layout,
-            entries: &entries,
-        });
-        for (mip, view) in self.mips.iter().enumerate() {
-            let attachments = [Some(wgpu::RenderPassColorAttachment {
-                view,
-                resolve_target: None,
-                depth_slice: None,
-                ops: wgpu::Operations {
-                    load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
-                    store: wgpu::StoreOp::Store,
-                },
-            })];
-            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                label: Some("Java shader pack block atlas"),
-                color_attachments: &attachments,
-                ..Default::default()
-            });
-            pass.set_pipeline(&self.pipeline);
-            pass.set_bind_group(0, &group, &[]);
-            pass.draw(0..3, mip as u32..mip as u32 + 1);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// `module` validates and translates for Metal, Vulkan and DirectX 12.
-    fn backends(module: &naga::Module, label: &str) {
-        let info = naga::valid::Validator::new(
-            naga::valid::ValidationFlags::all(),
-            naga::valid::Capabilities::all(),
-        )
-        .validate(module)
-        .unwrap_or_else(|e| panic!("{label}: {e:?}"));
-        naga::back::msl::write_string(
-            module,
-            &info,
-            // wgpu's Metal backend asks for MSL 2.x.
-            &naga::back::msl::Options {
-                lang_version: (2, 4),
-                ..Default::default()
-            },
-            &naga::back::msl::PipelineOptions::default(),
-        )
-        .unwrap_or_else(|e| panic!("{label} (MSL): {e}"));
-        naga::back::spv::write_vec(module, &info, &Default::default(), None)
-            .unwrap_or_else(|e| panic!("{label} (SPIR-V): {e}"));
-        for entry in &module.entry_points {
-            let mut hlsl = String::new();
-            naga::back::hlsl::Writer::new(
-                &mut hlsl,
-                &naga::back::hlsl::Options::default(),
-                &naga::back::hlsl::PipelineOptions {
-                    entry_point: Some((entry.stage, entry.name.clone())),
-                },
-            )
-            .write(module, &info, None)
-            .unwrap_or_else(|e| panic!("{label} {} (HLSL): {e}", entry.name));
-        }
-    }
-
-    /// A terrain program reading every attribute the glue fills, run after
-    /// each draw path's glue, and the atlas shader, on every backend.
-    #[test]
-    fn the_glue_feeds_a_terrain_program_on_every_backend() {
-        let program = "#version 120
-attribute vec4 mc_Entity;
-attribute vec4 mc_midTexCoord;
-attribute vec4 at_tangent;
-attribute vec3 at_midBlock;
-varying vec4 color;
-varying vec2 uv;
-varying vec2 lm;
-varying vec3 normal;
-varying float id;
-void main() {
-    vec4 p = gl_ModelViewMatrix * gl_Vertex;
-    p.xyz += at_midBlock / 64.0 * 0.0 + at_tangent.xyz * 0.0;
-    gl_Position = gl_ProjectionMatrix * p;
-    color = gl_Color;
-    uv = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy + mc_midTexCoord.xy * 0.0;
-    lm = (gl_TextureMatrix[1] * gl_MultiTexCoord1).xy;
-    normal = gl_NormalMatrix * gl_Normal;
-    id = mc_Entity.x;
-}
-";
-        for flat in [false, true] {
-            let mut link = horizon_shaderpack::translate::Link {
-                set: 2,
-                geometry: Some(glue(flat, Some(0.1))),
-                ..Default::default()
-            };
-            let t = horizon_shaderpack::translate::translate(
-                horizon_shaderpack::Stage::Vertex,
-                program,
-                &mut link,
-                &|l| format!("line {l}"),
-            )
-            .unwrap_or_else(|e| panic!("flat {flat}: {e}"));
-            for wanted in ["hz_vertex();", "mc_Entity = vec4(vec4(hz_block"] {
-                assert!(t.glsl.contains(wanted), "{wanted}\n{}", t.glsl);
-            }
-            // The glue's inputs are Horizon's vertex layout.
-            let inputs = t.module.entry_points[0].function.arguments.len();
-            assert_eq!(inputs, if flat { 6 } else { 7 }, "{}", t.wgsl);
-            let reparsed = naga::front::wgsl::parse_str(&t.wgsl).unwrap();
-            backends(&reparsed, &format!("terrain glue (flat {flat})"));
-        }
-        backends(&naga::front::wgsl::parse_str(ATLAS).unwrap(), "atlas");
-        backends(
-            &naga::front::wgsl::parse_str(super::super::java_stages::BLIT).unwrap(),
-            "Java shader pack blits",
-        );
-    }
-
-    #[test]
-    fn sprites_take_their_blocks_ids() {
-        let layers: BTreeMap<String, u32> = [
-            ("minecraft:block/oak_leaves", 0),
-            ("minecraft:block/water_still", 1),
-            ("minecraft:block/stone", 2),
-            ("minecraft:block/oak_log_top", 3),
-        ]
-        .into_iter()
-        .map(|(n, l)| (n.to_owned(), l))
-        .collect();
-        let ids: BTreeMap<String, i32> = [("oak_leaves", 10003), ("water", 8), ("oak_log", 7)]
-            .into_iter()
-            .map(|(n, i)| (n.to_owned(), i))
-            .collect();
-        assert_eq!(table(&layers, &ids), [2, 0, 10003, 8, -1, 7]);
-        assert_eq!(atlas_columns(5), 3);
-        assert_eq!(atlas_columns(0), 1);
-    }
-}
@@ -1,552 +0,0 @@
-//! A Horizon shader pack on the GPU (docs/shader-packs.md): each stage
-//! (`shadow`, `gbuffer`, `deferred`, `composite`, `final`) is a full-screen
-//! pass that reads the world's colour, depth, opaque depth, G-buffer normals
-//! and materials, shadow map, noise texture and the previous stage's output,
-//! and writes its own target; the last target goes to the screen through
-//! `world_post` (copy or FXAA) under the hand and HUD. Only exists while a
-//! pack is selected.
-use crate::shader_pack::{Rgba, ShaderPack, VERTEX_ENTRY};
-use horizon_shaderpack::uniforms::SmoothFloat;
-
-/// The `Frame` uniform of the prelude (`shader_pack_prelude.wgsl`).
-#[repr(C)]
-#[derive(Clone, Copy, Default, bytemuck::Pod, bytemuck::Zeroable)]
-pub struct FrameUniform {
-    pub view: [[f32; 4]; 4],
-    pub projection: [[f32; 4]; 4],
-    pub inverse_view: [[f32; 4]; 4],
-    pub inverse_projection: [[f32; 4]; 4],
-    pub camera_position: [f32; 4],
-    pub resolution: [f32; 4],
-    pub time: [f32; 4],
-    pub sun: [f32; 4],
-    pub moon: [f32; 4],
-    pub sky_color: [f32; 4],
-    pub fog_color: [f32; 4],
-    pub fog: [f32; 4],
-    pub weather: [f32; 4],
-    pub camera_state: [f32; 4],
-    pub view_params: [f32; 4],
-    pub dimension: [f32; 4],
-}
-
-/// The API 2 `FrameExt` uniform of the prelude (`shader_pack_prelude.wgsl`).
-#[repr(C)]
-#[derive(Clone, Copy, Default, bytemuck::Pod, bytemuck::Zeroable)]
-pub struct FrameExtUniform {
-    pub previous_view: [[f32; 4]; 4],
-    pub previous_projection: [[f32; 4]; 4],
-    pub shadow_view: [[f32; 4]; 4],
-    pub shadow_projection: [[f32; 4]; 4],
-    pub shadow_inverse_view: [[f32; 4]; 4],
-    pub shadow_inverse_projection: [[f32; 4]; 4],
-    pub previous_camera: [f32; 4],
-    pub shadow_params: [f32; 4],
-    pub environment: [f32; 4],
-}
-
-/// Iris's `noisetex` without a `texture.noise`: 256² random RGB, opaque.
-/// Horizon packs get the same one unless `[textures] noise` replaces it.
-pub(super) fn noise() -> Rgba {
-    const SIZE: u32 = 256;
-    let mut seed = 0x2545_f491_u32;
-    let pixels = (0..SIZE * SIZE * 4)
-        .map(|i| {
-            seed ^= seed << 13;
-            seed ^= seed >> 17;
-            seed ^= seed << 5;
-            if i % 4 == 3 { 255 } else { (seed >> 24) as u8 }
-        })
-        .collect();
-    Rgba {
-        width: SIZE,
-        height: SIZE,
-        pixels,
-    }
-}
-
-/// `image` as a sampled RGBA8 texture.
-pub(super) fn rgba_view(
-    device: &wgpu::Device,
-    queue: &wgpu::Queue,
-    label: &str,
-    image: &Rgba,
-) -> wgpu::TextureView {
-    let texture = device.create_texture(&wgpu::TextureDescriptor {
-        label: Some(label),
-        size: wgpu::Extent3d {
-            width: image.width,
-            height: image.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: &[],
-    });
-    queue.write_texture(
-        texture.as_image_copy(),
-        &image.pixels,
-        wgpu::TexelCopyBufferLayout {
-            offset: 0,
-            bytes_per_row: Some(image.width * 4),
-            rows_per_image: None,
-        },
-        texture.size(),
-    );
-    texture.create_view(&Default::default())
-}
-
-struct Pass {
-    pipeline: wgpu::RenderPipeline,
-    scale: f32,
-    target_format: wgpu::TextureFormat,
-    uniform: wgpu::Buffer,
-    uniform_ext: wgpu::Buffer,
-}
-/// A stage's output and the bindings that read the world into it.
-struct Target {
-    size: [u32; 2],
-    view: wgpu::TextureView,
-    group: wgpu::BindGroup,
-}
-
-pub struct PackStages {
-    pub id: String,
-    pub needs_shadow: bool,
-    /// The stages read the G-buffer (`build_gbuffer`) or the depth before
-    /// translucent geometry (`capture_opaque_depth`).
-    pub needs_gbuffer: bool,
-    pub needs_opaque_depth: bool,
-    pub shadow_res: u32,
-    pub shadow_dist: f32,
-    layout: wgpu::BindGroupLayout,
-    linear: wgpu::Sampler,
-    nearest: wgpu::Sampler,
-    repeat: wgpu::Sampler,
-    shadow_sampler: wgpu::Sampler,
-    noise_view: wgpu::TextureView,
-    passes: Vec<Pass>,
-    /// Built for this world target size and `world_post` generation.
-    targets: Vec<Target>,
-    /// `world_post`'s bindings of the last stage's output.
-    output: Option<wgpu::BindGroup>,
-    world_size: [u32; 2],
-    post_generation: u64,
-    started: std::time::Instant,
-    last: Option<std::time::Instant>,
-    frames: u32,
-    previous: Option<([[f32; 4]; 4], [[f32; 4]; 4], [f32; 3])>,
-    wetness: SmoothFloat,
-}
-
-fn stage_format(name: Option<&str>, default: wgpu::TextureFormat) -> wgpu::TextureFormat {
-    match name.map(str::to_lowercase).as_deref() {
-        Some("rgba16float" | "rgba16f") => wgpu::TextureFormat::Rgba16Float,
-        Some("rgba8unorm" | "rgba8" | "rgba") => wgpu::TextureFormat::Rgba8Unorm,
-        Some("rgb10a2unorm" | "rgb10_a2") => wgpu::TextureFormat::Rgb10a2Unorm,
-        _ => default,
-    }
-}
-
-impl PackStages {
-    /// The pipelines of a loaded (already validated) pack, or wgpu's error.
-    pub fn new(
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        format: wgpu::TextureFormat,
-        pack: &ShaderPack,
-    ) -> Result<Self, String> {
-        let texture = |binding, sample_type| wgpu::BindGroupLayoutEntry {
-            binding,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Texture {
-                sample_type,
-                view_dimension: wgpu::TextureViewDimension::D2,
-                multisampled: false,
-            },
-            count: None,
-        };
-        let float = wgpu::TextureSampleType::Float { filterable: true };
-        let sampler = |binding, ty| wgpu::BindGroupLayoutEntry {
-            binding,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Sampler(ty),
-            count: None,
-        };
-        let uniform_entry = |binding| wgpu::BindGroupLayoutEntry {
-            binding,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Buffer {
-                ty: wgpu::BufferBindingType::Uniform,
-                has_dynamic_offset: false,
-                min_binding_size: None,
-            },
-            count: None,
-        };
-        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            label: Some("Shader pack stage"),
-            entries: &[
-                texture(0, float),
-                texture(1, wgpu::TextureSampleType::Depth),
-                texture(2, float),
-                sampler(3, wgpu::SamplerBindingType::Filtering),
-                sampler(4, wgpu::SamplerBindingType::NonFiltering),
-                uniform_entry(5),
-                uniform_entry(6),
-                texture(7, float),
-                texture(8, float),
-                texture(9, wgpu::TextureSampleType::Depth),
-                texture(10, wgpu::TextureSampleType::Depth),
-                sampler(11, wgpu::SamplerBindingType::Comparison),
-                texture(12, float),
-                sampler(13, wgpu::SamplerBindingType::Filtering),
-            ],
-        });
-        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-            label: Some("Shader pack stage"),
-            bind_group_layouts: &[Some(&layout)],
-            ..Default::default()
-        });
-        let constants = pack.constants();
-        let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
-        let stage_count = pack.stages.len();
-        let passes = pack
-            .stages
-            .iter()
-            .enumerate()
-            .map(|(idx, stage)| {
-                let is_last = idx + 1 == stage_count;
-                let target_format = if is_last {
-                    format
-                } else {
-                    stage_format(stage.format.as_deref(), format)
-                };
-                let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-                    label: Some(&stage.file),
-                    source: wgpu::ShaderSource::Wgsl(stage.source.as_str().into()),
-                });
-                // Only the overrides a stage declares may be passed to it.
-                let constants: Vec<(&str, f64)> = constants
-                    .iter()
-                    .copied()
-                    .filter(|(key, _)| declares_override(&stage.source, key))
-                    .collect();
-                let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                    label: Some(&stage.file),
-                    layout: Some(&pipeline_layout),
-                    vertex: wgpu::VertexState {
-                        module: &module,
-                        entry_point: Some(VERTEX_ENTRY),
-                        compilation_options: Default::default(),
-                        buffers: &[],
-                    },
-                    primitive: Default::default(),
-                    depth_stencil: None,
-                    multisample: Default::default(),
-                    fragment: Some(wgpu::FragmentState {
-                        module: &module,
-                        entry_point: Some(&stage.entry),
-                        compilation_options: wgpu::PipelineCompilationOptions {
-                            constants: &constants,
-                            ..Default::default()
-                        },
-                        targets: &[Some(wgpu::ColorTargetState {
-                            format: target_format,
-                            blend: None,
-                            write_mask: wgpu::ColorWrites::ALL,
-                        })],
-                    }),
-                    multiview_mask: None,
-                    cache: None,
-                });
-                Pass {
-                    pipeline,
-                    scale: stage.scale,
-                    target_format,
-                    uniform: device.create_buffer(&wgpu::BufferDescriptor {
-                        label: Some("Shader pack frame"),
-                        size: std::mem::size_of::<FrameUniform>() as u64,
-                        usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-                        mapped_at_creation: false,
-                    }),
-                    uniform_ext: device.create_buffer(&wgpu::BufferDescriptor {
-                        label: Some("Shader pack frame ext"),
-                        size: std::mem::size_of::<FrameExtUniform>() as u64,
-                        usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-                        mapped_at_creation: false,
-                    }),
-                }
-            })
-            .collect();
-        if let Some(error) = pollster::block_on(scope.pop()) {
-            return Err(error.to_string());
-        }
-        let make_sampler = |filter, address, compare| {
-            device.create_sampler(&wgpu::SamplerDescriptor {
-                label: Some("Shader pack"),
-                address_mode_u: address,
-                address_mode_v: address,
-                address_mode_w: address,
-                mag_filter: filter,
-                min_filter: filter,
-                compare,
-                ..Default::default()
-            })
-        };
-        let noise_view = match &pack.custom_noise {
-            Some(image) => rgba_view(device, queue, "Shader pack noise", image),
-            None => rgba_view(device, queue, "Shader pack noise", &noise()),
-        };
-        let (shadow_res, shadow_dist) = pack.shadow_config();
-        Ok(Self {
-            id: pack.id.clone(),
-            needs_shadow: pack.needs_shadow(),
-            needs_gbuffer: pack.needs_gbuffer(),
-            needs_opaque_depth: pack.needs_opaque_depth(),
-            shadow_res,
-            shadow_dist,
-            layout,
-            linear: make_sampler(
-                wgpu::FilterMode::Linear,
-                wgpu::AddressMode::ClampToEdge,
-                None,
-            ),
-            nearest: make_sampler(
-                wgpu::FilterMode::Nearest,
-                wgpu::AddressMode::ClampToEdge,
-                None,
-            ),
-            repeat: make_sampler(wgpu::FilterMode::Linear, wgpu::AddressMode::Repeat, None),
-            shadow_sampler: make_sampler(
-                wgpu::FilterMode::Linear,
-                wgpu::AddressMode::ClampToEdge,
-                Some(wgpu::CompareFunction::GreaterEqual),
-            ),
-            noise_view,
-            passes,
-            targets: Vec::new(),
-            output: None,
-            world_size: [0, 0],
-            post_generation: u64::MAX,
-            started: std::time::Instant::now(),
-            last: None,
-            frames: 0,
-            previous: None,
-            wetness: SmoothFloat::default(),
-        })
-    }
-
-    /// Run every stage over the world's `color` and `depth` (`size`) and
-    /// return `post`'s bindings of the last stage's output.
-    #[allow(clippy::too_many_arguments)]
-    pub fn run(
-        &mut self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        encoder: &mut wgpu::CommandEncoder,
-        color: &wgpu::TextureView,
-        depth: &wgpu::TextureView,
-        size: [u32; 2],
-        post: &super::world_post::Post,
-        mut uniform: FrameUniform,
-        eye_light: [u8; 2],
-    ) -> &wgpu::BindGroup {
-        if self.world_size != size
-            || self.post_generation != post.generation()
-            || self.targets.len() != self.passes.len()
-        {
-            self.world_size = size;
-            self.post_generation = post.generation();
-            self.targets.clear();
-            for pass in &self.passes {
-                let target_size = size.map(|v| ((v as f32 * pass.scale).round() as u32).max(1));
-                let view = device
-                    .create_texture(&wgpu::TextureDescriptor {
-                        label: Some("Shader pack stage"),
-                        size: wgpu::Extent3d {
-                            width: target_size[0],
-                            height: target_size[1],
-                            depth_or_array_layers: 1,
-                        },
-                        mip_level_count: 1,
-                        sample_count: 1,
-                        dimension: wgpu::TextureDimension::D2,
-                        format: pass.target_format,
-                        usage: wgpu::TextureUsages::RENDER_ATTACHMENT
-                            | wgpu::TextureUsages::TEXTURE_BINDING,
-                        view_formats: &[],
-                    })
-                    .create_view(&Default::default());
-                let previous = self.targets.last().map_or(color, |t: &Target| &t.view);
-                let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-                    label: Some("Shader pack stage"),
-                    layout: &self.layout,
-                    entries: &[
-                        wgpu::BindGroupEntry {
-                            binding: 0,
-                            resource: wgpu::BindingResource::TextureView(color),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 1,
-                            resource: wgpu::BindingResource::TextureView(depth),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 2,
-                            resource: wgpu::BindingResource::TextureView(previous),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 3,
-                            resource: wgpu::BindingResource::Sampler(&self.linear),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 4,
-                            resource: wgpu::BindingResource::Sampler(&self.nearest),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 5,
-                            resource: pass.uniform.as_entire_binding(),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 6,
-                            resource: pass.uniform_ext.as_entire_binding(),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 7,
-                            resource: wgpu::BindingResource::TextureView(post.normal()),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 8,
-                            resource: wgpu::BindingResource::TextureView(post.material()),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 9,
-                            resource: wgpu::BindingResource::TextureView(post.opaque_depth()),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 10,
-                            resource: wgpu::BindingResource::TextureView(post.shadow_depth()),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 11,
-                            resource: wgpu::BindingResource::Sampler(&self.shadow_sampler),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 12,
-                            resource: wgpu::BindingResource::TextureView(&self.noise_view),
-                        },
-                        wgpu::BindGroupEntry {
-                            binding: 13,
-                            resource: wgpu::BindingResource::Sampler(&self.repeat),
-                        },
-                    ],
-                });
-                self.targets.push(Target {
-                    size: target_size,
-                    view,
-                    group,
-                });
-            }
-            let last = &self.targets.last().expect("a pack has a stage").view;
-            self.output = Some(post.bind(device, last));
-        }
-        let now = std::time::Instant::now();
-        let dt = self.last.map_or(0.0, |t| (now - t).as_secs_f32());
-        self.last = Some(now);
-        let wet = self.wetness.update(uniform.weather[0], 60.0, 120.0, dt);
-        let cam = [
-            uniform.camera_position[0],
-            uniform.camera_position[1],
-            uniform.camera_position[2],
-        ];
-        let (prev_view, prev_proj, prev_cam) =
-            self.previous
-                .unwrap_or((uniform.view, uniform.projection, cam));
-        self.previous = Some((uniform.view, uniform.projection, cam));
-        let shadow_view = post.shadow_view;
-        let shadow_proj = post.shadow_proj;
-        let ext = FrameExtUniform {
-            previous_view: prev_view,
-            previous_projection: prev_proj,
-            shadow_view: shadow_view.to_cols_array_2d(),
-            shadow_projection: shadow_proj.to_cols_array_2d(),
-            shadow_inverse_view: shadow_view.inverse().to_cols_array_2d(),
-            shadow_inverse_projection: shadow_proj.inverse().to_cols_array_2d(),
-            previous_camera: [prev_cam[0], prev_cam[1], prev_cam[2], dt],
-            shadow_params: [
-                post.shadow_resolution as f32,
-                post.shadow_distance,
-                0.0,
-                if post.shadow_active { 1.0 } else { 0.0 },
-            ],
-            environment: [
-                f32::from(eye_light[0]) * 16.0,
-                f32::from(eye_light[1]) * 16.0,
-                wet,
-                0.0,
-            ],
-        };
-        uniform.time[0] = self.started.elapsed().as_secs_f32();
-        uniform.time[1] = self.frames as f32;
-        self.frames = self.frames.wrapping_add(1);
-        for (pass, target) in self.passes.iter().zip(&self.targets) {
-            let [w, h] = target.size.map(|v| v as f32);
-            uniform.resolution = [w, h, 1.0 / w, 1.0 / h];
-            queue.write_buffer(&pass.uniform, 0, bytemuck::bytes_of(&uniform));
-            queue.write_buffer(&pass.uniform_ext, 0, bytemuck::bytes_of(&ext));
-            let attachments = [Some(wgpu::RenderPassColorAttachment {
-                view: &target.view,
-                resolve_target: None,
-                depth_slice: None,
-                ops: wgpu::Operations {
-                    load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
-                    store: wgpu::StoreOp::Store,
-                },
-            })];
-            let mut render = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                label: Some("Shader pack stage"),
-                color_attachments: &attachments,
-                ..Default::default()
-            });
-            render.set_pipeline(&pass.pipeline);
-            render.set_bind_group(0, &target.group, &[]);
-            render.draw(0..3, 0..1);
-        }
-        self.output.as_ref().expect("bound with the targets")
-    }
-}
-
-/// `override <key>` appears in the source (a declaration, not just a use).
-fn declares_override(source: &str, key: &str) -> bool {
-    source.lines().any(|line| {
-        line.trim_start()
-            .strip_prefix("override")
-            .and_then(|rest| rest.trim_start().strip_prefix(key))
-            .is_some_and(|rest| rest.trim_start().starts_with([':', '=']))
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn the_frame_uniform_matches_the_prelude() {
-        // 4 matrices and 12 vectors, as `struct Frame` in the prelude.
-        assert_eq!(std::mem::size_of::<super::FrameUniform>(), 4 * 64 + 12 * 16);
-        let prelude = crate::shader_pack::PRELUDE;
-        let body = prelude.split("struct Frame {").nth(1).unwrap();
-        let body = &body[..body.find('}').unwrap()];
-        assert_eq!(body.matches("mat4x4<f32>").count(), 4);
-        assert_eq!(body.matches("vec4<f32>").count(), 12);
-    }
-    #[test]
-    fn only_declared_overrides_are_passed() {
-        let source =
-            "override saturation: f32 = 1.0;\noverride  vignette = true;\nlet x = saturation_2;";
-        assert!(super::declares_override(source, "saturation"));
-        assert!(super::declares_override(source, "vignette"));
-        assert!(!super::declares_override(source, "saturation_2"));
-        assert!(!super::declares_override(source, "haze"));
-    }
-}
@@ -1,163 +1,25 @@
-//! Resolution scale, FXAA, and shader-pack G-buffer/shadow targets (Horizon
-//! settings): the world renders into its own target at the scaled size, then
-//! one full-screen pass copies or anti-aliases it onto the screen, under the
-//! hand and HUD. For a shader pack that reads them, `Post` also keeps:
-//! - `opaque_depth`: the depth before translucent terrain (water, stained
-//!   glass, ice) draws, a Java pack's `depthtex1`/`depthtex2`;
-//! - `normal` and `material`, an api 2 pack's `scene_normal` and
-//!   `scene_material`: surface normals and material properties
-//!   reconstructed from depth and scene colour;
-//! - `shadow_depth`, an api 2 pack's: the sun/moon shadow map and its
-//!   light-space `shadow_view` and `shadow_proj` matrices.
-//!
-//! With none of them on, the world renders straight to the screen as before.
-
-use super::pack_stages::FrameUniform;
-use glam::{Mat4, Vec3};
-
-const GBUFFER_WGSL: &str = r#"
-struct GbufferParams {
-    inverse_view: mat4x4<f32>,
-    inverse_projection: mat4x4<f32>,
-    resolution: vec4<f32>,
-    // x: eye block light (0..1), y: eye sky light (0..1), z: wetness (0..1), w: sun elevation
-    env: vec4<f32>,
-}
-
-@group(0) @binding(0) var world_color: texture_2d<f32>;
-@group(0) @binding(1) var world_depth: texture_depth_2d;
-@group(0) @binding(2) var opaque_depth: texture_depth_2d;
-@group(0) @binding(3) var nearest_sampler: sampler;
-@group(0) @binding(4) var<uniform> params: GbufferParams;
-
-struct VsOut {
-    @builtin(position) clip: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-}
-
-@vertex
-fn vs_gbuffer(@builtin(vertex_index) i: u32) -> VsOut {
-    let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
-    var out: VsOut;
-    out.clip = vec4<f32>(p * 2.0 - 1.0, 0.0, 1.0);
-    out.uv = vec2<f32>(p.x, 1.0 - p.y);
-    return out;
-}
-
-struct GbufferOut {
-    @location(0) normal: vec4<f32>,
-    @location(1) material: vec4<f32>,
-}
-
-fn world_pos(uv: vec2<f32>, d: f32) -> vec3<f32> {
-    let v = params.inverse_projection * vec4<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, d, 1.0);
-    let view = v.xyz / max(v.w, 1e-6);
-    return (params.inverse_view * vec4<f32>(view, 1.0)).xyz;
-}
-
-@fragment
-fn fs_gbuffer(in: VsOut) -> GbufferOut {
-    let d_all = textureSampleLevel(world_depth, nearest_sampler, in.uv, 0);
-    let d_opq = textureSampleLevel(opaque_depth, nearest_sampler, in.uv, 0);
-    let color = textureSampleLevel(world_color, nearest_sampler, in.uv, 0.0);
-    var out: GbufferOut;
-    if d_all <= 0.0 && d_opq <= 0.0 {
-        out.normal = vec4<f32>(0.5, 1.0, 0.5, 0.0);
-        out.material = vec4<f32>(0.0, params.env.y, 0.0, 1.0);
-        return out;
-    }
-    let d = select(d_all, d_opq, d_opq > 0.0);
-    let step_uv = params.resolution.zw;
-    let p0 = world_pos(in.uv, d);
-    let uv_r = clamp(in.uv + vec2<f32>(step_uv.x, 0.0), vec2<f32>(0.0), vec2<f32>(1.0));
-    let uv_l = clamp(in.uv - vec2<f32>(step_uv.x, 0.0), vec2<f32>(0.0), vec2<f32>(1.0));
-    let uv_d = clamp(in.uv + vec2<f32>(0.0, step_uv.y), vec2<f32>(0.0), vec2<f32>(1.0));
-    let uv_u = clamp(in.uv - vec2<f32>(0.0, step_uv.y), vec2<f32>(0.0), vec2<f32>(1.0));
-    let dr = textureSampleLevel(opaque_depth, nearest_sampler, uv_r, 0);
-    let dl = textureSampleLevel(opaque_depth, nearest_sampler, uv_l, 0);
-    let dd = textureSampleLevel(opaque_depth, nearest_sampler, uv_d, 0);
-    let du = textureSampleLevel(opaque_depth, nearest_sampler, uv_u, 0);
-    let dx = select(world_pos(uv_r, dr) - p0, p0 - world_pos(uv_l, dl), abs(dl - d) < abs(dr - d));
-    let dy = select(world_pos(uv_d, dd) - p0, p0 - world_pos(uv_u, du), abs(du - d) < abs(dd - d));
-    let raw_n = cross(dy, dx);
-    let n_len = length(raw_n);
-    let n = select(vec3<f32>(0.0, 1.0, 0.0), raw_n / max(n_len, 1e-6), n_len > 1e-6);
-    // Reversed depth: closer translucent geometry has larger depth than opaque geometry.
-    let is_translucent = select(0.0, 1.0, d_all > d_opq + 1e-5);
-    let luma = dot(color.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
-    let block_light = clamp(max(params.env.x, smoothstep(0.65, 0.98, luma)), 0.0, 1.0);
-    let roughness = select(clamp(0.85 - params.env.z * 0.45, 0.1, 1.0), 0.05, is_translucent > 0.5);
-    out.normal = vec4<f32>(n * 0.5 + 0.5, 1.0);
-    out.material = vec4<f32>(block_light, params.env.y, is_translucent, roughness);
-    return out;
-}
-"#;
-
-#[repr(C)]
-#[derive(Clone, Copy, Default, bytemuck::Pod, bytemuck::Zeroable)]
-struct GbufferUniform {
-    inverse_view: [[f32; 4]; 4],
-    inverse_projection: [[f32; 4]; 4],
-    resolution: [f32; 4],
-    env: [f32; 4],
-}
-
-/// What the frame's shader pack reads beyond the world's colour and depth:
-/// `Post` keeps these targets only while one does.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub struct Extras {
-    pub opaque_depth: bool,
-    pub gbuffer: bool,
-}
+//! Resolution scale and FXAA (Horizon settings): the world renders into its
+//! own target at the scaled size, then one full-screen pass copies or
+//! anti-aliases it onto the screen, under the hand and HUD. With neither on,
+//! the world renders straight to the screen.

 struct WorldTarget {
    size: [u32; 2],
-    extras: Extras,
    color: wgpu::TextureView,
-    depth_tex: wgpu::Texture,
    depth: wgpu::TextureView,
-    /// With `extras.opaque_depth` or `extras.gbuffer` (which reads it).
-    opaque_depth: Option<(wgpu::Texture, wgpu::TextureView)>,
-    gbuffer: Option<Gbuffer>,
    group: wgpu::BindGroup,
-    opaque_captured: bool,
-}
-
-struct Gbuffer {
-    normal: wgpu::TextureView,
-    material: wgpu::TextureView,
-    group: wgpu::BindGroup,
-}
-
-struct ShadowTarget {
-    resolution: u32,
-    depth: wgpu::TextureView,
 }

 pub struct Post {
    layout: wgpu::BindGroupLayout,
    sampler: wgpu::Sampler,
-    nearest: wgpu::Sampler,
    copy: wgpu::RenderPipeline,
    fxaa: wgpu::RenderPipeline,
-    gbuffer_layout: wgpu::BindGroupLayout,
-    gbuffer_pipeline: wgpu::RenderPipeline,
-    gbuffer_uniform: wgpu::Buffer,
    format: wgpu::TextureFormat,
    /// World resolution relative to the window (0.5..=2.0).
    pub scale: f32,
    pub antialias: bool,
    target: Option<WorldTarget>,
-    shadow: Option<ShadowTarget>,
-    /// Bumped whenever a target is made: bindings of the old ones are stale.
-    generation: u64,
-    fallback_shadow: wgpu::TextureView,
-    fallback_color: wgpu::TextureView,
-    pub shadow_view: Mat4,
-    pub shadow_proj: Mat4,
-    pub shadow_distance: f32,
-    pub shadow_resolution: u32,
-    pub shadow_active: bool,
 }

 impl Post {
@@ -225,192 +87,31 @@ impl Post {
            min_filter: wgpu::FilterMode::Linear,
            ..Default::default()
        });
-        let nearest = device.create_sampler(&wgpu::SamplerDescriptor {
-            label: Some("Horizon post nearest"),
-            mag_filter: wgpu::FilterMode::Nearest,
-            min_filter: wgpu::FilterMode::Nearest,
-            ..Default::default()
-        });
-
-        let gbuffer_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-            label: Some("Horizon gbuffer"),
-            source: wgpu::ShaderSource::Wgsl(GBUFFER_WGSL.into()),
-        });
-        let gbuffer_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            label: Some("Horizon gbuffer layout"),
-            entries: &[
-                wgpu::BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Texture {
-                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
-                        view_dimension: wgpu::TextureViewDimension::D2,
-                        multisampled: false,
-                    },
-                    count: None,
-                },
-                wgpu::BindGroupLayoutEntry {
-                    binding: 1,
-                    visibility: wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Texture {
-                        sample_type: wgpu::TextureSampleType::Depth,
-                        view_dimension: wgpu::TextureViewDimension::D2,
-                        multisampled: false,
-                    },
-                    count: None,
-                },
-                wgpu::BindGroupLayoutEntry {
-                    binding: 2,
-                    visibility: wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Texture {
-                        sample_type: wgpu::TextureSampleType::Depth,
-                        view_dimension: wgpu::TextureViewDimension::D2,
-                        multisampled: false,
-                    },
-                    count: None,
-                },
-                wgpu::BindGroupLayoutEntry {
-                    binding: 3,
-                    visibility: wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::NonFiltering),
-                    count: None,
-                },
-                wgpu::BindGroupLayoutEntry {
-                    binding: 4,
-                    visibility: wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Buffer {
-                        ty: wgpu::BufferBindingType::Uniform,
-                        has_dynamic_offset: false,
-                        min_binding_size: None,
-                    },
-                    count: None,
-                },
-            ],
-        });
-        let gbuffer_pipe_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-            label: Some("Horizon gbuffer"),
-            bind_group_layouts: &[Some(&gbuffer_layout)],
-            ..Default::default()
-        });
-        let gbuffer_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-            label: Some("Horizon gbuffer"),
-            layout: Some(&gbuffer_pipe_layout),
-            vertex: wgpu::VertexState {
-                module: &gbuffer_shader,
-                entry_point: Some("vs_gbuffer"),
-                compilation_options: Default::default(),
-                buffers: &[],
-            },
-            primitive: Default::default(),
-            depth_stencil: None,
-            multisample: Default::default(),
-            fragment: Some(wgpu::FragmentState {
-                module: &gbuffer_shader,
-                entry_point: Some("fs_gbuffer"),
-                compilation_options: Default::default(),
-                targets: &[
-                    Some(wgpu::ColorTargetState {
-                        format: wgpu::TextureFormat::Rgba8Unorm,
-                        blend: None,
-                        write_mask: wgpu::ColorWrites::ALL,
-                    }),
-                    Some(wgpu::ColorTargetState {
-                        format: wgpu::TextureFormat::Rgba8Unorm,
-                        blend: None,
-                        write_mask: wgpu::ColorWrites::ALL,
-                    }),
-                ],
-            }),
-            multiview_mask: None,
-            cache: None,
-        });
-        let gbuffer_uniform = device.create_buffer(&wgpu::BufferDescriptor {
-            label: Some("Horizon gbuffer uniform"),
-            size: std::mem::size_of::<GbufferUniform>() as u64,
-            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-            mapped_at_creation: false,
-        });
-        let fallback_shadow = device
-            .create_texture(&wgpu::TextureDescriptor {
-                label: Some("Horizon fallback shadow"),
-                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::RENDER_ATTACHMENT
-                    | wgpu::TextureUsages::TEXTURE_BINDING,
-                view_formats: &[],
-            })
-            .create_view(&Default::default());
-        let fallback_color = device
-            .create_texture(&wgpu::TextureDescriptor {
-                label: Some("Horizon fallback gbuffer"),
-                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::Rgba8Unorm,
-                usage: wgpu::TextureUsages::RENDER_ATTACHMENT
-                    | wgpu::TextureUsages::TEXTURE_BINDING,
-                view_formats: &[],
-            })
-            .create_view(&Default::default());
        Self {
            copy: pipeline("fs_copy"),
            fxaa: pipeline("fs_fxaa"),
            layout,
            sampler,
-            nearest,
-            gbuffer_layout,
-            gbuffer_pipeline,
-            gbuffer_uniform,
            format,
            scale: 1.0,
            antialias: false,
            target: None,
-            shadow: None,
-            generation: 0,
-            fallback_shadow,
-            fallback_color,
-            shadow_view: Mat4::IDENTITY,
-            shadow_proj: Mat4::IDENTITY,
-            shadow_distance: 128.0,
-            shadow_resolution: 2048,
-            shadow_active: false,
        }
    }

    /// The world's colour and depth targets this frame, or `None` to draw
-    /// it straight to the screen. `pack`: a shader pack runs this frame,
-    /// reading `extras`.
+    /// it straight to the screen.
    pub fn prepare(
        &mut self,
        device: &wgpu::Device,
        window: [u32; 2],
-        pack: bool,
-        extras: Extras,
    ) -> Option<(wgpu::TextureView, wgpu::TextureView)> {
-        if self.scale == 1.0 && !self.antialias && !pack {
+        if self.scale == 1.0 && !self.antialias {
            self.target = None;
-            self.shadow_active = false;
            return None;
        }
        let size = window.map(|v| ((v as f32 * self.scale).round() as u32).clamp(1, 8192));
-        if self
-            .target
-            .as_ref()
-            .is_none_or(|t| t.size != size || t.extras != extras)
-        {
-            self.generation += 1;
+        if self.target.as_ref().is_none_or(|t| t.size != size) {
            let extent = wgpu::Extent3d {
                width: size[0],
                height: size[1],
@@ -434,273 +135,26 @@ impl Post {
                wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
            )
            .create_view(&Default::default());
-            let depth_tex = make_tex(
+            // TEXTURE_BINDING: occlusion culling reads it.
+            let depth = make_tex(
                "Scaled world depth",
                wgpu::TextureFormat::Depth32Float,
-                wgpu::TextureUsages::RENDER_ATTACHMENT
-                    | wgpu::TextureUsages::TEXTURE_BINDING
-                    | wgpu::TextureUsages::COPY_SRC,
-            );
-            let depth = depth_tex.create_view(&Default::default());
-            let opaque_depth = (extras.opaque_depth || extras.gbuffer).then(|| {
-                let tex = make_tex(
-                    "Opaque world depth",
-                    wgpu::TextureFormat::Depth32Float,
-                    wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-                );
-                let view = tex.create_view(&Default::default());
-                (tex, view)
-            });
-            let gbuffer = opaque_depth
-                .as_ref()
-                .filter(|_| extras.gbuffer)
-                .map(|(_, opaque)| {
-                    let color_target = |label| {
-                        make_tex(
-                            label,
-                            wgpu::TextureFormat::Rgba8Unorm,
-                            wgpu::TextureUsages::RENDER_ATTACHMENT
-                                | wgpu::TextureUsages::TEXTURE_BINDING,
-                        )
-                        .create_view(&Default::default())
-                    };
-                    let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-                        label: Some("Horizon gbuffer"),
-                        layout: &self.gbuffer_layout,
-                        entries: &[
-                            wgpu::BindGroupEntry {
-                                binding: 0,
-                                resource: wgpu::BindingResource::TextureView(&color),
-                            },
-                            wgpu::BindGroupEntry {
-                                binding: 1,
-                                resource: wgpu::BindingResource::TextureView(&depth),
-                            },
-                            wgpu::BindGroupEntry {
-                                binding: 2,
-                                resource: wgpu::BindingResource::TextureView(opaque),
-                            },
-                            wgpu::BindGroupEntry {
-                                binding: 3,
-                                resource: wgpu::BindingResource::Sampler(&self.nearest),
-                            },
-                            wgpu::BindGroupEntry {
-                                binding: 4,
-                                resource: self.gbuffer_uniform.as_entire_binding(),
-                            },
-                        ],
-                    });
-                    Gbuffer {
-                        normal: color_target("World G-buffer normal"),
-                        material: color_target("World G-buffer material"),
-                        group,
-                    }
-                });
+                wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
+            )
+            .create_view(&Default::default());
            let group = self.bind(device, &color);
            self.target = Some(WorldTarget {
                size,
-                extras,
                color,
-                depth_tex,
                depth,
-                opaque_depth,
-                gbuffer,
                group,
-                opaque_captured: false,
            });
        }
-        if let Some(t) = &mut self.target {
-            t.opaque_captured = false;
-        }
        self.target
            .as_ref()
            .map(|t| (t.color.clone(), t.depth.clone()))
    }

-    /// Prepare the directional sun/moon shadow map target and compute its
-    /// camera-relative orthographic `shadow_view` and `shadow_proj` matrices.
-    pub fn prepare_shadow(
-        &mut self,
-        device: &wgpu::Device,
-        resolution: u32,
-        distance: f32,
-        sun_dir: Vec3,
-        moon_dir: Vec3,
-    ) -> &wgpu::TextureView {
-        let resolution = resolution.clamp(256, 4096);
-        let distance = distance.clamp(16.0, 512.0);
-        if self
-            .shadow
-            .as_ref()
-            .is_none_or(|s| s.resolution != resolution)
-        {
-            let depth = device
-                .create_texture(&wgpu::TextureDescriptor {
-                    label: Some("Horizon shadow map"),
-                    size: wgpu::Extent3d {
-                        width: resolution,
-                        height: resolution,
-                        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: &[],
-                })
-                .create_view(&Default::default());
-            self.shadow = Some(ShadowTarget { resolution, depth });
-            self.generation += 1;
-        }
-        let light_dir = if sun_dir.y >= -0.05 {
-            sun_dir.normalize_or_zero()
-        } else {
-            moon_dir.normalize_or_zero()
-        };
-        let dir = if light_dir.length_squared() > 1e-4 {
-            light_dir
-        } else {
-            Vec3::Y
-        };
-        let up = if dir.y.abs() > 0.99 { Vec3::Z } else { Vec3::Y };
-        self.shadow_view = Mat4::look_at_rh(dir * distance, Vec3::ZERO, up);
-        // Reversed-depth orthographic projection for the world's GreaterEqual
-        // pipelines (near maps to 1.0, far maps to 0.0), and standard 0..1
-        // projection for shader sampling.
-        self.shadow_proj = Mat4::orthographic_rh(
-            -distance,
-            distance,
-            -distance,
-            distance,
-            distance * 2.5,
-            0.05,
-        );
-        self.shadow_distance = distance;
-        self.shadow_resolution = resolution;
-        self.shadow_active = true;
-        &self.shadow.as_ref().expect("created above").depth
-    }
-
-    /// Snapshot `world_depth` into `opaque_depth` (`depthtex1`/`depthtex2`)
-    /// right before translucent water and weather draw.
-    pub fn capture_opaque_depth(&mut self, encoder: &mut wgpu::CommandEncoder) {
-        let Some(t) = &mut self.target else { return };
-        let Some((opaque, _)) = &t.opaque_depth else {
-            return;
-        };
-        encoder.copy_texture_to_texture(
-            t.depth_tex.as_image_copy(),
-            opaque.as_image_copy(),
-            t.depth_tex.size(),
-        );
-        t.opaque_captured = true;
-    }
-
-    /// Reconstruct the G-buffer `normal` and `material` textures after the
-    /// world pass finishes (with `Extras::gbuffer`).
-    pub fn build_gbuffer(
-        &mut self,
-        queue: &wgpu::Queue,
-        encoder: &mut wgpu::CommandEncoder,
-        frame: &FrameUniform,
-        eye_light: [u8; 2],
-        wetness: f32,
-    ) {
-        if !self.target.as_ref().is_some_and(|t| t.opaque_captured) {
-            self.capture_opaque_depth(encoder);
-        }
-        let Some(t) = &self.target else { return };
-        let Some(gbuffer) = &t.gbuffer else { return };
-        let [w, h] = t.size.map(|v| v.max(1) as f32);
-        let uniform = GbufferUniform {
-            inverse_view: frame.inverse_view,
-            inverse_projection: frame.inverse_projection,
-            resolution: [w, h, 1.0 / w, 1.0 / h],
-            env: [
-                f32::from(eye_light[0]) / 15.0,
-                f32::from(eye_light[1]) / 15.0,
-                wetness,
-                frame.sun[1],
-            ],
-        };
-        queue.write_buffer(&self.gbuffer_uniform, 0, bytemuck::bytes_of(&uniform));
-        let attachments = [
-            Some(wgpu::RenderPassColorAttachment {
-                view: &gbuffer.normal,
-                resolve_target: None,
-                depth_slice: None,
-                ops: wgpu::Operations {
-                    load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
-                    store: wgpu::StoreOp::Store,
-                },
-            }),
-            Some(wgpu::RenderPassColorAttachment {
-                view: &gbuffer.material,
-                resolve_target: None,
-                depth_slice: None,
-                ops: wgpu::Operations {
-                    load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
-                    store: wgpu::StoreOp::Store,
-                },
-            }),
-        ];
-        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: Some("Horizon gbuffer"),
-            color_attachments: &attachments,
-            ..Default::default()
-        });
-        pass.set_pipeline(&self.gbuffer_pipeline);
-        pass.set_bind_group(0, &gbuffer.group, &[]);
-        pass.draw(0..3, 0..1);
-    }
-
-    /// The world target's size, once `prepare` made one.
-    pub fn size(&self) -> Option<[u32; 2]> {
-        self.target.as_ref().map(|t| t.size)
-    }
-
-    /// Changes whenever `prepare` or `prepare_shadow` makes new targets:
-    /// bindings made from the views below must be made again.
-    pub fn generation(&self) -> u64 {
-        self.generation
-    }
-
-    /// The depth before translucent geometry (`capture_opaque_depth`), or
-    /// the world's depth when nothing reads it.
-    pub fn opaque_depth(&self) -> &wgpu::TextureView {
-        match &self.target {
-            Some(WorldTarget {
-                opaque_depth: Some((_, view)),
-                ..
-            }) => view,
-            Some(t) => &t.depth,
-            None => &self.fallback_shadow,
-        }
-    }
-
-    /// Reconstructed world-space normals (`scene_normal`).
-    pub fn normal(&self) -> &wgpu::TextureView {
-        self.gbuffer().map_or(&self.fallback_color, |g| &g.normal)
-    }
-
-    /// Reconstructed material and light (`scene_material`).
-    pub fn material(&self) -> &wgpu::TextureView {
-        self.gbuffer().map_or(&self.fallback_color, |g| &g.material)
-    }
-
-    fn gbuffer(&self) -> Option<&Gbuffer> {
-        self.target.as_ref()?.gbuffer.as_ref()
-    }
-
-    /// The sun/moon shadow map (`shadow_depth` of api 2 packs).
-    pub fn shadow_depth(&self) -> &wgpu::TextureView {
-        self.shadow
-            .as_ref()
-            .map_or(&self.fallback_shadow, |s| &s.depth)
-    }
-
    /// Bindings that copy (or anti-alias) `view` onto the screen in `finish_with`.
    pub fn bind(&self, device: &wgpu::Device, view: &wgpu::TextureView) -> wgpu::BindGroup {
        device.create_bind_group(&wgpu::BindGroupDescriptor {
@@ -252,9 +252,6 @@ pub struct Graphics {
    /// or behind other windows, and half the worker threads. Off by default;
    /// it changes when frames are drawn, never what they show or the ticks.
    pub battery: bool,
-    /// The Horizon shader pack in `shaderpacks/` (its folder name); empty:
-    /// none, the vanilla picture (docs/shader-packs.md).
-    pub shader_pack: String,
    /// The graphics API (Windows only; see `GraphicsApi`).
    pub api: GraphicsApi,
 }
@@ -280,7 +277,6 @@ impl Default for Graphics {
            resolution_scale: 100,
            fxaa: false,
            battery: false,
-            shader_pack: String::new(),
            api: GraphicsApi::Auto,
        }
    }
@@ -332,7 +328,6 @@ impl Graphics {
                "resolutionScale" => g.resolution_scale = number(g.resolution_scale).clamp(50, 200),
                "fxaa" => g.fxaa = flag(g.fxaa),
                "batteryMode" => g.battery = flag(g.battery),
-                "shaderPack" => g.shader_pack = value.to_string(),
                "graphicsApi" => g.api = GraphicsApi::from_name(value).unwrap_or_default(),
                "overlay" => {
                    g.overlay = match value {
@@ -348,7 +343,7 @@ impl Graphics {
    }
    pub fn serialize(&self) -> String {
        format!(
-            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\ncullLeaves:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nbatteryMode:{}\nshaderPack:{}\ngraphicsApi:{}\n",
+            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\ncullLeaves:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nbatteryMode:{}\ngraphicsApi:{}\n",
            self.preset.name(),
            self.lod_distance,
            self.far_detail.name(),
@@ -375,7 +370,6 @@ impl Graphics {
            self.resolution_scale,
            bool_text(self.fxaa),
            bool_text(self.battery),
-            self.shader_pack,
            self.api.name(),
        )
    }
@@ -469,13 +463,17 @@ mod tests {
            resolution_scale: 75,
            fxaa: true,
            battery: true,
-            shader_pack: "horizon-sample".into(),
            api: GraphicsApi::Dx12,
        };
        assert_eq!(Graphics::parse(&g.serialize()), g);
        assert_eq!(Graphics::parse(""), Graphics::default());
-        // The old menus' Simple / Advanced choice is ignored.
+        // The old menus' Simple / Advanced choice is ignored, and so is the
+        // shader pack older versions saved.
        assert_eq!(Graphics::parse("level:advanced\n"), Graphics::default());
+        assert_eq!(
+            Graphics::parse("shaderPack:Pack.zip\n"),
+            Graphics::default()
+        );
        assert_eq!(
            Graphics::parse("workers:abc\nsky:maybe\ncullLeaves:maybe\nentityCulling:maybe\n"),
            Graphics::default()
@@ -39,7 +39,6 @@ pub enum H {
    ResolutionScale,
    Antialiasing,
    BatteryMode,
-    ShaderPack,
    GraphicsApi,
 }

@@ -112,18 +111,13 @@ pub fn rows(level: Level) -> Vec<Row> {
        "Waits for the display's refresh: no tearing, a little latency.",
    );
    let gui = v(Opt::GuiScale, None, "Size of menus and the HUD.");
-    let shader_pack = h(
-        H::ShaderPack,
-        High,
-        "Redraws the world with a pack from the shaderpacks folder. Off is vanilla.",
-    );
    let preset = h(
        H::Preset,
        None,
        "Sets the options below together. Changing one makes it Custom.",
    );
    let mut rows = match level {
-        Level::Simple => vec![preset, render, lod, far, fov, fps, vsync, gui, shader_pack],
+        Level::Simple => vec![preset, render, lod, far, fov, fps, vsync, gui],
        Level::Advanced => vec![
            Row::Header("Rendering"),
            render,
@@ -251,7 +245,6 @@ pub fn rows(level: Level) -> Vec<Row> {
                None,
                "Lowers the frame rate when minimised, or idle too.",
            ),
-            shader_pack,
            Row::Header("Preferences"),
            v(Opt::ViewBobbing, None, "Sways the view while walking."),
            v(Opt::ChunkFade, None, "Fades newly loaded chunks in."),
@@ -381,10 +374,6 @@ impl H {
            H::Antialiasing => labelled("Anti-aliasing", if g.fxaa { "FXAA" } else { "Off" }),
            H::BatteryMode => labelled("Battery Mode", on_off(g.battery)),
            H::GraphicsApi => labelled("Graphics API", g.api.label()),
-            H::ShaderPack => match g.shader_pack.as_str() {
-                "" => labelled("Shader Pack", "Off"),
-                id => labelled("Shader Pack", id),
-            },
            H::Overlay => labelled(
                "Performance Overlay",
                match g.overlay {
@@ -527,7 +516,6 @@ impl Item {
                    | H::PresentMode
                    | H::Workers
                    | H::BatteryMode
-                    | H::ShaderPack
                    | H::GraphicsApi
            ) | Item::Vanilla(
                Opt::GuiScale
@@ -557,8 +545,6 @@ pub enum Action {
    Changed,
    OpenAdvanced,
    OpenSimple,
-    /// The Shader Pack row: the Shader Packs page (where packs are picked).
-    OpenShaderPacks,
    Done,
 }

@@ -784,9 +770,6 @@ impl GraphicsUi {
            }
            return match wd.target {
                Target::Button(action) => vec![Action::ButtonClick, action],
-                Target::Item(Item::Horizon(H::ShaderPack)) => {
-                    vec![Action::ButtonClick, Action::OpenShaderPacks]
-                }
                Target::Item(item) => {
                    if item.slider(s).is_some() {
                        self.dragging = Some(item);
@@ -994,44 +977,6 @@ mod tests {
        );
    }

-    #[test]
-    fn the_shader_pack_row_is_off_by_default_and_outside_presets() {
-        let mut s = Settings::default();
-        let row = Item::Horizon(H::ShaderPack);
-        assert_eq!(row.label(&s).plain(), "Shader Pack: Off");
-        assert!(
-            rows(Level::Advanced)
-                .iter()
-                .any(|r| matches!(r, Row::Setting(x) if x.item == row))
-        );
-        s.horizon.shader_pack = "horizon-sample".into();
-        assert_eq!(row.label(&s).plain(), "Shader Pack: horizon-sample");
-        // The row opens the Shader Packs page, where packs are picked.
-        let mut ui = GraphicsUi::default();
-        let find = |ui: &mut GraphicsUi| {
-            let (widgets, ..) = ui.layout(Level::Advanced, 854.0, 480.0);
-            widgets
-                .into_iter()
-                .find(|w| matches!(w.target, Target::Item(i) if i == row))
-                .unwrap()
-        };
-        ui.scroll = find(&mut ui).y - GraphicsUi::bounds(480.0).0 - 4.0;
-        let w = find(&mut ui);
-        assert_eq!(
-            ui.click(
-                Level::Advanced,
-                &mut s,
-                (w.x + 1.0, w.y + 1.0),
-                (854.0, 480.0),
-                [854, 480],
-                false,
-                false
-            ),
-            [Action::ButtonClick, Action::OpenShaderPacks]
-        );
-        assert_eq!(s.horizon.shader_pack, "horizon-sample");
-    }
-
    #[test]
    fn presets_set_vanilla_and_horizon_options() {
        let mut s = Settings::default();
@@ -298,6 +298,7 @@ impl PlayerMotion {
            blocking,
            blocked: 0.0,
            block_sound: false,
+            knocked: false,
            totem: totem_ready,
            totem_fired: false,
        };
@@ -313,6 +314,7 @@ impl PlayerMotion {
            hurt,
            blocked: environment.blocked,
            sound: environment.block_sound,
+            knockback: environment.knocked,
        };
        if environment.totem_fired {
            h.totem_used = true;
@@ -373,6 +375,8 @@ pub(crate) struct Environment<'a> {
    pub(crate) blocking: Option<Blocking>,
    pub(crate) blocked: f32,
    pub(crate) block_sound: bool,
+    /// `dealDefaultKnockback` ran: a fresh hit, not fully blocked.
+    pub(crate) knocked: bool,
    /// LivingEntity.checkTotemDeathProtection: a totem is held / was used.
    pub(crate) totem: bool,
    pub(crate) totem_fired: bool,
@@ -435,6 +439,9 @@ pub struct BlockOutcome {
    pub blocked: f32,
    /// `BlocksAttacks.onBlocked` ran (the block sound plays).
    pub sound: bool,
+    /// The hit knocks the player back (`dealDefaultKnockback`): not one in
+    /// the hurt cooldown, nor one the shield took whole.
+    pub knockback: bool,
 }
 struct MatchedSets;
 impl horizon_world::blocking_rules::TypeMatchWorld for MatchedSets {
@@ -667,9 +674,11 @@ impl HurtWorld for Environment<'_> {
        *self.sync_velocity = true;
        Ok(())
    }
+    /// The caller applies it: these sources carry no entity or position.
    fn knockback(&mut self, _: &mut State, _: f32, _: bool) -> io::Result<()> {
+        self.knocked = true;
        Ok(())
-    } // no entity or position on these sources
+    }
    fn death_protection(&mut self, _: &mut State) -> io::Result<bool> {
        if !self.totem
            || self
@@ -761,6 +770,37 @@ impl ServerPlayerHurtWorld for Environment<'_> {

 #[cfg(test)]
 mod tests {
+    #[test]
+    fn a_hit_in_the_hurt_cooldown_knocks_nobody_back() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = crate::assets::Assets::load(&root).unwrap();
+        let resources = crate::motion::MotionResources::load(&root, &assets).unwrap();
+        let mut player =
+            crate::motion::PlayerMotion::new(&resources, horizon_core::geometry::Vec3::ZERO)
+                .unwrap();
+        let (health, rules) = (&resources.health, super::HealthRules::default());
+        let id = health.damage.id("minecraft:mob_attack").unwrap();
+        let mut hit = |amount| {
+            player
+                .hurt_blocking(health, rules, id, amount, None)
+                .unwrap()
+        };
+        let first = hit(1.0);
+        assert!(first.hurt && first.knockback);
+        // A stronger hit inside the cooldown hurts by the difference only
+        // (LivingEntity.hurtServer), with no dealDefaultKnockback.
+        let second = hit(2.0);
+        assert!(second.hurt && !second.knockback);
+        // A weaker one doesn't hurt at all.
+        let third = hit(1.5);
+        assert!(!third.hurt && !third.knockback);
+    }
+
    #[test]
    fn hurt_sounds_follow_damage_effects() {
        // DamageEffects: HURT, THORNS, DROWNING, BURNING, POKING, FREEZING.
@@ -156,6 +156,7 @@ impl FoodWorld for TickWorld<'_> {
            blocking: None,
            blocked: 0.0,
            block_sound: false,
+            knocked: false,
            totem: false,
            totem_fired: false,
        };
@@ -271,23 +271,15 @@ fn read_levels(t: Option<&Tag>) -> Levels {
        return Vec::new();
    };
    // Pre-1.21.5 worlds wrap the map in {levels: {...}}.
-    if let Some(Tag::Compound(inner)) = map.get(&JavaString::from("levels")) {
-        return inner
-            .iter()
-            .filter_map(|(k, v)| {
-                Some((
-                    Arc::from(k.to_string_lossy().as_str()),
-                    int(v)?.clamp(1, 255) as u32,
-                ))
-            })
-            .collect();
-    }
+    let map = match map.get(&JavaString::from("levels")) {
+        Some(Tag::Compound(inner)) => inner,
+        _ => map,
+    };
+    // The keys are enchantment Identifiers: `knockback` is `minecraft:knockback`.
    map.iter()
        .filter_map(|(k, v)| {
-            Some((
-                Arc::from(k.to_string_lossy().as_str()),
-                int(v)?.clamp(1, 255) as u32,
-            ))
+            let id = horizon_world::datafix::dynamic::namespaced(&k.to_string_lossy());
+            Some((Arc::from(id), int(v)?.clamp(1, 255) as u32))
        })
        .collect()
 }
@@ -863,6 +855,22 @@ mod tests {
        assert_eq!(back.custom_name(), Some("Blade"));
    }

+    #[test]
+    fn enchantment_ids_without_a_namespace_are_minecraft_ones() {
+        let levels = Tag::compound([
+            ("knockback", Tag::Int(2)),
+            ("minecraft:sharpness", Tag::Int(1)),
+        ]);
+        let components = Tag::compound([("minecraft:enchantments", levels)]);
+        let (_, extra) = decode_components(Some(&components));
+        let stack = ItemStack {
+            extra,
+            ..ItemStack::new("minecraft:wooden_sword", 1)
+        };
+        assert_eq!(stack.enchantment_level("minecraft:knockback"), 2);
+        assert_eq!(stack.enchantment_level("minecraft:sharpness"), 1);
+    }
+
    #[test]
    fn custom_name_reads_the_extra_spans() {
        let name = Tag::compound([
@@ -1051,7 +1051,7 @@ impl LootContext<'_> {
                continue;
            }
            // LootPool: rolls.getInt (Mth.randomBetweenInclusive for uniform rolls).
-            let rolls = ctx.int_number(&pool["rolls"], random).max(0) as u32;
+            let rolls = LootContext::int_number(&pool["rolls"], random).max(0) as u32;
            for _ in 0..rolls {
                let mut produced = Vec::new();
                ctx.choose(
@@ -1085,7 +1085,7 @@ impl LootContext<'_> {
    fn enchantment_level(&self, id: &str) -> u32 {
        self.held.map_or(0, |h| h.enchantment_level(id))
    }
-    fn number<R: RandomSource>(&self, v: &Value, random: &mut R) -> f32 {
+    fn number<R: RandomSource>(v: &Value, random: &mut R) -> f32 {
        match v {
            Value::Number(n) => n.as_f64().unwrap_or(0.0) as f32,
            Value::Object(o) => match o
@@ -1097,8 +1097,8 @@ impl LootContext<'_> {
                    o.get("value").and_then(Value::as_f64).unwrap_or(0.0) as f32
                }
                "minecraft:uniform" => {
-                    let min = self.number(o.get("min").unwrap_or(&Value::Null), random);
-                    let max = self.number(o.get("max").unwrap_or(&Value::Null), random);
+                    let min = Self::number(o.get("min").unwrap_or(&Value::Null), random);
+                    let max = Self::number(o.get("max").unwrap_or(&Value::Null), random);
                    // UniformGenerator.getFloat / getInt (Mth.nextInt) differ; use int for counts.
                    if max <= min {
                        min
@@ -1107,8 +1107,8 @@ impl LootContext<'_> {
                    }
                }
                "minecraft:binomial" => {
-                    let n = self.number(o.get("n").unwrap_or(&Value::Null), random) as u32;
-                    let p = self.number(o.get("p").unwrap_or(&Value::Null), random);
+                    let n = Self::number(o.get("n").unwrap_or(&Value::Null), random) as u32;
+                    let p = Self::number(o.get("p").unwrap_or(&Value::Null), random);
                    (0..n).filter(|_| random.next_float() < p).count() as f32
                }
                _ => 1.0,
@@ -1116,22 +1116,22 @@ impl LootContext<'_> {
            _ => 1.0,
        }
    }
-    fn int_number<R: RandomSource>(&self, v: &Value, random: &mut R) -> i32 {
+    fn int_number<R: RandomSource>(v: &Value, random: &mut R) -> i32 {
        if let Value::Object(o) = v
            && o.get("type")
                .and_then(Value::as_str)
                .unwrap_or("minecraft:uniform")
                == "minecraft:uniform"
        {
-            let min = self.int_number(o.get("min").unwrap_or(&Value::Null), random);
-            let max = self.int_number(o.get("max").unwrap_or(&Value::Null), random);
+            let min = Self::int_number(o.get("min").unwrap_or(&Value::Null), random);
+            let max = Self::int_number(o.get("max").unwrap_or(&Value::Null), random);
            return if max <= min {
                min
            } else {
                min + random.next_int_bound(max - min + 1).unwrap_or(0)
            };
        }
-        self.number(v, random).round() as i32
+        Self::number(v, random).round() as i32
    }
    fn condition<R: RandomSource>(&self, c: &Value, random: &mut R) -> bool {
        let (kind, c) = match c {
@@ -1157,7 +1157,7 @@ impl LootContext<'_> {
                .into_iter()
                .flatten()
                .all(|t| self.condition(t, random)),
-            "minecraft:random_chance" => random.next_float() < self.number(&c["chance"], random),
+            "minecraft:random_chance" => random.next_float() < Self::number(&c["chance"], random),
            "minecraft:table_bonus" => {
                // BonusLevelTableCondition: chances[min(level, len - 1)].
                let level =
@@ -1378,7 +1378,7 @@ impl LootContext<'_> {
            }
            match f["type"].as_str().or(f["function"].as_str()).unwrap_or("") {
                "minecraft:set_count" => {
-                    let n = self.int_number(&f["count"], random);
+                    let n = Self::int_number(&f["count"], random);
                    let base = if f["add"].as_bool() == Some(true) {
                        stack.count as i32
                    } else {
@@ -1421,7 +1421,7 @@ impl LootContext<'_> {
                    // Attacker's level x count, rounded (looting).
                    let level = self.enchantment_level(f["enchantment"].as_str().unwrap_or(""));
                    if level > 0 && self.killed_by_player && self.block.is_empty() {
-                        let add = level as f32 * self.number(&f["count"], random);
+                        let add = level as f32 * Self::number(&f["count"], random);
                        stack.count = (stack.count as i32 + add.round() as i32).max(0) as u32;
                        if let Some(limit) = f["limit"].as_i64().filter(|l| *l > 0) {
                            stack.count = stack.count.min(limit as u32);
@@ -1,432 +0,0 @@
-//! Java (OptiFine/Iris) shader packs in `shaderpacks/` (docs/shader-packs.md):
-//! a folder holding `shaders/`, or a `.zip`. `horizon-shaderpack` translates
-//! their full-screen programs (`begin`, `prepare`, `deferred`, `composite`,
-//! `final`) to WGSL, and `gfx/java_stages.rs` runs them over Horizon's world
-//! as Iris runs them over its own. Of the geometry programs, the terrain's
-//! (`gbuffers_terrain`, `gbuffers_water` and their fallbacks) draw Horizon's
-//! terrain (`gfx/java_terrain.rs`); the rest of the world is Horizon's.
-use horizon_shaderpack::{
-    JavaPack,
-    pipeline::{Directives, GeometryProgram, Pass, Program, TargetSettings},
-    preprocess::Environment,
-    properties::{Blend, SkyDirectives},
-    uniforms::CustomUniforms,
-};
-use std::{
-    collections::{BTreeMap, BTreeSet},
-    path::Path,
-};
-
-/// The passes of one program folder (`world0`, or `""` for the pack's root).
-pub struct JavaFolder {
-    pub folder: String,
-    pub targets: Vec<TargetSettings>,
-    /// `begin*`, `prepare*`, `deferred*`, `composite*`, in order.
-    pub passes: Vec<Program>,
-    /// How many of `passes` run before the world (`begin*`, `prepare*`): the
-    /// world's colour and depth enter `world_target` and `depthtex*` after them.
-    pub world_at: usize,
-    /// The colour target the world goes into, where the pack's terrain
-    /// program draws (MakeUp: colortex1).
-    pub world_target: u32,
-    /// The targets whose alternate side the world is written to.
-    pub flipped_after_prepare: BTreeSet<u32>,
-    pub final_pass: Option<Program>,
-    /// The targets whose alternate side holds the frame's last write.
-    pub flipped_at_end: BTreeSet<u32>,
-    /// `sunPathRotation`, `eyeBrightnessHalflife`, `wetnessHalflife` and
-    /// `drynessHalflife`.
-    pub directives: Directives,
-    /// The programs Horizon's solid and translucent terrain are drawn with,
-    /// each translated for instanced and flat draws (`variants[0]`).
-    pub terrain: Option<GeometryProgram>,
-    pub water: Option<GeometryProgram>,
-    /// How many of `passes` run before translucent terrain (`begin*`,
-    /// `prepare*`, `deferred*`).
-    pub translucent_at: usize,
-    pub flipped_after_translucent: BTreeSet<u32>,
-    /// Each draw buffer's blending in `terrain` and `water`.
-    pub terrain_blends: Vec<Option<wgpu::BlendState>>,
-    pub water_blends: Vec<Option<wgpu::BlendState>>,
-}
-
-/// The key of `texture.noise` (`noisetex`) in [`JavaPasses::custom_textures`].
-pub const NOISE_KEY: &str = "noise";
-
-/// The key of `texture.<stage>.<sampler>` in [`JavaPasses::custom_textures`]
-/// for a pass of `program` (`world0/composite2`): Iris's texture stages, where
-/// `final` reads the `composite` ones.
-pub fn texture_key(program: &str, sampler: &str) -> String {
-    let name = program.rsplit('/').next().unwrap_or(program);
-    let stage = match name.trim_end_matches(|c: char| c.is_ascii_digit()) {
-        "final" => "composite",
-        stage => stage,
-    };
-    format!("{stage}.{sampler}")
-}
-
-/// A loaded Java pack.
-pub struct JavaPasses {
-    pub folders: Vec<JavaFolder>,
-    /// `uniform.*` / `variable.*` from `shaders.properties`.
-    pub uniforms: CustomUniforms,
-    /// What the pack keeps of the vanilla sky (`clouds`, `sun`, `moon`).
-    pub sky: SkyDirectives,
-    /// `block.properties`: block name → `mc_Entity` id.
-    pub block_ids: BTreeMap<String, i32>,
-    /// `texture.<stage>.<sampler>` and `texture.noise` images, by
-    /// `"<stage>.<sampler>"` and [`NOISE_KEY`].
-    pub custom_textures: BTreeMap<String, crate::shader_pack::Rgba>,
-}
-
-impl JavaPasses {
-    /// The folder Iris uses in `dimension` (0 overworld, -1 the Nether, 1 the
-    /// End): `world<N>` when the pack has one, else `world0`, else the root.
-    pub fn folder_for(&self, dimension: i8) -> Option<usize> {
-        let find = |name: &str| self.folders.iter().position(|f| f.folder == name);
-        find(&format!("world{dimension}"))
-            .or_else(|| find("world0"))
-            .or_else(|| find(""))
-    }
-}
-
-/// A folder holding `shaders/`, or a zip.
-pub fn is_java_pack(path: &Path) -> bool {
-    path.join("shaders").is_dir()
-        || path.is_file()
-            && path
-                .extension()
-                .is_some_and(|e| e.eq_ignore_ascii_case("zip"))
-}
-
-/// The `MC_GL_VENDOR_*` name of a wgpu adapter (`AdapterInfo::vendor`, a
-/// PCI id; Apple's GPUs report 0).
-pub fn vendor_name(vendor: u32, adapter: &str) -> &'static str {
-    match vendor {
-        0x10de => "NVIDIA Corporation",
-        0x1002 | 0x1022 => "AMD",
-        0x8086 => "Intel",
-        _ if adapter.starts_with("Apple") => "Apple",
-        _ => "Unknown",
-    }
-}
-
-/// Open the pack at `path` and translate its full-screen passes with the
-/// player's `values`; `vendor` and `renderer` name the GPU to the pack.
-pub fn load(
-    path: &Path,
-    values: &BTreeMap<String, String>,
-    vendor: &str,
-    renderer: &str,
-) -> Result<JavaPasses, String> {
-    let pack = JavaPack::open(path)?;
-    let values = pack.values(values);
-    let env = Environment::iris(vendor, renderer, 4);
-    let properties = pack.properties(&values, &env)?;
-    let mut names: Vec<&str> = ["world0", "world-1", "world1"]
-        .into_iter()
-        .filter(|d| {
-            pack.programs
-                .iter()
-                .any(|p| p.starts_with(&format!("{d}/")))
-        })
-        .collect();
-    if pack.programs.iter().any(|p| !p.contains('/')) {
-        names.push("");
-    }
-    let mut folders = Vec::new();
-    for name in names {
-        let plan = pack.passes(name, &values, &env, &properties)?;
-        let compile = |pass| {
-            let program = pack.compile(pass, &plan.targets, &values, &env, &properties)?;
-            if let Some((image, _)) = program.fragment.interface.images.first() {
-                return Err(format!(
-                    "{}: images ({image}) aren't supported yet",
-                    program.pass.program
-                ));
-            }
-            Ok::<_, String>(program)
-        };
-        let early = plan.begin.iter().chain(&plan.prepare);
-        let passes = early
-            .clone()
-            .chain(&plan.deferred)
-            .chain(&plan.composite)
-            .map(compile)
-            .collect::<Result<Vec<_>, _>>()?;
-        let final_pass = plan.final_pass.as_ref().map(compile).transpose()?;
-        if passes.is_empty() && final_pass.is_none() {
-            continue;
-        }
-        // A geometry program that doesn't translate leaves that terrain to
-        // Horizon, with a warning.
-        let geometry = |pass: &Option<horizon_shaderpack::pipeline::Pass>, alpha_test| {
-            let pass = pass.as_ref()?;
-            let glues = [false, true].map(|flat| crate::gfx::java_terrain::glue(flat, alpha_test));
-            match pack.compile_geometry(pass, &plan.targets, &values, &env, &properties, &glues) {
-                Ok(program) => Some(program),
-                Err(e) => {
-                    log::warn!("Horizon: shader pack {}: {e}", pass.program);
-                    None
-                }
-            }
-        };
-        // Iris's alpha test of cutout terrain (`AlphaTests.ONE_TENTH_ALPHA`).
-        let terrain = geometry(&plan.terrain, Some(0.1));
-        let water = terrain.as_ref().and_then(|_| geometry(&plan.water, None));
-        let translucent_at = early.clone().count() + plan.deferred.len();
-        let blends = |g: &Option<GeometryProgram>, default| {
-            g.as_ref().map_or_else(Vec::new, |g| {
-                pass_blends(&g.program.pass, &g.program.draw_buffers, default)
-            })
-        };
-        let terrain_blends = blends(&terrain, None);
-        // Vanilla's translucent blending (`BlendFunction.TRANSLUCENT`).
-        let water_blends = blends(
-            &water,
-            Some(wgpu::BlendState {
-                color: wgpu::BlendComponent {
-                    src_factor: wgpu::BlendFactor::SrcAlpha,
-                    dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                    operation: wgpu::BlendOperation::Add,
-                },
-                alpha: wgpu::BlendComponent {
-                    src_factor: wgpu::BlendFactor::One,
-                    dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                    operation: wgpu::BlendOperation::Add,
-                },
-            }),
-        );
-        folders.push(JavaFolder {
-            folder: name.to_owned(),
-            targets: plan.targets,
-            world_at: early.count(),
-            world_target: plan.world_target,
-            passes,
-            flipped_after_prepare: plan.flipped_after_prepare,
-            final_pass,
-            flipped_at_end: plan.flipped_at_end,
-            directives: plan.directives,
-            terrain,
-            water,
-            translucent_at,
-            flipped_after_translucent: plan.flipped_after_translucent,
-            terrain_blends,
-            water_blends,
-        });
-    }
-    if folders.is_empty() {
-        return Err("no deferred, composite or final programs".into());
-    }
-    let mut custom_textures = BTreeMap::new();
-    for tex in properties.custom_textures() {
-        let key = match tex.stage {
-            Some(stage) => format!("{stage}.{}", tex.sampler),
-            None if tex.sampler == NOISE_KEY => NOISE_KEY.to_owned(),
-            None => continue,
-        };
-        // Only PNGs for now: resource locations and raw `.dat` textures are
-        // skipped and the sampler reads what it would without them.
-        let image = pack
-            .files
-            .read_bytes(&tex.path)
-            .ok_or_else(|| "not in the pack".to_owned())
-            .and_then(|bytes| crate::shader_pack::decode_png(&bytes));
-        match image {
-            Ok(image) => {
-                custom_textures.insert(key, image);
-            }
-            Err(e) => log::warn!("Horizon: shader pack texture {}: {e}", tex.path),
-        }
-    }
-    let uniforms = properties.custom_uniforms();
-    for problem in &uniforms.problems {
-        log::warn!("Horizon: shader pack custom uniform {problem}");
-    }
-    let block_ids = pack.block_ids(&values, &env).unwrap_or_else(|e| {
-        log::warn!("Horizon: shader pack {e}");
-        BTreeMap::new()
-    });
-    Ok(JavaPasses {
-        folders,
-        uniforms,
-        sky: properties.sky(),
-        custom_textures,
-        block_ids,
-    })
-}
-
-/// Each draw buffer's blending, as Iris's `BlendModeOverride`:
-/// `blend.<program>.<buffer>`, else `blend.<program>`, else `default`
-/// (none for full-screen passes, vanilla's for the geometry programs).
-pub(crate) fn pass_blends(
-    pass: &Pass,
-    draw_buffers: &[u32],
-    default: Option<wgpu::BlendState>,
-) -> Vec<Option<wgpu::BlendState>> {
-    let all = pass.blend.as_ref().map_or(default, blend_state);
-    draw_buffers
-        .iter()
-        .map(|i| {
-            pass.buffer_blends
-                .iter()
-                .find(|(b, _)| b == i)
-                .map_or(all, |(_, b)| blend_state(b))
-        })
-        .collect()
-}
-
-/// A `blend.*` value as wgpu's blending (`off`: none). The factors are the
-/// GL ones `ShaderProperties` accepts.
-pub(crate) fn blend_state(blend: &Blend) -> Option<wgpu::BlendState> {
-    let Blend::Factors(factors) = blend else {
-        return None;
-    };
-    let factor = |name: &str| {
-        use wgpu::BlendFactor as F;
-        match name {
-            "ZERO" => F::Zero,
-            "SRC_COLOR" => F::Src,
-            "ONE_MINUS_SRC_COLOR" => F::OneMinusSrc,
-            "DST_COLOR" => F::Dst,
-            "ONE_MINUS_DST_COLOR" => F::OneMinusDst,
-            "SRC_ALPHA" => F::SrcAlpha,
-            "ONE_MINUS_SRC_ALPHA" => F::OneMinusSrcAlpha,
-            "DST_ALPHA" => F::DstAlpha,
-            "ONE_MINUS_DST_ALPHA" => F::OneMinusDstAlpha,
-            "SRC_ALPHA_SATURATE" => F::SrcAlphaSaturated,
-            _ => F::One,
-        }
-    };
-    let component = |src: &str, dst: &str| wgpu::BlendComponent {
-        src_factor: factor(src),
-        dst_factor: factor(dst),
-        operation: wgpu::BlendOperation::Add,
-    };
-    Some(wgpu::BlendState {
-        color: component(&factors[0], &factors[1]),
-        alpha: component(&factors[2], &factors[3]),
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn custom_textures_belong_to_iris_s_stages() {
-        assert_eq!(texture_key("world0/composite2", "gaux1"), "composite.gaux1");
-        assert_eq!(texture_key("final", "colortex4"), "composite.colortex4");
-        assert_eq!(
-            texture_key("world-1/deferred10", "noisetex"),
-            "deferred.noisetex"
-        );
-        assert_eq!(texture_key("prepare", "depthtex2"), "prepare.depthtex2");
-    }
-
-    #[test]
-    fn loads_the_full_screen_passes_of_a_java_pack() {
-        let dir = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../horizon-shaderpack/tests/fixtures/passes");
-        assert!(is_java_pack(&dir));
-        let pack = load(&dir, &BTreeMap::new(), "Apple", "Apple M4 Pro").unwrap();
-        let [folder] = &pack.folders[..] else {
-            panic!("one folder, the root");
-        };
-        assert_eq!(folder.folder, "");
-        assert_eq!(
-            folder
-                .passes
-                .iter()
-                .map(|p| p.pass.program.as_str())
-                .collect::<Vec<_>>(),
-            ["deferred", "composite", "composite1"]
-        );
-        assert_eq!(folder.world_at, 0);
-        assert!(folder.final_pass.is_some());
-        // The overworld, the Nether and the End all use the root.
-        assert_eq!([-1, 0, 1].map(|d| pack.folder_for(d)), [Some(0); 3]);
-        assert_eq!(
-            vendor_name(0x10de, "NVIDIA GeForce RTX 4080"),
-            "NVIDIA Corporation"
-        );
-        assert_eq!(vendor_name(0, "Apple M4 Pro"), "Apple");
-    }
-
-    /// wgpu is given the WGSL text: it must parse again.
-    fn reparse_error(pack: &JavaPasses) -> Option<String> {
-        let passes = pack
-            .folders
-            .iter()
-            .flat_map(|f| f.passes.iter().chain(&f.final_pass));
-        let geometry = pack
-            .folders
-            .iter()
-            .flat_map(|f| f.terrain.iter().chain(&f.water));
-        passes
-            .flat_map(|p| [(p, &p.vertex, "vsh"), (p, &p.fragment, "fsh")])
-            .chain(geometry.flat_map(|g| {
-                let p = &g.program;
-                [(p, &p.vertex, "vsh"), (p, &p.fragment, "fsh")]
-                    .into_iter()
-                    .chain(g.variants.iter().map(move |v| (p, v, "vsh (flat)")))
-            }))
-            .find_map(|(p, t, ext)| {
-                let e = naga::front::wgsl::parse_str(&t.wgsl).err()?;
-                Some(format!(
-                    "{}.{ext}: {}",
-                    p.pass.program,
-                    e.emit_to_string(&t.wgsl)
-                ))
-            })
-    }
-
-    /// The packs in `HORIZON_TEST_SHADERPACKS` (folders or zips) load as the
-    /// game loads them, with their default options: the compatibility table
-    /// of docs/shader-packs.md. Skipped when the variable isn't set.
-    #[test]
-    fn real_packs_load() {
-        let Some(dir) = std::env::var_os("HORIZON_TEST_SHADERPACKS") else {
-            return;
-        };
-        let mut entries: Vec<_> = std::fs::read_dir(dir)
-            .unwrap()
-            .flatten()
-            .map(|e| e.path())
-            .filter(|p| is_java_pack(p))
-            .collect();
-        entries.sort();
-        let mut failures = Vec::new();
-        for path in entries {
-            let name = path.file_name().unwrap().to_string_lossy().into_owned();
-            match load(&path, &BTreeMap::new(), "Apple", "Apple M4 Pro") {
-                Ok(pack) if let Some(e) = reparse_error(&pack) => {
-                    println!("{name}: {e}");
-                    failures.push(name);
-                }
-                Ok(pack) => {
-                    let folders: Vec<String> = pack
-                        .folders
-                        .iter()
-                        .map(|f| {
-                            let n = f.passes.len() + usize::from(f.final_pass.is_some());
-                            let geometry: Vec<&str> = f
-                                .terrain
-                                .iter()
-                                .chain(&f.water)
-                                .map(|g| g.program.pass.program.as_str())
-                                .collect();
-                            format!("{} {n} passes, terrain {geometry:?}", f.folder)
-                        })
-                        .collect();
-                    println!("{name}: loads ({})", folders.join(", "));
-                }
-                Err(e) => {
-                    println!("{name}: {e}");
-                    failures.push(name);
-                }
-            }
-        }
-        assert!(failures.is_empty(), "{failures:?}");
-    }
-}
@@ -206,6 +206,9 @@ pub struct Guest {
    /// (Entity.DATA_AIR_SUPPLY_ID, Player.DATA_PLAYER_ABSORPTION_ID); their
    /// defaults until either changes.
    pub sent_air: (i32, f32),
+    /// The shared flags (Entity.DATA_SHARED_FLAGS_ID) the player's client was
+    /// last sent about itself.
+    pub sent_shared: i8,
    /// Where the player last died (Player.lastDeathLocation), sent with the respawn.
    pub last_death: Option<[i32; 3]>,
    /// The last action sequence to acknowledge at the next tick (-1: none).
@@ -336,6 +339,7 @@ impl Guest {
            sent_health: None,
            sent_xp: None,
            sent_air: (300, 0.0),
+            sent_shared: 0,
            last_death: None,
            ack_up_to: std::cell::Cell::new(-1),
            sent_selected: 0,
@@ -432,6 +436,13 @@ pub fn stack_to_network(
    item_id: impl Fn(&str) -> i32,
    enchantment_id: impl Fn(&str) -> Option<i32>,
    s: &Option<ItemStack>,
+) -> Option<Stack> {
+    network_stack(&item_id, &enchantment_id, s)
+}
+fn network_stack(
+    item_id: &dyn Fn(&str) -> i32,
+    enchantment_id: &dyn Fn(&str) -> Option<i32>,
+    s: &Option<ItemStack>,
 ) -> Option<Stack> {
    let s = s.as_ref()?;
    let mut stack = Stack::new(item_id(&s.item), s.count as i32);
@@ -488,6 +499,18 @@ pub fn stack_to_network(
                horizon_protocol::item::Component::Int(i32::from(mode)),
            ));
        }
+        // A loaded crossbow's ammunition.
+        if !d.charged.is_empty() {
+            let charged = d
+                .charged
+                .iter()
+                .filter_map(|c| network_stack(item_id, enchantment_id, &Some(c.clone())))
+                .collect();
+            stack.added.push((
+                horizon_protocol::item::component::CHARGED_PROJECTILES,
+                horizon_protocol::item::Component::Stacks(charged),
+            ));
+        }
        // The books a lectern shows and a guest reads.
        if !d.writable_pages.is_empty() {
            stack.added.push((
@@ -1477,16 +1477,7 @@ impl Hub {
        attributes: Vec<play::AttributeSnapshot>,
    ) -> EntityState {
        let (sneaking, sprinting, gliding, sleeping) = flags;
-        let mut shared = 0i8;
-        if sneaking {
-            shared |= 0x02;
-        }
-        if sprinting {
-            shared |= 0x08;
-        }
-        if gliding {
-            shared |= -128;
-        }
+        let shared = shared_flags(sneaking, sprinting, gliding);
        let pose = if sleeping {
            2
        } else if gliding {
@@ -1764,6 +1755,18 @@ impl Hub {
                }));
            }
        }
+        // ServerEntity.sendDirtyEntityData: the shared flags go to the player
+        // too, so the sprint a hit stops (Player.causeExtraKnockback) stops
+        // on its client.
+        let g = &mut self.guests[i];
+        let shared = shared_flags(g.sneaking, g.sprinting, g.fall_flying);
+        if shared != g.sent_shared {
+            g.sent_shared = shared;
+            g.send(&C::SetEntityData(play::SetEntityData {
+                id: g.entity_id,
+                values: vec![(0, serializer::BYTE, Value::Byte(shared))],
+            }));
+        }
        // Sent when the health or the food level changes, or the saturation
        // reaches or leaves zero; a dead player's health of 0 too.
        let g = &mut self.guests[i];
@@ -1981,14 +1984,15 @@ impl Hub {
                    self.guests[i].sneaking = p.flags & 32 != 0;
                    self.guests[i].sprinting = p.flags & 64 != 0 && p.flags & 1 != 0;
                }
-                // OPEN_INVENTORY is the game's: the ridden mount's inventory.
-                S::PlayerCommand(p) if p.action == 5 => {
+                // OPEN_INVENTORY (the ridden mount's inventory) and
+                // START_FALL_FLYING (checked against the guest's chest slot
+                // and effects) are the game's.
+                S::PlayerCommand(p) if matches!(p.action, 5 | 6) => {
                    events.push(HostEvent::Packet(conn, Box::new(S::PlayerCommand(p))));
                }
                S::PlayerCommand(p) => match p.action {
                    1 => self.guests[i].sprinting = true,
                    2 => self.guests[i].sprinting = false,
-                    6 => self.guests[i].fall_flying = true,
                    // STOP_SLEEPING.
                    0 => self.wake(i),
                    _ => {}
@@ -2479,6 +2483,7 @@ impl Hub {
        g.sent_health = None;
        g.sent_xp = None;
        g.sent_air = (300, 0.0);
+        g.sent_shared = 0;
        let (cx, cz) = g.chunk();
        g.send(&C::SetChunkCacheCenter(play::SetChunkCacheCenter {
            x: cx,
@@ -2518,6 +2523,21 @@ fn ticking_state(rate: f32, frozen: bool) -> C {
    raw(ids::TICKING_STATE, w.data)
 }

+/// Entity.DATA_SHARED_FLAGS_ID of a player: crouching, sprinting, gliding.
+fn shared_flags(sneaking: bool, sprinting: bool, gliding: bool) -> i8 {
+    let mut shared = 0i8;
+    if sneaking {
+        shared |= 0x02;
+    }
+    if sprinting {
+        shared |= 0x08;
+    }
+    if gliding {
+        shared |= -128;
+    }
+    shared
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -95,7 +95,6 @@ pub mod item_data;
 pub mod item_render;
 pub mod item_tooltip;
 pub mod items;
-pub mod java_pack;
 pub mod java_text;
 pub mod key_names;
 pub mod keybinds;
@@ -159,7 +158,6 @@ pub mod screen_layout;
 pub mod sculk;
 pub use horizon_server_files as server;
 pub mod settings;
-pub mod shader_pack;
 pub mod shadows;
 pub mod signs;
 pub mod skins;
@@ -987,6 +987,12 @@ pub enum MobEvent {
        pos: [i32; 3],
        state: horizon_world::registry::BlockStateId,
    },
+    /// `DoorBlock.setOpen` by a mob (`InteractWithDoor`): the door opens or
+    /// closes, both halves, with its sound and game event.
+    SetDoorOpen {
+        pos: [i32; 3],
+        open: bool,
+    },
    /// Destroy a block, dropping nothing (sheep eating grass becomes dirt via SetBlock).
    BreakBlock {
        pos: [i32; 3],
@@ -1602,6 +1608,8 @@ impl Mob {
                | Species::Fox
                | Species::Panda
        );
+        // The PathNavigation constructor: the base follow range.
+        mob.ai.nav.max_visited_nodes = (mob.kind.follow_range * 16.0).floor() as i32;
        ai::register(&mut mob);
        mob
    }
@@ -2277,7 +2285,7 @@ mod sensor_scan_tests {
    use horizon_core::geometry::Vec3;
    use serde_json::json;

-    fn kind() -> Arc<MobType> {
+    pub(super) fn kind() -> Arc<MobType> {
        Arc::new(MobType {
            id: "minecraft:cow".into(),
            species: Species::Cow,
@@ -2481,56 +2489,9 @@ mod sensor_scan_tests {
 }
 #[cfg(test)]
 mod push_tests {
+    use super::sensor_scan_tests::kind;
    use super::*;
    use horizon_core::geometry::Vec3;
-    use serde_json::json;
-
-    fn kind() -> Arc<MobType> {
-        Arc::new(MobType {
-            id: "minecraft:cow".into(),
-            species: Species::Cow,
-            width: 0.9,
-            height: 1.4,
-            eye_height: 1.3,
-            category: "creature".into(),
-            max_health: 10.0,
-            speed: 0.2,
-            flying_speed: 0.4,
-            attack_damage: 0.0,
-            attack_knockback: 0.0,
-            follow_range: 16.0,
-            step_height: 0.6,
-            armor: 0.0,
-            armor_toughness: 0.0,
-            knockback_resistance: 0.0,
-            jump_strength: 0.42,
-            attributes: Arc::default(),
-            gravity: 0.08,
-            safe_fall_distance: 3.0,
-            fall_damage_multiplier: 1.0,
-            water_efficiency: 0.0,
-            water_slowdown: 0.8,
-            air_speed: 0.02,
-            baby_scale: 0.5,
-            head_rot_speed: 10.0,
-            max_head_x_rot: 40.0,
-            max_head_y_rot: 75.0,
-            ambient_interval: 120,
-            flags: Flags {
-                animal: true,
-                ..Default::default()
-            },
-            model: Arc::new(Part::parse("root", &json!({}))),
-            layers: HashMap::new(),
-            texture: String::new(),
-            brain: Brain::Passive,
-            anim: Anim::Rabbit,
-            sounds: [""; 3],
-            step_sound: None,
-            food: Arc::default(),
-            tempt: Arc::default(),
-        })
-    }

    /// The pending pushes as one list, scanned for each mob, as before.
    fn take_old(events: &mut Vec<MobEvent>, from: usize, pending: &mut Vec<(u32, Vec3)>) {
@@ -405,7 +405,7 @@ pub fn tick(
    }
    // Mob.tickHeadTurn -> BodyRotationControl.clientTick (a frozen
    // creaking's waits).
-    if m.alive() && !(super::creaking::is_creaking(m) && !super::creaking::can_move(m)) {
+    if m.alive() && (!super::creaking::is_creaking(m) || super::creaking::can_move(m)) {
        m.body_rotation_tick();
    }
    events.append(&mut m.outbox);
@@ -752,8 +752,8 @@ impl Mob {
    pub fn pushable(&self) -> bool {
        self.alive()
            && !matches!(self.species(), Species::Bat | Species::Shulker)
-            && !(self.kind.flags.climber && self.climbing)
-            && !(self.species() == Species::Creaking && !super::creaking::can_move(self))
+            && (!self.kind.flags.climber || !self.climbing)
+            && (self.species() != Species::Creaking || super::creaking::can_move(self))
    }
 }
 /// LivingEntity.onClimbable for the pusher (Spider.onClimbable: climbing a wall).
@@ -780,7 +780,7 @@ fn push_entities(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
    let self_pushable = m.alive()
        && m.species() != Species::Shulker
        && !on_climbable(m, w)
-        && !(m.species() == Species::Creaking && !super::creaking::can_move(m));
+        && (m.species() != Species::Creaking || super::creaking::can_move(m));
    let mut targets: Vec<(Who, Vec3)> = Vec::new();
    if let Some(p) = &w.player
        // Entity.push: passengers of the same vehicle never push each other.
@@ -26,7 +26,7 @@ pub fn register(m: &mut Mob) {
    };
    m.ai.nav.kind = NavKind::Flying;
    // FlyingPathNavigation.setRequiredPathLength(48).
-    m.ai.nav.required_path_length = 48.0;
+    m.set_required_path_length(48.0);
    let g = &mut m.ai.goals;
    g.add(0, Panic::new(2.5));
    g.add(1, Fetch);
@@ -9,7 +9,12 @@
 //! own random drives positions, sounds and jumps. `RunOne` shuffles with a
 //! random of its own, seeded with the brain's `shuffle_seed` when it is
 //! built.
-use super::{Mob, MobEvent, MobWorld, Species, Who, path::Path, sniffer};
+use super::{
+    Mob, MobEvent, MobWorld, Species, Who,
+    brain::{Timed, living_near},
+    path::Path,
+    sniffer,
+};
 use horizon_core::{
    geometry::Vec3,
    random::{LegacyRandom, RandomSource},
@@ -603,22 +608,7 @@ fn tick_sensors(m: &mut Mob, w: &MobWorld) {
 /// `NearestLivingEntitySensor`: everything alive within the follow range,
 /// nearest first.
 fn sense_living(m: &mut Mob, w: &MobWorld) {
-    let r = m.attrs.follow_range;
-    let area = m.bounds().inflate(Vec3::new(r, r, r));
-    let mut found: Vec<(Who, f64)> = Vec::new();
-    for o in w.others_near(area) {
-        if o.id != m.id && o.alive && o.bounds.intersects(area) {
-            found.push((Who::Mob(o.id), m.distance_sqr(o.position)));
-        }
-    }
-    if let Some(p) = &w.player
-        && p.alive
-        && p.bounds.intersects(area)
-    {
-        found.push((Who::Player, m.distance_sqr(p.position)));
-    }
-    found.sort_by(|a, b| a.1.total_cmp(&b.1));
-    let list: Vec<Who> = found.into_iter().map(|(w, _)| w).collect();
+    let list = living_near(m, w);
    let mm = mem(m);
    mm.mobs.set_list(list.clone());
    mm.visible_mobs.set(Visible {
@@ -794,37 +784,6 @@ fn followable_friendly(s: Species) -> bool {

 // ---- Behaviours ------------------------------------------------------------

-/// `Behavior`'s running state and end time.
-#[derive(Clone, Copy, Debug)]
-struct Timed {
-    running: bool,
-    end: i64,
-    min: i32,
-    max: i32,
-}
-impl Timed {
-    fn new(min: i32, max: i32) -> Self {
-        Self {
-            running: false,
-            end: 0,
-            min,
-            max,
-        }
-    }
-    /// `Behavior.tryStart`'s duration draw.
-    fn begin(&mut self, cx: &mut Bx) {
-        self.running = true;
-        let bound = self.max.wrapping_add(1).wrapping_sub(self.min);
-        let d = self
-            .min
-            .wrapping_add(cx.lr.next_int_bound(bound).unwrap_or(0));
-        self.end = cx.now + i64::from(d);
-    }
-    fn timed_out(&self, now: i64) -> bool {
-        now > self.end
-    }
-}
-
 /// `RunOne`: shuffles its children by weight and starts the first that can.
 #[derive(Clone, Debug)]
 struct Gate {
@@ -1076,7 +1035,7 @@ impl B {
                {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                mem(m).walk_target.clear();
                mem(m).look_target.clear();
                m.add_effect("minecraft:regeneration", 200, 0);
@@ -1086,7 +1045,7 @@ impl B {
                if !swim_condition(m) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::AnimalPanic { t, .. } => {
@@ -1094,7 +1053,7 @@ impl B {
                if !(mm.hurt_by.get() == Some(&true) || mm.is_panicking.present()) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                if brain_mut(m).kind == Kind::Sniffer {
                    reset_sniffing(m, cx);
                }
@@ -1123,7 +1082,7 @@ impl B {
                let reached = reached(m, cx.w, &walk);
                if !reached && compute_path(m, cx, &walk, path, speed) {
                    *last_target = walk.target.block(cx.w);
-                    t.begin(cx);
+                    t.begin(cx.lr, cx.now);
                    mem(m).path.set_opt(path.clone());
                    m.nav_move_to_path(path.clone(), f64::from(*speed));
                    return true;
@@ -1139,21 +1098,21 @@ impl B {
                if !mem(m).temptation_cooldown_ticks.present() {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::CountDownGaze(t) => {
                if !mem(m).gaze_cooldown_ticks.present() {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::CountDownTransport(t) => {
                if !mem(m).transport_items_cooldown_ticks.present() {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::Transport(x) => x.try_start(m, cx),
@@ -1171,7 +1130,7 @@ impl B {
                let Some(partner) = breed_partner(m, cx.w) else {
                    return false;
                };
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                if brain_mut(m).kind == Kind::Sniffer {
                    reset_sniffing(m, cx);
                }
@@ -1200,7 +1159,7 @@ impl B {
                {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                if brain_mut(m).kind == Kind::Sniffer {
                    reset_sniffing(m, cx);
                }
@@ -1210,14 +1169,14 @@ impl B {
                if !mem(m).look_target.present() {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::FeelingHappy(t) => {
                if !mem(m).sniffer_happy.present() {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                transition(m, cx, sniffer::FEELING_HAPPY);
                true
            }
@@ -1233,7 +1192,7 @@ impl B {
                if !can_sniff(m) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                transition(m, cx, sniffer::DIGGING);
                true
            }
@@ -1246,7 +1205,7 @@ impl B {
                {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                transition(m, cx, sniffer::RISING);
                true
            }
@@ -1261,7 +1220,7 @@ impl B {
                if !can_sniff(m) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                transition(m, cx, sniffer::SEARCHING);
                true
            }
@@ -1278,7 +1237,7 @@ impl B {
                if is_tempted(m) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                transition(m, cx, sniffer::SCENTING);
                true
            }
@@ -1293,12 +1252,12 @@ impl B {
                if m.is_baby() || !can_sniff(m) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                transition(m, cx, sniffer::SNIFFING);
                true
            }
            B::DoNothing(t) => {
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::AxolotlAction { .. }
@@ -138,7 +138,7 @@ pub fn register(m: &mut Mob) {
    };
    m.ai.nav.kind = NavKind::Flying;
    m.ai.nav.can_open_doors = false;
-    m.ai.nav.required_path_length = 48.0;
+    m.set_required_path_length(48.0);
    m.set_malus(PathType::Fire, -1.0);
    m.set_malus(PathType::Water, -1.0);
    m.set_malus(PathType::WaterBorder, 16.0);
@@ -1046,7 +1046,7 @@ impl Goal for GrowCrop {
    }
    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
        // The 0.3 roll comes only after the crop count: it draws randomness.
-        let usable = !get(m).is_some_and(|b| b.crops_grown >= 10)
+        let usable = get(m).is_none_or(|b| b.crops_grown < 10)
            && m.random.next_float() >= 0.3
            && has_nectar(m)
            && hive_valid(m, cx.w);
@@ -1,8 +1,11 @@
 //! Pieces of vanilla's `Brain` that species implemented as brains share:
 //! memories that expire, behaviour durations, walk targets and
 //! `MoveToTargetSink`.
-use super::{Mob, goals::Cx};
-use horizon_core::random::RandomSource;
+use super::{Mob, MobWorld, Who, goals::Cx};
+use horizon_core::{
+    geometry::Vec3,
+    random::{LegacyRandom, RandomSource},
+};

 /// A memory with an expiry (`Brain.setMemoryWithExpiry`): present for the
 /// tick it was set and `ttl` more ticks. `Ttl::default()` is absent.
@@ -25,6 +28,57 @@ impl Ttl {
        }
    }
 }
+/// `Behavior`'s bookkeeping in the brains ported behaviour for behaviour
+/// (villager, animal, monster, warden): running, and until when.
+#[derive(Clone, Copy, Debug)]
+pub struct Timed {
+    pub running: bool,
+    pub end: i64,
+    pub min: i32,
+    pub max: i32,
+}
+impl Timed {
+    pub fn new(min: i32, max: i32) -> Self {
+        Self {
+            running: false,
+            end: 0,
+            min,
+            max,
+        }
+    }
+    /// `Behavior.tryStart`'s duration draw from the level random, in Java's
+    /// int arithmetic (made even when it cannot vary).
+    pub fn begin(&mut self, lr: &mut LegacyRandom, now: i64) {
+        self.running = true;
+        let bound = self.max.wrapping_add(1).wrapping_sub(self.min);
+        let d = self.min.wrapping_add(lr.next_int_bound(bound).unwrap_or(0));
+        self.end = now + i64::from(d);
+    }
+    /// `Behavior.timedOut`.
+    pub fn timed_out(&self, now: i64) -> bool {
+        now > self.end
+    }
+}
+/// `NearestLivingEntitySensor`'s scan: the living entities (the player
+/// among them) whose boxes meet the follow range around `m`, nearest first.
+pub fn living_near(m: &Mob, w: &MobWorld) -> Vec<Who> {
+    let r = m.attrs.follow_range;
+    let area = m.bounds().inflate(Vec3::new(r, r, r));
+    let mut found: Vec<(Who, f64)> = Vec::new();
+    for o in w.others_near(area) {
+        if o.id != m.id && o.alive && o.bounds.intersects(area) {
+            found.push((Who::Mob(o.id), m.distance_sqr(o.position)));
+        }
+    }
+    if let Some(p) = &w.player
+        && p.alive
+        && p.bounds.intersects(area)
+    {
+        found.push((Who::Player, m.distance_sqr(p.position)));
+    }
+    found.sort_by(|a, b| a.1.total_cmp(&b.1));
+    found.into_iter().map(|(w, _)| w).collect()
+}
 /// A random duration in `min..=max` (`Behavior`'s end time).
 pub fn duration(m: &mut Mob, min: i32, max: i32) -> i32 {
    if max <= min {
@@ -26,7 +26,7 @@ pub const DROPPING_NO_ITEM: u8 = 4;
 pub const WEATHER: [&str; 4] = ["unaffected", "exposed", "weathered", "oxidized"];

 pub fn register(m: &mut Mob) {
-    m.ai.nav.required_path_length = 48.0;
+    m.set_required_path_length(48.0);
    m.ai.nav.can_open_doors = true;
    m.persistent = true;
    // nextWeatheringTick starts unset (-1); waxed is -2.
@@ -464,6 +464,7 @@ pub fn finalize_spawn(m: &mut Mob, lr: &mut LegacyRandom) {
    let bonus = lr.triangle(0.0, 0.114_850_000_000_000_01);
    // ADD_MULTIPLIED_BASE on the base value.
    m.attrs.follow_range += m.kind.follow_range * bonus;
+    m.update_max_visited_nodes();
    let _left_handed = lr.next_float() < 0.05;
 }
 fn wrap_degrees(angle: f32) -> f32 {
@@ -559,7 +559,10 @@ fn refresh(m: &mut Mob, a: Attr) {
    match a {
        Attr::MaxHealth => m.attrs.max_health = value(m, a) as f32,
        Attr::MovementSpeed => m.attrs.speed = base_with_modifiers(m, a),
-        Attr::FollowRange => m.attrs.follow_range = value(m, a),
+        Attr::FollowRange => {
+            m.attrs.follow_range = value(m, a);
+            m.update_max_visited_nodes();
+        }
        Attr::AttackDamage => m.attrs.attack_damage = value(m, a) as f32,
        Attr::KnockbackResistance => m.attrs.knockback_resistance = value(m, a),
        Attr::SpawnReinforcements => m.attrs.spawn_reinforcements = value(m, a),
@@ -39,6 +39,10 @@ fn setup(m: &mut Mob, baby: bool) {
    m.ai.look.wanted = [0.0; 3];
    m.ai.look.cooldown = 0;
    m.extra.counter2 = 0;
+    // The new navigation's PathNavigation constructor.
+    m.ai.nav.required_path_length = 16.0;
+    m.ai.nav.max_visited_nodes =
+        (super::finalize::base_value(m, super::finalize::Attr::FollowRange) * 16.0).floor() as i32;
    if baby {
        m.ai.look.kind = LookKind::Default;
        m.ai.mov.kind = MoveKind::Flying {
@@ -48,7 +52,7 @@ fn setup(m: &mut Mob, baby: bool) {
        // BabyFlyingPathNavigation.
        m.ai.nav.kind = NavKind::Flying;
        m.ai.nav.can_float = true;
-        m.ai.nav.required_path_length = 48.0;
+        m.set_required_path_length(48.0);
        return;
    }
    if was == 1 {
@@ -167,9 +167,9 @@ impl MobWorld<'_> {
                    let Ok(block) = self.collision.collision_block(state) else {
                        continue;
                    };
-                    if !block.large_collision_shape
-                        && !block.moving_piston
-                        && !(column && meets(Axis::Y, y))
+                    if !(block.large_collision_shape
+                        || block.moving_piston
+                        || (column && meets(Axis::Y, y)))
                    {
                        continue;
                    }
@@ -50,7 +50,7 @@ pub fn is_illager(s: &Seen) -> bool {
    )
 }
 pub fn register(m: &mut Mob) {
-    m.ai.nav.required_path_length = 40.0;
+    m.set_required_path_length(40.0);
    let tempt = m.kind.tempt.clone();
    let trader = is_trader(m);
    if trader {
@@ -11,9 +11,10 @@
 //! seeded when the brain is built.
 use super::{
    Mob, MobEvent, MobWorld, Species, Who,
+    brain::{Timed, living_near},
    goals::Cx,
    path::Path,
-    villager_brain::{NEVER, Slot, Tracker, Visible, WalkTarget},
+    villager_brain::{NEVER, Slot, Tracker, Visible, WalkTarget, compute_path, reached},
 };
 use crate::projectiles::{Projectile, ProjectileKind};
 use horizon_core::{
@@ -129,6 +130,10 @@ fn brain_mut(m: &mut Mob) -> &mut Brain {
 fn mem(m: &mut Mob) -> &mut Memories {
    &mut brain_mut(m).mem
 }
+/// `CANT_REACH_WALK_TARGET_SINCE`, for `compute_path`.
+fn cant_reach(m: &mut Mob) -> &mut Slot<i64> {
+    &mut mem(m).cant_reach_walk_target_since
+}
 fn mem_ref(m: &Mob) -> &Memories {
    &brain(m).expect("brain").mem
 }
@@ -292,22 +297,7 @@ fn tick_sensors(m: &mut Mob, w: &MobWorld) {
 /// `NearestLivingEntitySensor`: everything alive within the follow range,
 /// nearest first.
 fn sense_living(m: &mut Mob, w: &MobWorld) {
-    let r = m.attrs.follow_range;
-    let area = m.bounds().inflate(Vec3::new(r, r, r));
-    let mut found: Vec<(Who, f64)> = Vec::new();
-    for o in w.others_near(area) {
-        if o.id != m.id && o.alive && o.bounds.intersects(area) {
-            found.push((Who::Mob(o.id), m.distance_sqr(o.position)));
-        }
-    }
-    if let Some(p) = &w.player
-        && p.alive
-        && p.bounds.intersects(area)
-    {
-        found.push((Who::Player, m.distance_sqr(p.position)));
-    }
-    found.sort_by(|a, b| a.1.total_cmp(&b.1));
-    let list: Vec<Who> = found.into_iter().map(|(w, _)| w).collect();
+    let list = living_near(m, w);
    let mm = mem(m);
    mm.mobs.set_list(list.clone());
    mm.visible_mobs.set(Visible {
@@ -456,31 +446,6 @@ fn sense_breeze_attack(m: &mut Mob, w: &MobWorld) {

 // ---- Behaviours ---------------------------------------------------------

-/// `Behavior`'s bookkeeping: running, and until when.
-#[derive(Clone, Debug)]
-struct Timed {
-    running: bool,
-    end: i64,
-    min: i32,
-    max: i32,
-}
-impl Timed {
-    fn new(min: i32, max: i32) -> Self {
-        Self {
-            running: false,
-            end: 0,
-            min,
-            max,
-        }
-    }
-    /// `Behavior.tryStart`'s duration draw from the level random.
-    fn begin(&mut self, cx: &mut Bx) {
-        self.running = true;
-        let d = self.min + cx.lr.next_int_bound(self.max + 1 - self.min).unwrap_or(0);
-        self.end = cx.now + i64::from(d);
-    }
-}
-
 /// `StartAttacking`'s target finders.
 #[derive(Clone, Copy, Debug)]
 enum Finder {
@@ -607,14 +572,14 @@ impl B {
                if *creaking && !super::creaking::can_move(m) || !swim_condition(m) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::LookAtTargetSink(t) => {
                if !mem(m).look_target.present() {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::MoveToTargetSink {
@@ -636,9 +601,9 @@ impl B {
                }
                let walk = mm.walk_target.value().unwrap();
                let reached = reached(m, cx.w, &walk);
-                if !reached && compute_path(m, cx, &walk, path, speed) {
+                if !reached && compute_path(m, cx.w, cx.now, &walk, path, speed, cant_reach) {
                    *last_target = walk.target.block(cx.w);
-                    t.begin(cx);
+                    t.begin(cx.lr, cx.now);
                    // start
                    mem(m).path.set_opt(path.clone());
                    m.nav_move_to_path(path.clone(), f64::from(*speed));
@@ -712,14 +677,14 @@ impl B {
                            .is_some_and(|l| l.contains(&Who::Player));
                    !reachable
                };
-                if !(can_attack(m, cx.w, target) && !tired && alive && !stop_when) {
+                if !can_attack(m, cx.w, target) || tired || !alive || stop_when {
                    set_attack_target(m, None);
                }
                *running = true;
                true
            }
            B::DoNothing(t) => {
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::RandomStroll(running, speed) => {
@@ -848,7 +813,7 @@ impl B {
                    mem(m).breeze_shoot.clear();
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                // start
                super::breeze::set_pose(m, super::breeze::SHOOTING);
                mem(m).breeze_shoot_charging.set_ttl((), 15);
@@ -867,7 +832,7 @@ impl B {
                if !long_jump_can_run(m, cx) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                // start
                if !mem(m).breeze_jump_inhaling.present() {
                    mem(m).breeze_jump_inhaling.set_ttl((), 10);
@@ -905,7 +870,7 @@ impl B {
                if !stuck {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                mem(m).breeze_shoot.set_ttl((), 60);
                true
            }
@@ -924,7 +889,7 @@ impl B {
                {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                slide_start(m, cx);
                true
            }
@@ -989,7 +954,7 @@ impl B {
                    && let Some(now_target) = walk.target.block(cx.w)
                {
                    let d = manhattan_sq(now_target, last);
-                    if d > 4 && compute_path(m, cx, &walk, path, speed) {
+                    if d > 4 && compute_path(m, cx.w, cx.now, &walk, path, speed, cant_reach) {
                        *last_target = Some(now_target);
                        mem(m).path.set_opt(path.clone());
                        m.nav_move_to_path(path.clone(), f64::from(*speed));
@@ -1122,53 +1087,6 @@ fn tracker_visible(m: &mut Mob, w: &MobWorld, t: Tracker) -> bool {
        _ => true,
    }
 }
-/// `MoveToTargetSink.reachedTarget`.
-fn reached(m: &Mob, w: &MobWorld, walk: &WalkTarget) -> bool {
-    walk.target.block(w).is_some_and(|p| {
-        let h = block_of(m.position);
-        (p[0] - h[0]).abs() + (p[1] - h[1]).abs() + (p[2] - h[2]).abs() <= walk.close
-    })
-}
-/// `MoveToTargetSink.tryComputePath`.
-fn compute_path(
-    m: &mut Mob,
-    cx: &mut Bx,
-    walk: &WalkTarget,
-    path: &mut Option<Path>,
-    speed: &mut f32,
-) -> bool {
-    let Some(target) = walk.target.block(cx.w) else {
-        return false;
-    };
-    *path = m.create_path_to(cx.w, target, 0);
-    *speed = walk.speed;
-    if reached(m, cx.w, walk) {
-        mem(m).cant_reach_walk_target_since.clear();
-    } else {
-        let can_reach = path.as_ref().is_some_and(|p| p.reached);
-        let mm = mem(m);
-        if can_reach {
-            mm.cant_reach_walk_target_since.clear();
-        } else if !mm.cant_reach_walk_target_since.present() {
-            mm.cant_reach_walk_target_since.set(cx.now);
-        }
-        if path.is_some() {
-            return true;
-        }
-        let to = [
-            f64::from(target[0]) + 0.5,
-            f64::from(target[1]),
-            f64::from(target[2]) + 0.5,
-        ];
-        if let Some(step) =
-            m.default_random_pos_towards(cx.w, 10, 7, to, f64::from(std::f32::consts::FRAC_PI_2))
-        {
-            *path = m.create_path_to(cx.w, block_of(Vec3::new(step[0], step[1], step[2])), 0);
-            return path.is_some();
-        }
-    }
-    false
-}
 /// `BehaviorUtils.isWithinAttackRange(body, target, 1)` for a mob without a
 /// ranged weapon: `Mob.isWithinMeleeAttackRange`.
 fn within_attack_range(m: &Mob, w: &MobWorld, target: Who) -> bool {
@@ -37,7 +37,11 @@ pub struct Navigation {
    reach_range: i32,
    pub max_visited_multiplier: f32,
    pub stuck: bool,
+    /// Set through [`Mob::set_required_path_length`].
    pub required_path_length: f32,
+    /// `PathFinder.maxVisitedNodes`: the base follow range times 16 when the
+    /// navigation is made, then [`Mob::update_max_visited_nodes`].
+    pub max_visited_nodes: i32,
    pub can_float: bool,
    pub can_open_doors: bool,
    pub can_pass_doors: bool,
@@ -68,6 +72,7 @@ impl Default for Navigation {
            max_visited_multiplier: 1.0,
            stuck: false,
            required_path_length: 16.0,
+            max_visited_nodes: 256,
            can_float: false,
            can_open_doors: false,
            can_pass_doors: true,
@@ -147,6 +152,16 @@ impl Mob {
    fn max_path_length(&self) -> f32 {
        (self.attrs.follow_range as f32).max(self.ai.nav.required_path_length)
    }
+    /// `PathNavigation.updatePathfinderMaxVisitedNodes`: after a follow range
+    /// change and a new required path length.
+    pub fn update_max_visited_nodes(&mut self) {
+        self.ai.nav.max_visited_nodes = (self.max_path_length() * 16.0).floor() as i32;
+    }
+    /// `PathNavigation.setRequiredPathLength`.
+    pub fn set_required_path_length(&mut self, length: f32) {
+        self.ai.nav.required_path_length = length;
+        self.update_max_visited_nodes();
+    }
    fn can_update_path(&self) -> bool {
        match self.ai.nav.kind {
            NavKind::Ground | NavKind::WallClimber => self.on_ground || self.is_in_liquid(),
@@ -237,8 +252,8 @@ impl Mob {
            return Some(path.clone());
        }
        let pm = self.path_mob();
-        let max_visited = ((self.attrs.follow_range * 16.0).floor() as f32
-            * self.ai.nav.max_visited_multiplier) as i32;
+        let max_visited =
+            (self.ai.nav.max_visited_nodes as f32 * self.ai.nav.max_visited_multiplier) as i32;
        let finder = Finder::new(w, &pm, self.ai.nav.evaluator());
        let path = finder.find(targets, max_len, reach, max_visited);
        if let Some(p) = &path {
@@ -426,7 +426,7 @@ impl Goal for MoveThroughVillage {
            self.visited.remove(0);
        }
        let Some(s) = state(m) else { return false };
-        if !(s.active_raid && !s.raid_over) || m.ai.target.is_some() {
+        if !s.active_raid || s.raid_over || m.ai.target.is_some() {
            return false;
        }
        let Some(homes) = s.homes.clone() else {
@@ -46,7 +46,7 @@ pub fn register(m: &mut Mob) {
    // Villager's constructor: its brain does everything, it has no goals.
    m.ai.nav.can_open_doors = true;
    m.ai.nav.can_float = true;
-    m.ai.nav.required_path_length = 48.0;
+    m.set_required_path_length(48.0);
 }

 /// `LivingEntity.addParticlesAroundSelf`: five particles about the body.
@@ -614,6 +614,144 @@ pub fn meet(
        gossiped: ready,
    }
 }
+/// `Villager.spawnGolemIfNeeded` up to the spawn: villager `i` wants a golem
+/// and so do at least `needed` of the villagers whose boxes meet its own grown
+/// by 10 blocks. Returns all of those villagers: once the golem stands, they
+/// remember it ([`super::villager_brain::golem_detected`]).
+pub fn golem_summoners(mobs: &[Mob], i: usize, now: i64, needed: usize) -> Option<Vec<usize>> {
+    if !ext(&mobs[i]).is_some_and(|e| e.wants_golem(now)) {
+        return None;
+    }
+    let area = mobs[i]
+        .bounds()
+        .inflate(horizon_core::geometry::Vec3::new(10.0, 10.0, 10.0));
+    let near: Vec<usize> = mobs
+        .iter()
+        .enumerate()
+        .filter(|(_, m)| {
+            m.species() == Species::Villager && !m.removed && m.bounds().intersects(area)
+        })
+        .map(|(j, _)| j)
+        .collect();
+    let wanting = near
+        .iter()
+        .filter(|&&j| ext(&mobs[j]).is_some_and(|e| e.wants_golem(now)))
+        .take(5)
+        .count();
+    (wanting >= needed).then_some(near)
+}
+/// `SpawnUtil.Strategy.LEGACY_IRON_GOLEM`'s refused floors.
+fn golem_floor_ok(name: &str) -> bool {
+    !matches!(
+        name,
+        "minecraft:cobweb"
+            | "minecraft:cactus"
+            | "minecraft:glass_pane"
+            | "minecraft:conduit"
+            | "minecraft:ice"
+            | "minecraft:tnt"
+            | "minecraft:glowstone"
+            | "minecraft:beacon"
+            | "minecraft:sea_lantern"
+            | "minecraft:frosted_ice"
+            | "minecraft:tinted_glass"
+            | "minecraft:glass"
+    ) && !name.ends_with("_stained_glass_pane")
+        && !name.ends_with("_stained_glass")
+        && !name.ends_with("leaves")
+}
+/// One attempt of `SpawnUtil.trySpawnMob(IRON_GOLEM, ..., 8 across, 6 up and
+/// down, LEGACY_IRON_GOLEM)`: a column drawn near `start`, searched down from
+/// 6 above for a solid floor (or powder snow) under air or a liquid block.
+/// Returns the block the golem would stand in.
+fn golem_attempt<L: super::spawn_rules::SpawnLevel>(
+    l: &L,
+    start: [i32; 3],
+    random: &mut impl RandomSource,
+) -> Option<[i32; 3]> {
+    let dx = random.next_int_bound(17).unwrap_or(8) - 8;
+    let dz = random.next_int_bound(17).unwrap_or(8) - 8;
+    let (x, z) = (start[0] + dx, start[2] + dz);
+    let name = |y: i32| -> &str { &l.facts().get(l.state(x, y, z)).name };
+    let mut y = start[1] + 6;
+    let mut above = l.state(x, y, z);
+    for _ in 0..=12 {
+        y -= 1;
+        let here = l.state(x, y, z);
+        let above_name = &*l.facts().get(above).name;
+        // BlockState.liquid(): a water or lava block (not a waterlogged one).
+        let open = l.facts().is_air(above)
+            || above_name == "minecraft:water"
+            || above_name == "minecraft:lava";
+        let solid = l.mob_data().state(here).flags & super::data::SOLID != 0
+            || name(y) == "minecraft:powder_snow";
+        if golem_floor_ok(name(y)) && open && solid {
+            return Some([x, y + 1, z]);
+        }
+        above = here;
+    }
+    None
+}
+/// `IronGolem.checkSpawnObstruction`: a floor with a full top face, its feet
+/// free whatever fluid is there, and the two blocks above free.
+fn golem_fits<L: super::spawn_rules::SpawnLevel>(l: &L, [x, y, z]: [i32; 3]) -> bool {
+    use super::spawn_rules::is_valid_empty_spawn;
+    // entityCanStandOn: Block.isFaceFull(collision shape, UP).
+    let floor = l.mob_data().state(l.state(x, y - 1, z));
+    let stands = floor.flags & super::data::STURDY_TOP != 0 && floor.top >= 1.0;
+    // isValidEmptySpawnBlock with Fluids.EMPTY: open water is free too.
+    let feet = is_valid_empty_spawn(Species::IronGolem, l, x, y, z)
+        || &*l.facts().get(l.state(x, y, z)).name == "minecraft:water";
+    stands
+        && feet
+        && is_valid_empty_spawn(Species::IronGolem, l, x, y + 1, z)
+        && is_valid_empty_spawn(Species::IronGolem, l, x, y + 2, z)
+}
+/// `SpawnUtil.trySpawnMob(IRON_GOLEM, MOB_SUMMONED, level, start, 10, 8, 6,
+/// LEGACY_IRON_GOLEM, false)`: up to ten columns tried. In each spot found
+/// `create` makes the golem (`EntityType.create`: the yaw drawn here, then its
+/// `finalizeSpawn` draws, see [`finalize_summoned_golem`]); it is kept only
+/// when `IronGolem.checkSpawnObstruction` passes, and discarded otherwise.
+pub fn summon_golem<L: super::spawn_rules::SpawnLevel, R: RandomSource, T>(
+    l: &L,
+    start: [i32; 3],
+    random: &mut R,
+    mut create: impl FnMut(&mut R, horizon_core::geometry::Vec3, f32) -> T,
+) -> Option<T> {
+    for _ in 0..10 {
+        let Some([x, y, z]) = golem_attempt(l, start, random) else {
+            continue;
+        };
+        // Mth.wrapDegrees(nextFloat() * 360).
+        let mut yaw = random.next_float() * 360.0;
+        if yaw >= 180.0 {
+            yaw -= 360.0;
+        }
+        let at =
+            horizon_core::geometry::Vec3::new(f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5);
+        let golem = create(random, at, yaw);
+        if golem_fits(l, [x, y, z]) {
+            return Some(golem);
+        }
+    }
+    None
+}
+/// `Mob.finalizeSpawn` for a summoned iron golem, from the level's random:
+/// the follow range spawn bonus and left-handedness.
+pub fn finalize_summoned_golem(m: &mut Mob, random: &mut impl RandomSource) {
+    use super::finalize::{Attr, Op, add_modifier, has_modifier};
+    if !has_modifier(m, Attr::FollowRange, "minecraft:random_spawn_bonus") {
+        let bonus = random.triangle(0.0, 0.114_850_000_000_000_01);
+        add_modifier(
+            m,
+            Attr::FollowRange,
+            "minecraft:random_spawn_bonus",
+            bonus,
+            Op::AddMultipliedBase,
+        );
+    }
+    m.extra.left_handed = random.next_float() < 0.05;
+}
 /// `PoiManager.take(HOME, ..., 48)`: the nearest bed head not `claimed`
 /// (`free_head`: a bed head that is not occupied).
 pub fn take_vacant_bed(
@@ -11,6 +11,7 @@
 //! `Brain::shuffle_seed` when the brain is built.
 use super::{
    Mob, MobEvent, MobWorld, Species, Who,
+    brain::{Timed, living_near},
    path::{Path, PathNode},
 };
 use horizon_core::{
@@ -341,6 +342,10 @@ fn brain_mut(m: &mut Mob) -> &mut Brain {
 fn mem(m: &mut Mob) -> &mut Memories {
    &mut brain_mut(m).mem
 }
+/// `CANT_REACH_WALK_TARGET_SINCE`, for `compute_path`.
+fn cant_reach(m: &mut Mob) -> &mut Slot<i64> {
+    &mut mem(m).cant_reach_walk_target_since
+}
 fn mem_ref(m: &Mob) -> Option<&Memories> {
    brain(m).map(|b| &b.mem)
 }
@@ -565,22 +570,7 @@ const FOLLOW_RANGE: f64 = 16.0;
 /// `NearestLivingEntitySensor`: everything alive within the follow range,
 /// nearest first.
 fn sense_living(m: &mut Mob, w: &MobWorld) {
-    let r = m.attrs.follow_range;
-    let area = m.bounds().inflate(Vec3::new(r, r, r));
-    let mut found: Vec<(Who, f64)> = Vec::new();
-    for o in w.others_near(area) {
-        if o.id != m.id && o.alive && o.bounds.intersects(area) {
-            found.push((Who::Mob(o.id), m.distance_sqr(o.position)));
-        }
-    }
-    if let Some(p) = &w.player
-        && p.alive
-        && p.bounds.intersects(area)
-    {
-        found.push((Who::Player, m.distance_sqr(p.position)));
-    }
-    found.sort_by(|a, b| a.1.total_cmp(&b.1));
-    let list: Vec<Who> = found.into_iter().map(|(w, _)| w).collect();
+    let list = living_near(m, w);
    let mm = mem(m);
    mm.mobs.set_list(list.clone());
    mm.visible_mobs.set(Visible {
@@ -789,35 +779,15 @@ fn sense_golem(m: &mut Mob, w: &MobWorld) {
    }
 }

-// ---- Behaviours ---------------------------------------------------------
+/// `GolemSensor.golemDetected`: a golem was summoned near this villager;
+/// for 599 ticks it wants no other.
+pub fn golem_detected(m: &mut Mob, now: i64) {
+    mem(m).golem_detected_recently.set_ttl(true, 599);
+    // What `sync` derives from the memory.
+    super::villager::ext_mut(m).golem_until = now + 599 + 1;
+}

-/// `Behavior`'s bookkeeping: running, and until when.
-#[derive(Clone, Debug)]
-struct Timed {
-    running: bool,
-    end: i64,
-    min: i32,
-    max: i32,
-}
-impl Timed {
-    fn new(min: i32, max: i32) -> Self {
-        Self {
-            running: false,
-            end: 0,
-            min,
-            max,
-        }
-    }
-    /// `Behavior.tryStart`'s duration draw.
-    fn begin(&mut self, cx: &mut Bx) {
-        self.running = true;
-        let bound = self.max.wrapping_add(1).wrapping_sub(self.min);
-        let d = self
-            .min
-            .wrapping_add(cx.lr.next_int_bound(bound).unwrap_or(0));
-        self.end = cx.now + i64::from(d);
-    }
-}
+// ---- Behaviours ---------------------------------------------------------

 /// The POI types villagers use.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -1498,18 +1468,18 @@ impl B {
                if !swim_condition(m) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::LookAtTargetSink(t) => {
                if !mem(m).look_target.present() {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::PanicTrigger(t) => {
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                // VillagerPanicTrigger.start
                if panic_condition(m) {
                    if !brain_mut(m).is_active(Act::Panic) {
@@ -1542,9 +1512,9 @@ impl B {
                }
                let walk = mm.walk_target.value().unwrap();
                let reached = reached(m, cx.w, &walk);
-                if !reached && compute_path(m, cx, &walk, path, speed) {
+                if !reached && compute_path(m, cx.w, cx.now, &walk, path, speed, cant_reach) {
                    *last_target = walk.target.block(cx.w);
-                    t.begin(cx);
+                    t.begin(cx.lr, cx.now);
                    // start
                    mem(m).path.set_opt(path.clone());
                    m.nav_move_to_path(path.clone(), f64::from(*speed));
@@ -1561,7 +1531,7 @@ impl B {
                if !follow_trading_condition(m, cx.w) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                follow_trading_player(m);
                true
            }
@@ -1573,7 +1543,7 @@ impl B {
                if !matches!(a, Act::Idle | Act::Work | Act::Play) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::JumpOnBed {
@@ -1590,7 +1560,7 @@ impl B {
                if mm.walk_target.present() || !m.is_baby() {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                *bed = Some(nearest);
                *time_left = 100;
                *jumps = 3 + cx.lr.next_int_bound(4).unwrap_or(0);
@@ -1599,7 +1569,7 @@ impl B {
                true
            }
            B::DoNothing(t) => {
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::GiveGiftToHero {
@@ -1618,7 +1588,7 @@ impl B {
                    *until_next -= 1;
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                *given = false;
                *started = now;
                let mm = mem(m);
@@ -1630,7 +1600,7 @@ impl B {
                if !mem(m).interaction_target.present() || !show_trades_condition(m, cx.w) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                // start
                if let Some(target) = mem(m).interaction_target.value() {
                    mem(m).look_target.set(Tracker::Entity(target, true));
@@ -1646,7 +1616,7 @@ impl B {
                if !villager_target_valid(m, cx.w, Mem::InteractionTarget) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                let target = mem(m).interaction_target.value().unwrap();
                lock_gaze(m, target, cx);
                true
@@ -1659,7 +1629,7 @@ impl B {
                if !breeding_possible(m, cx.w) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                let target = mem(m).breed_target.value().unwrap();
                lock_gaze(m, target, cx);
                *birth = now + 275 + i64::from(m.random.next_int_bound(50).unwrap_or(0));
@@ -1680,7 +1650,7 @@ impl B {
                if !closer_to_center(site, m.position, 1.73) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                // start
                let mm = mem(m);
                mm.last_worked_at_poi.set(now);
@@ -1709,7 +1679,7 @@ impl B {
                *valid = farmland_around(m, cx.w);
                *target = pick_farmland(valid, cx);
                let Some(p) = *target else { return false };
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                if now > *next_ok {
                    let mm = mem(m);
                    mm.look_target.set(Tracker::Block(p));
@@ -2288,8 +2258,9 @@ impl B {
                {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                if now > *next_ok {
+                    close_doors(m, cx, None, None);
                    if super::villager::start_sleeping(m, home, w) {
                        mem(m).last_slept.set(now);
                    }
@@ -2609,7 +2580,7 @@ impl B {
                {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::LocateHidingPlace {
@@ -2769,7 +2740,7 @@ impl B {
                    && let Some(now_target) = walk.target.block(cx.w)
                {
                    let d = manhattan_sq(now_target, last);
-                    if d > 4 && compute_path(m, cx, &walk, path, speed) {
+                    if d > 4 && compute_path(m, cx.w, cx.now, &walk, path, speed, cant_reach) {
                        *last_target = Some(now_target);
                        mem(m).path.set_opt(path.clone());
                        m.nav_move_to_path(path.clone(), f64::from(*speed));
@@ -2806,8 +2777,8 @@ impl B {
                let on_or_over = jumpable(here) || jumpable([here[0], here[1] - 1, here[2]]);
                let still = m.is_baby()
                    && bed.is_some_and(jumpable)
-                    && !(!on_or_over && *time_left <= 0)
-                    && !(on_or_over && *jumps <= 0);
+                    && (on_or_over || *time_left > 0)
+                    && (!on_or_over || *jumps > 0);
                if !still {
                    self.do_stop(m, cx);
                    return;
@@ -3141,33 +3112,37 @@ fn tracker_visible(m: &mut Mob, w: &MobWorld, t: Tracker) -> bool {
    }
 }
 /// `MoveToTargetSink.reachedTarget`.
-fn reached(m: &Mob, w: &MobWorld, walk: &WalkTarget) -> bool {
+pub(super) fn reached(m: &Mob, w: &MobWorld, walk: &WalkTarget) -> bool {
    walk.target
        .block(w)
        .is_some_and(|p| manhattan(p, block_of(m.position)) <= walk.close)
 }
-/// `MoveToTargetSink.tryComputePath`.
-fn compute_path(
+/// `MoveToTargetSink.tryComputePath`, for the brains on these memories
+/// (villager, monster, warden): `cant_reach` is the brain's
+/// `CANT_REACH_WALK_TARGET_SINCE`.
+pub(super) fn compute_path(
    m: &mut Mob,
-    cx: &mut Bx,
+    w: &MobWorld,
+    now: i64,
    walk: &WalkTarget,
    path: &mut Option<Path>,
    speed: &mut f32,
+    cant_reach: fn(&mut Mob) -> &mut Slot<i64>,
 ) -> bool {
-    let Some(target) = walk.target.block(cx.w) else {
+    let Some(target) = walk.target.block(w) else {
        return false;
    };
-    *path = m.create_path_to(cx.w, target, 0);
+    *path = m.create_path_to(w, target, 0);
    *speed = walk.speed;
-    if reached(m, cx.w, walk) {
-        mem(m).cant_reach_walk_target_since.clear();
+    if reached(m, w, walk) {
+        cant_reach(m).clear();
    } else {
        let can_reach = path.as_ref().is_some_and(|p| p.reached);
-        let mm = mem(m);
+        let since = cant_reach(m);
        if can_reach {
-            mm.cant_reach_walk_target_since.clear();
-        } else if !mm.cant_reach_walk_target_since.present() {
-            mm.cant_reach_walk_target_since.set(cx.now);
+            since.clear();
+        } else if !since.present() {
+            since.set(now);
        }
        if path.is_some() {
            return true;
@@ -3178,14 +3153,14 @@ fn compute_path(
            f64::from(target[2]) + 0.5,
        ];
        if let Some(step) =
-            m.default_random_pos_towards(cx.w, 10, 7, to, f64::from(std::f32::consts::FRAC_PI_2))
+            m.default_random_pos_towards(w, 10, 7, to, f64::from(std::f32::consts::FRAC_PI_2))
        {
            let p = [
                step[0].floor() as i32,
                step[1].floor() as i32,
                step[2].floor() as i32,
            ];
-            *path = m.create_path_to(cx.w, p, 0);
+            *path = m.create_path_to(w, p, 0);
            return path.is_some();
        }
    }
@@ -3196,7 +3171,7 @@ fn follow_trading_condition(m: &Mob, w: &MobWorld) -> bool {
    m.extra.flag2
        && m.alive()
        && !m.fluids.in_water
-        && !(m.hurt_time > 0)
+        && m.hurt_time <= 0
        && w.player
            .as_ref()
            .is_some_and(|p| m.distance_sqr(p.position) <= 16.0)
@@ -3526,7 +3501,74 @@ fn walk_to_block_memory(
 }
 /// `InteractWithDoor`: open the doors on the path, close the ones passed.
 fn interact_with_doors(m: &mut Mob, cx: &mut Bx, from: PathNode, to: PathNode) {
-    let _ = (m, cx, from, to);
+    let (from, to) = ([from.x, from.y, from.z], [to.x, to.y, to.z]);
+    // The door being left is remembered even when it is open already; the
+    // one ahead only when this villager opens it.
+    for (p, always) in [(from, true), (to, false)] {
+        let Some(open) = door_open(cx.w, p) else {
+            continue;
+        };
+        if !open {
+            cx.events.push(MobEvent::SetDoorOpen { pos: p, open: true });
+        }
+        if always || !open {
+            remember_door(m, p);
+        }
+    }
+    close_doors(m, cx, Some(from), Some(to));
+}
+/// Whether the block at `p` is a door mobs open (`MOB_INTERACTABLE_DOORS`), and
+/// then whether it is open.
+fn door_open(w: &MobWorld, p: [i32; 3]) -> Option<bool> {
+    let name = w.block_name(p[0], p[1], p[2]);
+    (name.ends_with("_door") && w.has_tag("minecraft:mob_interactable_doors", name))
+        .then(|| w.prop(p[0], p[1], p[2], "open") == Some("true"))
+}
+fn remember_door(m: &mut Mob, p: [i32; 3]) {
+    let doors = &mut mem(m).doors_to_close;
+    match doors.get_mut() {
+        Some(list) if list.contains(&p) => {}
+        Some(list) => list.push(p),
+        None => doors.set(vec![p]),
+    }
+}
+/// `InteractWithDoor.closeDoorsThatIHaveOpenedOrPassedThrough`: the remembered
+/// doors other than the two of the step being taken are forgotten, and closed
+/// when still open, near (3 blocks) and no other villager within 2 blocks of
+/// one is passing through it.
+fn close_doors(m: &mut Mob, cx: &mut Bx, from: Option<[i32; 3]>, to: Option<[i32; 3]>) {
+    let Some(doors) = mem(m).doors_to_close.get().cloned() else {
+        return;
+    };
+    let near = mem(m).mobs.value().unwrap_or_default();
+    let mut kept = Vec::new();
+    for door in doors {
+        if from == Some(door) || to == Some(door) {
+            kept.push(door);
+            continue;
+        }
+        if !closer_to_center(door, m.position, 3.0) || door_open(cx.w, door) != Some(true) {
+            continue;
+        }
+        let passing = near.iter().any(|&who| {
+            let Who::Mob(id) = who else { return false };
+            cx.w.seen(id).is_some_and(|s| {
+                s.species == Species::Villager
+                    && closer_to_center(door, s.position, 2.0)
+                    && s.villager
+                        .as_ref()
+                        .and_then(|v| v.path_nodes)
+                        .is_some_and(|(prev, next)| prev.is_some_and(|p| p == door || next == door))
+            })
+        });
+        if !passing {
+            cx.events.push(MobEvent::SetDoorOpen {
+                pos: door,
+                open: false,
+            });
+        }
+    }
+    mem(m).doors_to_close.set(kept);
 }
 /// The scan order of POI candidates (before the nearest-first sort).
 fn pois_scan_order(_m: &Mob, found: &[(Poi, [i32; 3])]) -> Vec<usize> {
@@ -457,7 +457,7 @@ pub fn can_receive_vibration(m: &Mob, _now: i64, ctx: &Context) -> bool {
        && m.alive()
        && !st.brain.mem.vibration_cooldown.present()
        && !digging_or_emerging(m)
-        && !(ctx.living && !ctx.targetable)
+        && (!ctx.living || ctx.targetable)
 }
 /// `VibrationSystem.Listener.handleGameEvent` for the warden: a free
 /// listener within 16 blocks of its eyes schedules what it can hear.
@@ -14,9 +14,10 @@
 //! shuffle seed.
 use super::{
    Mob, MobEvent, MobWorld, Who,
+    brain::Timed,
    goals::Cx,
    path::Path,
-    villager_brain::{Slot, Tracker, Visible, WalkTarget},
+    villager_brain::{Slot, Tracker, Visible, WalkTarget, compute_path, reached},
    warden::{self, Pose},
 };
 use horizon_core::{
@@ -145,31 +146,6 @@ impl Memories {
    }
 }

-/// `Behavior`'s bookkeeping: running, and until when.
-#[derive(Clone, Debug)]
-struct Timed {
-    running: bool,
-    end: i64,
-    min: i32,
-    max: i32,
-}
-impl Timed {
-    fn new(min: i32, max: i32) -> Self {
-        Self {
-            running: false,
-            end: 0,
-            min,
-            max,
-        }
-    }
-    /// `Behavior.tryStart`'s duration draw (made even when it cannot vary).
-    fn begin(&mut self, cx: &mut Bx) {
-        self.running = true;
-        let d = self.min + cx.lr.next_int_bound(self.max + 1 - self.min).unwrap_or(0);
-        self.end = cx.now + i64::from(d);
-    }
-}
-
 /// `RunOne`'s `ShufflingList` over a stroll (weight 2) and `DoNothing` (1).
 #[derive(Clone, Debug)]
 struct Gate {
@@ -383,6 +359,10 @@ fn brain(m: &Mob) -> Option<&Brain> {
 pub(super) fn mem(m: &mut Mob) -> &mut Memories {
    &mut m.extra.warden.as_mut().expect("a warden").brain.mem
 }
+/// `CANT_REACH_WALK_TARGET_SINCE`, for `compute_path`.
+fn cant_reach(m: &mut Mob) -> &mut Slot<i64> {
+    &mut mem(m).cant_reach_walk_target_since
+}
 pub(super) fn mem_ref(m: &Mob) -> Option<&Memories> {
    brain(m).map(|b| &b.mem)
 }
@@ -558,9 +538,6 @@ fn find_closest(m: &mut Mob, w: &MobWorld, filter: impl Fn(&Mob, Who) -> bool) -
 fn block_of(p: Vec3) -> [i32; 3] {
    [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32]
 }
-fn manhattan(a: [i32; 3], b: [i32; 3]) -> i32 {
-    (a[0] - b[0]).abs() + (a[1] - b[1]).abs() + (a[2] - b[2]).abs()
-}
 fn dist_sqr(a: [i32; 3], b: [i32; 3]) -> i64 {
    (0..3).map(|i| i64::from(a[i] - b[i]).pow(2)).sum()
 }
@@ -607,57 +584,6 @@ fn tracker_visible(m: &mut Mob, w: &MobWorld, t: Tracker) -> bool {
        _ => true,
    }
 }
-/// `MoveToTargetSink.reachedTarget`.
-fn reached(m: &Mob, w: &MobWorld, walk: &WalkTarget) -> bool {
-    walk.target
-        .block(w)
-        .is_some_and(|p| manhattan(p, block_of(m.position)) <= walk.close)
-}
-/// `MoveToTargetSink.tryComputePath`.
-fn compute_path(
-    m: &mut Mob,
-    cx: &mut Bx,
-    walk: &WalkTarget,
-    path: &mut Option<Path>,
-    speed: &mut f32,
-) -> bool {
-    let Some(target) = walk.target.block(cx.w) else {
-        return false;
-    };
-    *path = m.create_path_to(cx.w, target, 0);
-    *speed = walk.speed;
-    if reached(m, cx.w, walk) {
-        mem(m).cant_reach_walk_target_since.clear();
-    } else {
-        let can_reach = path.as_ref().is_some_and(|p| p.reached);
-        let mm = mem(m);
-        if can_reach {
-            mm.cant_reach_walk_target_since.clear();
-        } else if !mm.cant_reach_walk_target_since.present() {
-            mm.cant_reach_walk_target_since.set(cx.now);
-        }
-        if path.is_some() {
-            return true;
-        }
-        let to = [
-            f64::from(target[0]) + 0.5,
-            f64::from(target[1]),
-            f64::from(target[2]) + 0.5,
-        ];
-        if let Some(step) =
-            m.default_random_pos_towards(cx.w, 10, 7, to, f64::from(std::f32::consts::FRAC_PI_2))
-        {
-            let p = [
-                step[0].floor() as i32,
-                step[1].floor() as i32,
-                step[2].floor() as i32,
-            ];
-            *path = m.create_path_to(cx.w, p, 0);
-            return path.is_some();
-        }
-    }
-    false
-}
 fn same_path(a: Option<&Path>, b: Option<&Path>) -> bool {
    match (a, b) {
        (None, None) => true,
@@ -710,7 +636,7 @@ impl B {
                if !swim_condition(m) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::SetWardenLookTarget(r) => one(r, || {
@@ -732,7 +658,7 @@ impl B {
                if !mem(m).look_target.present() {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::MoveToTargetSink {
@@ -755,9 +681,9 @@ impl B {
                    return false;
                };
                let reached = reached(m, cx.w, &walk);
-                if !reached && compute_path(m, cx, &walk, path, speed) {
+                if !reached && compute_path(m, cx.w, cx.now, &walk, path, speed, cant_reach) {
                    *last_target = walk.target.block(cx.w);
-                    t.begin(cx);
+                    t.begin(cx.lr, cx.now);
                    // start
                    mem(m).path.set_opt(path.clone());
                    m.nav_move_to_path(path.clone(), f64::from(*speed));
@@ -775,7 +701,7 @@ impl B {
                if !mm.is_emerging.present() || mm.walk_target.present() {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                warden::set_pose(m, Pose::Emerging);
                sound(m, "entity.warden.emerge", 5.0, 1.0, cx.events);
                true
@@ -791,7 +717,7 @@ impl B {
                if !(m.on_ground || liquid) {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                if m.on_ground {
                    warden::set_pose(m, Pose::Digging);
                    sound(m, "entity.warden.dig", 5.0, 1.0, cx.events);
@@ -872,7 +798,7 @@ impl B {
                true
            }),
            B::DoNothing(t) => {
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                true
            }
            B::GoToDisturbance(r) => one(r, || {
@@ -907,7 +833,7 @@ impl B {
                {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                sound(m, "entity.warden.sniff", 5.0, 1.0, cx.events);
                true
            }
@@ -919,7 +845,7 @@ impl B {
                let Some(target) = mm.roar_target.value() else {
                    return false;
                };
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                let mm = mem(m);
                mm.roar_sound_delay.set_ttl((), ROAR_SOUND_DELAY);
                mm.walk_target.clear();
@@ -1004,7 +930,7 @@ impl B {
                if !close {
                    return false;
                }
-                t.begin(cx);
+                t.begin(cx.lr, cx.now);
                let mm = mem(m);
                mm.attack_cooling_down
                    .set_ttl(true, i64::from(SONIC_DURATION));
@@ -1092,7 +1018,7 @@ impl B {
                    && let Some(walk) = mem(m).walk_target.value()
                    && let Some(now_target) = walk.target.block(cx.w)
                    && dist_sqr(now_target, last) > 4
-                    && compute_path(m, cx, &walk, path, speed)
+                    && compute_path(m, cx.w, cx.now, &walk, path, speed, cant_reach)
                {
                    *last_target = Some(now_target);
                    mem(m).path.set_opt(path.clone());
@@ -296,6 +296,10 @@ pub struct PlayerMotion {
    pub freeze_immune: bool,
    /// `Entity.oldPosition`: where this tick started.
    pub old_position: Vec3,
+    /// The server's copy of a player another client moves (a LAN guest), while
+    /// it travels on the server: `isLocalInstanceAuthoritative` is false, so
+    /// its moves check no fall damage.
+    pub server_copy: bool,
    /// `Entity.applyEffectsFromBlocks` runs after travel (always in the game;
    /// differential fixtures turn it off where their reference does).
    pub block_effects: bool,
@@ -460,6 +464,7 @@ impl PlayerMotion {
            leather_boots: false,
            freeze_immune: false,
            old_position: position,
+            server_copy: false,
            block_effects: true,
            powder_snow_entered: Vec::new(),
            hurt_log: Vec::new(),
@@ -467,6 +472,16 @@ impl PlayerMotion {
            border: None,
        })
    }
+    /// LivingEntity.aiStep: speeds too small to matter stop.
+    fn drop_tiny_velocity(&mut self) {
+        let v = &mut self.velocity;
+        if v.x * v.x + v.z * v.z < 9.0e-6 {
+            (v.x, v.z) = (0.0, 0.0);
+        }
+        if v.y.abs() < 0.003 {
+            v.y = 0.0;
+        }
+    }
    /// `Entity.getTicksRequiredToFreeze`.
    pub const TICKS_REQUIRED_TO_FREEZE: i32 = 140;
    /// `Entity.getPercentFrozen`.
@@ -920,15 +935,7 @@ impl MotionWorld<'_, '_, '_> {
        if self.player.no_jump_delay > 0 {
            self.player.no_jump_delay -= 1;
        }
-        let mut velocity = self.player.velocity;
-        if velocity.x * velocity.x + velocity.z * velocity.z < 9.0e-6 {
-            velocity.x = 0.0;
-            velocity.z = 0.0;
-        }
-        if velocity.y.abs() < 0.003 {
-            velocity.y = 0.0;
-        }
-        self.player.velocity = velocity;
+        self.player.drop_tiny_velocity();
        let mut input = match input {
            TickInput::Living(v) => Vec3::new(
                f64::from(v[0] * 0.98),
@@ -947,9 +954,38 @@ impl MotionWorld<'_, '_, '_> {
        }
        self.jump_phase()?;
        let before_travel = self.player.bounds();
-        // Player.travel: swim steering, then LivingEntity.travel (fluids
-        // first, then gliding, then air), keeping 0.6 of the vertical speed
-        // while flying.
+        self.player_travel(input)?;
+        if self.player.block_effects {
+            self.apply_effects_from_blocks()?;
+        }
+        // LivingEntity.aiStep "freezing" (server).
+        if !self.player.in_powder_snow || !self.player.can_freeze() {
+            self.player.ticks_frozen = (self.player.ticks_frozen - 2).max(0);
+        }
+        self.player.remove_frost()?;
+        let on = self.support(movement_support::LEGACY_SUPPORT_OFFSET)?;
+        let on_air = self.assets.registry.state(self.block(on)).is_none_or(|s| {
+            matches!(
+                s.name.as_str(),
+                "minecraft:air" | "minecraft:cave_air" | "minecraft:void_air"
+            )
+        });
+        self.player.try_add_frost(on_air)?;
+        if self.player.health.tick_count % 40 == 0
+            && self.player.is_fully_frozen()
+            && self.player.can_freeze()
+        {
+            self.freeze_damage()?;
+        }
+        if self.player.auto_spin_attack_ticks > 0 {
+            self.player.auto_spin_attack_ticks -= 1;
+            self.check_auto_spin_attack(before_travel);
+        }
+        Ok(())
+    }
+    /// Player.travel: swim steering, then LivingEntity.travel (fluids first,
+    /// then gliding, then air), keeping 0.6 of the vertical speed while flying.
+    fn player_travel(&mut self, input: Vec3) -> Result<()> {
        if self.player.swimming {
            let look_y =
                horizon_world::view_direction::view_vector(self.player.pitch, self.player.yaw).y;
@@ -979,34 +1015,29 @@ impl MotionWorld<'_, '_, '_> {
        if let Some(y) = flying_y {
            self.player.velocity.y = y * 0.6;
        }
-        if self.player.block_effects {
-            self.apply_effects_from_blocks()?;
-        }
-        // LivingEntity.aiStep "freezing" (server).
-        if !self.player.in_powder_snow || !self.player.can_freeze() {
-            self.player.ticks_frozen = (self.player.ticks_frozen - 2).max(0);
-        }
-        self.player.remove_frost()?;
-        let on = self.support(movement_support::LEGACY_SUPPORT_OFFSET)?;
-        let on_air = self.assets.registry.state(self.block(on)).is_none_or(|s| {
-            matches!(
-                s.name.as_str(),
-                "minecraft:air" | "minecraft:cave_air" | "minecraft:void_air"
-            )
-        });
-        self.player.try_add_frost(on_air)?;
-        if self.player.health.tick_count % 40 == 0
-            && self.player.is_fully_frozen()
-            && self.player.can_freeze()
-        {
-            self.freeze_damage()?;
-        }
-        if self.player.auto_spin_attack_ticks > 0 {
-            self.player.auto_spin_attack_ticks -= 1;
-            self.check_auto_spin_attack(before_travel);
-        }
        Ok(())
    }
+    /// ServerPlayer's own travel: the server simulates a player too
+    /// (`MoveSimulationType.AUTHORITATIVE_SIDE_AND_SERVER`), with no input
+    /// (it never sets xxa/zza). Only the delta movement it leaves stays: it
+    /// is what a hurt sends the player (`ServerEntity.sendChanges`), and
+    /// what the next knockback starts from; the client's next move places
+    /// the player.
+    pub fn server_travel(&mut self) -> Result<()> {
+        let p = &mut *self.player;
+        let (position, ground, collision) = (p.position, p.ground, p.collision);
+        let (history, fall_distance, steps) = (p.history.clone(), p.fall_distance, p.steps);
+        let events = p.events.len();
+        p.drop_tiny_velocity();
+        p.server_copy = true;
+        let travelled = self.player_travel(Vec3::ZERO);
+        let p = &mut *self.player;
+        p.server_copy = false;
+        (p.position, p.ground, p.collision) = (position, ground, collision);
+        (p.history, p.fall_distance, p.steps) = (history, fall_distance, steps);
+        p.events.truncate(events);
+        travelled
+    }
    /// `LivingEntity.checkAutoSpinAttack`: the first living entity in the
    /// box swept this tick takes the hit and ends the spin, bouncing the
    /// player back at a fifth of its speed; a wall ends it too.
@@ -1678,7 +1709,7 @@ impl EntityMoveWorld for MotionWorld<'_, '_, '_> {
        &mut self.player.history
    }
    fn locally_authoritative(&mut self) -> Result<bool> {
-        Ok(true)
+        Ok(!self.player.server_copy)
    }
    fn set_on_ground_with_movement(
        &mut self,
@@ -2327,6 +2358,64 @@ mod tests {
        assert_eq!(player.position.y, 4.0);
    }

+    #[test]
+    fn server_travel_moves_only_the_velocity() {
+        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = Assets::load(&root).unwrap();
+        let render = assets.reload(&root).unwrap();
+        let binding = crate::collisions::load(&root, assets.registry).unwrap();
+        let resources = MotionResources::load(&root, &assets).unwrap();
+        let mut scene = World::test_scene(&assets, &render, 1).unwrap();
+        let at = Vec3::new(20.5, 4.0, 20.5);
+        let mut player = PlayerMotion::new(&resources, at).unwrap();
+        let mut travel = |player: &mut PlayerMotion| {
+            MotionWorld {
+                entities: &[],
+                player,
+                scene: &mut scene,
+                assets: &assets,
+                collision_binding: &binding,
+                resources: &resources,
+            }
+            .server_travel()
+            .unwrap()
+        };
+        // A knockback on the ground (vanilla's server sends 0.21840 0.27516
+        // after a zombie's hit): ground friction, then gravity and drag.
+        player.ground.on_ground = true;
+        player.velocity = Vec3::new(-0.4, 0.3608, 0.0);
+        travel(&mut player);
+        assert!(
+            (player.velocity.x + 0.2184).abs() < 1e-6,
+            "{:?}",
+            player.velocity
+        );
+        assert!(
+            (player.velocity.y - 0.275184).abs() < 1e-6,
+            "{:?}",
+            player.velocity
+        );
+        assert_eq!(player.position, at);
+        assert!(player.ground.on_ground);
+        // Falling onto the ground hurts no one on the server's copy, and leaves
+        // the fall to the client's moves.
+        let health = player.health.health();
+        player.position = Vec3::new(20.5, 4.5, 20.5);
+        player.ground.on_ground = false;
+        player.fall_distance = 10.0;
+        player.velocity = Vec3::new(0.0, -1.0, 0.0);
+        travel(&mut player);
+        assert_eq!(player.velocity.y, -0.0784000015258789);
+        assert_eq!(player.health.health(), health);
+        assert_eq!(player.fall_distance, 10.0);
+        assert!(player.events.is_empty());
+    }
+
    #[test]
    fn spectator_scroll_speed_controls_horizontal_and_vertical_flight() {
        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
@@ -10,7 +10,6 @@ use crate::{
    keybinds::{self, CATEGORIES, KeyBinds, MAPPINGS},
    lang::{self, LanguageInfo},
    settings::{SOUND_SOURCES, Settings},
-    shader_pack::PackConfig,
    text::{self, Style, Text},
    ui,
 };
@@ -863,10 +862,6 @@ pub enum Page {
    Font,
    Packs,
    Mods,
-    /// The shader packs in `shaderpacks/`: pick one, open the folder.
-    ShaderPacks,
-    /// Interactive options and profiles for the active shader pack.
-    ShaderPackOptions,
    /// Horizon's graphics settings (`graphics_ui`).
    Graphics,
    GraphicsAdvanced,
@@ -898,17 +893,9 @@ enum Act {
    ResetPadKeys,
    ToggleMod(usize),
    OpenModFolder,
-    /// Pick shader pack `i` of `OptionsUi::shader_packs` (again: off).
-    ToggleShaderPack(usize),
-    OpenShaderPackFolder,
    /// Credits & Attribution's Credits button (WinScreen without the poem).
    Credits,
    CopyAgentDetails,
-    ShaderPackProfile,
-    ShaderPackSubscreen(String),
-    ShaderPackBackScreen,
-    ShaderPackOption(usize),
-    ResetShaderPackOptions,
 }
 enum WKind {
    Button {
@@ -921,11 +908,6 @@ enum WKind {
        value: f32,
        opt: Opt,
    },
-    ShaderOptionSlider {
-        label: Text,
-        value: f32,
-        index: usize,
-    },
    Text {
        text: Text,
        color: u32,
@@ -961,15 +943,10 @@ pub enum Event {
    Packs(Vec<String>),
    OpenPackFolder,
    OpenModFolder,
-    /// Create `shaderpacks/` if needed and open it.
-    OpenShaderPackFolder,
    /// Roll the credits (`CreditsAndAttributionScreen.openCreditsScreen`).
    Credits,
    /// Copy how an agent connects (the AI Agent page).
    CopyAgentDetails,
-    /// The shader pack settings page closed with changes: they are saved,
-    /// the pack is built again with them.
-    ReloadShaderPack,
 }
 /// `SliderableValueSet.applyValueImmediately`: these apply 600 ms after
 /// the last change (`OptionInstanceSliderButton.delayedApplyAt`).
@@ -1021,19 +998,8 @@ pub struct OptionsUi {
    /// Scroll the selected language into the middle on the next layout.
    center_language: bool,
    pub graphics: crate::graphics_ui::GraphicsUi,
-    /// `shaderpacks/` and its packs, read while the Shader Packs page shows.
-    pub shader_packs: crate::shader_pack::Folder,
-    /// The pack that failed to load last and why (set by the game).
-    pub shader_pack_error: Option<(String, String)>,
    /// The AI Agent page's status lines (set by the game while it shows).
    pub agent_status: Vec<String>,
-    /// Loaded interactive configuration for the currently selected shader pack.
-    pub shader_pack_config: Option<PackConfig>,
-    /// The shader pack option slider being dragged.
-    pub(crate) dragging_shader_option: Option<usize>,
-    /// `shader_pack_config` changed since the settings page opened: leaving
-    /// it saves the values and reloads the pack.
-    shader_pack_edited: bool,
 }
 impl Default for OptionsUi {
    fn default() -> Self {
@@ -1062,12 +1028,7 @@ impl Default for OptionsUi {
            in_world: false,
            center_language: false,
            graphics: Default::default(),
-            shader_packs: Default::default(),
-            shader_pack_error: None,
            agent_status: Vec::new(),
-            shader_pack_config: None,
-            dragging_shader_option: None,
-            shader_pack_edited: false,
        }
    }
 }
@@ -1114,14 +1075,11 @@ fn option_widget(s: &Settings, opt: Opt, x: f32, y: f32, w: f32) -> Widget {
 /// What a button opening one of Horizon's pages says on hover.
 fn horizon_page_tooltip(page: Page) -> Option<&'static str> {
    Some(match page {
-        Page::Horizon => {
-            "Horizon's own settings: graphics, shader packs, controllers, extras and mods."
-        }
+        Page::Horizon => "Horizon's own settings: graphics, controllers, extras and mods.",
        Page::Graphics => "Graphics, simply: each setting says what it costs.",
        Page::GraphicsAdvanced => {
            "Every graphics setting, Horizon's included, with what each costs."
        }
-        Page::ShaderPacks => "Packs that redraw the world. Off is the vanilla look.",
        Page::Controller => "Controllers: their buttons, sticks, vibration and menu navigation.",
        Page::Extras => {
            "Optional additions, all off by default: the game stays vanilla until you turn one on."
@@ -1196,105 +1154,6 @@ impl OptionsUi {
            self.graphics.reset();
        }
    }
-    /// Pick shader pack `i` of the folder, or turn it off when it is the
-    /// one running.
-    pub(crate) fn toggle_shader_pack(&mut self, s: &mut Settings, i: usize) {
-        let Some((id, Ok(_))) = self.shader_packs.packs.get(i) else {
-            return;
-        };
-        let g = &mut s.horizon;
-        g.shader_pack = if g.shader_pack == *id {
-            String::new()
-        } else {
-            id.clone()
-        };
-        self.sync_shader_pack_config(s);
-    }
-    /// Ensure `shader_pack_config` matches `s.horizon.shader_pack`.
-    pub fn sync_shader_pack_config(&mut self, s: &Settings) {
-        let id = s.horizon.shader_pack.as_str();
-        if id.is_empty() {
-            self.shader_pack_config = None;
-            return;
-        }
-        if self
-            .shader_pack_config
-            .as_ref()
-            .is_some_and(|cfg| cfg.id == id)
-        {
-            return;
-        }
-        // A pack whose options can't be read has none, rather than being
-        // read again every frame.
-        let config = PackConfig::load(&self.shader_pack_dir(), id).unwrap_or_else(|e| {
-            log::warn!("Horizon: shader pack {id} options: {e}");
-            PackConfig {
-                id: id.to_owned(),
-                ..Default::default()
-            }
-        });
-        self.shader_pack_config = Some(config);
-        self.shader_pack_edited = false;
-    }
-    /// The picked pack has options or profiles to show.
-    fn shader_pack_has_settings(&self, s: &Settings) -> bool {
-        self.shader_pack_config.as_ref().is_some_and(|c| {
-            !s.horizon.shader_pack.is_empty()
-                && c.id == s.horizon.shader_pack
-                && (!c.options.is_empty() || !c.profiles.is_empty())
-        })
-    }
-    fn shader_pack_dir(&self) -> std::path::PathBuf {
-        if self.shader_packs.dir.as_os_str().is_empty() {
-            crate::shader_pack::folder()
-        } else {
-            self.shader_packs.dir.clone()
-        }
-    }
-    /// A file or folder dropped on the window: on the Shader Packs page (as
-    /// Iris's `ShaderPackScreen.onFilesDrop`), a pack copied into
-    /// `shaderpacks/` and picked. `None` elsewhere; the caller saves the
-    /// settings and loads the pack on `Some(Ok)`.
-    pub fn drop_shader_pack(
-        &mut self,
-        s: &mut Settings,
-        path: &std::path::Path,
-    ) -> Option<Result<(), String>> {
-        if self.page() != Page::ShaderPacks {
-            return None;
-        }
-        let dir = self.shader_pack_dir();
-        Some(crate::shader_pack::import_pack(path, &dir).map(|id| {
-            self.shader_packs = Default::default();
-            self.shader_packs.poll(dir);
-            s.horizon.shader_pack = id;
-            self.sync_shader_pack_config(s);
-        }))
-    }
-    /// Change the shader pack's options, applied when its page closes.
-    fn edit_shader_pack(&mut self, edit: impl FnOnce(&mut PackConfig)) {
-        if let Some(cfg) = &mut self.shader_pack_config {
-            edit(cfg);
-            self.shader_pack_edited = true;
-        }
-    }
-    /// Save the active shader pack options to `shaderpacks/<id>.txt`.
-    fn save_shader_pack_config(&self) {
-        if let Some(cfg) = &self.shader_pack_config
-            && let Err(e) = cfg.save(&self.shader_pack_dir())
-        {
-            log::warn!("Horizon: shader pack {} options: {e}", cfg.id);
-        }
-    }
-    pub(crate) fn shader_pack_failed(&self, id: &str) -> bool {
-        self.shader_pack_error
-            .as_ref()
-            .is_some_and(|(e, _)| e == id)
-    }
-    /// Whether the Shader Packs page shows.
-    fn shader_packs_shown(&self) -> bool {
-        self.page() == Page::ShaderPacks
-    }
    /// The graphics screen level of `page`, if it is one.
    fn graphics_level(page: Page) -> Option<crate::graphics_ui::Level> {
        match page {
@@ -1317,8 +1176,6 @@ impl OptionsUi {
            Page::Font => "options.font.title",
            Page::Packs => "resourcePack.title",
            Page::Mods => "Mods",
-            Page::ShaderPacks => "Shader Packs",
-            Page::ShaderPackOptions => "Shader Pack Settings",
            Page::Graphics | Page::GraphicsAdvanced => "options.videoTitle",
            Page::Controller => "Controller Settings",
            Page::PadBinds => "Controller Binds",
@@ -1434,10 +1291,7 @@ impl OptionsUi {
                        open("Graphics...", Page::Graphics),
                        Some(open("Advanced Graphics...", Page::GraphicsAdvanced)),
                    ),
-                    Row::Buttons(
-                        open("Shader Packs...", Page::ShaderPacks),
-                        Some(open("Controller Settings...", Page::Controller)),
-                    ),
+                    Row::Buttons(open("Controller Settings...", Page::Controller), None),
                    Row::Buttons(
                        open("Extras...", Page::Extras),
                        Some(open("Mods...", Page::Mods)),
@@ -1485,16 +1339,6 @@ impl OptionsUi {
                        Act::Push(Page::GraphicsAdvanced),
                    )),
                )];
-                rows.push(Row::Buttons(
-                    button(
-                        0.0,
-                        0.0,
-                        310.0,
-                        Text::literal("Shader Packs..."),
-                        Act::Push(Page::ShaderPacks),
-                    ),
-                    None,
-                ));
                rows.push(Row::Header("options.video.display.header"));
                rows.extend(pairs(&[
                    Opt::MaxFps,
@@ -1667,113 +1511,6 @@ impl OptionsUi {
                    })
                    .collect()
            }
-            Page::ShaderPacks => {
-                let folder = &self.shader_packs;
-                let mut rows = vec![Row::Note(folder.dir.display().to_string())];
-                if folder.packs.is_empty() {
-                    rows.push(Row::Header(
-                        "No shader packs: put a pack's folder or .zip in this folder",
-                    ));
-                }
-                for (i, (id, info)) in folder.packs.iter().enumerate() {
-                    let on = s.horizon.shader_pack == *id;
-                    let mut label = Text::literal(format!("{id}: ")).append(on_off(on));
-                    if info.is_err() || self.shader_pack_failed(id) {
-                        label = label.append(" (Failed)");
-                    }
-                    let widget = button(0.0, 0.0, 310.0, label, Act::ToggleShaderPack(i));
-                    rows.push(Row::Buttons(
-                        if info.is_ok() {
-                            widget
-                        } else {
-                            inactive(widget)
-                        },
-                        None,
-                    ));
-                }
-                rows
-            }
-            Page::ShaderPackOptions => {
-                let Some(cfg) = &self.shader_pack_config else {
-                    return vec![Row::Header("No configurable options for this shader pack")];
-                };
-                let screen = cfg.current_screen();
-                let mut rows = vec![Row::Note(format!("{} — {}", cfg.id, screen.label))];
-                if cfg.active_screen.is_some() {
-                    rows.push(Row::Buttons(
-                        button(
-                            0.0,
-                            0.0,
-                            310.0,
-                            Text::literal("Back to Main Screen"),
-                            Act::ShaderPackBackScreen,
-                        ),
-                        None,
-                    ));
-                }
-                let mut widgets = Vec::new();
-                for item in &screen.items {
-                    match item {
-                        crate::shader_pack::ScreenItem::Empty => {}
-                        crate::shader_pack::ScreenItem::Profile => {
-                            let label =
-                                Text::literal(format!("Profile: {}", cfg.active_profile_label()));
-                            widgets.push(button(0.0, 0.0, 150.0, label, Act::ShaderPackProfile));
-                        }
-                        crate::shader_pack::ScreenItem::Subscreen(sub, title) => {
-                            let label = Text::literal(format!("{title}..."));
-                            widgets.push(button(
-                                0.0,
-                                0.0,
-                                150.0,
-                                label,
-                                Act::ShaderPackSubscreen(sub.clone()),
-                            ));
-                        }
-                        crate::shader_pack::ScreenItem::Option(idx) => {
-                            if let Some(opt) = cfg.options.get(*idx) {
-                                let label = Text::literal(format!(
-                                    "{}: {}",
-                                    opt.label,
-                                    opt.display_value()
-                                ));
-                                if let Some(value) = opt.slider_pos() {
-                                    widgets.push(Widget {
-                                        x: 0.0,
-                                        y: 0.0,
-                                        w: 150.0,
-                                        h: 20.0,
-                                        kind: WKind::ShaderOptionSlider {
-                                            label,
-                                            value,
-                                            index: *idx,
-                                        },
-                                        list: false,
-                                    });
-                                } else {
-                                    widgets.push(button(
-                                        0.0,
-                                        0.0,
-                                        150.0,
-                                        label,
-                                        Act::ShaderPackOption(*idx),
-                                    ));
-                                }
-                            }
-                        }
-                    }
-                }
-                let mut iter = widgets.into_iter();
-                while let Some(mut first) = iter.next() {
-                    if let Some(second) = iter.next() {
-                        rows.push(Row::Buttons(first, Some(second)));
-                    } else {
-                        first.w = 310.0;
-                        rows.push(Row::Buttons(first, None));
-                    }
-                }
-                rows
-            }
            _ => {
                let _ = s;
                Vec::new()
@@ -1784,9 +1521,6 @@ impl OptionsUi {
    fn layout(&mut self, s: &Settings, w: f32, h: f32) -> (Vec<Widget>, f32, f32, f32) {
        let mut out = Vec::new();
        let page = self.page();
-        if matches!(page, Page::ShaderPacks | Page::ShaderPackOptions) {
-            self.sync_shader_pack_config(s);
-        }
        let cx = (w / 2.0).floor();
        if matches!(page, Page::Video | Page::Controls | Page::KeyBinds) {
            self.settings_search.x = cx - 100.0;
@@ -2176,10 +1910,6 @@ impl OptionsUi {
                if matches!(page, Page::Video | Page::Controls) {
                    top = 38.0;
                }
-                if page == Page::ShaderPacks {
-                    // Two footer rows, as Iris's ShaderPackScreen.
-                    bottom = h - 57.0;
-                }
                out.push(Widget {
                    x: 0.0,
                    y: if matches!(page, Page::Video | Page::Controls) {
@@ -2266,42 +1996,13 @@ impl OptionsUi {
                }
                content = y + self.scroll - top + 2.0;
                out[list_start..].iter_mut().for_each(|w| w.list = true);
-                let folder = match page {
-                    Page::Mods => Some(("Open Mod Folder", Act::OpenModFolder)),
-                    Page::ShaderPackOptions => {
-                        Some(("Reset to Defaults", Act::ResetShaderPackOptions))
-                    }
-                    _ => None,
-                };
-                if page == Page::ShaderPacks {
-                    // Iris: the folder and the pack's settings above Done.
-                    out.push(button(
-                        cx - 154.0,
-                        h - 51.0,
-                        150.0,
-                        Text::literal("Open Shader Pack Folder"),
-                        Act::OpenShaderPackFolder,
-                    ));
-                    let settings = button(
-                        cx + 4.0,
-                        h - 51.0,
-                        150.0,
-                        Text::literal("Shader Pack Settings..."),
-                        Act::Push(Page::ShaderPackOptions),
-                    );
-                    out.push(if self.shader_pack_has_settings(s) {
-                        settings
-                    } else {
-                        inactive(settings)
-                    });
-                    out.push(done(h - 27.0));
-                } else if let Some((label, act)) = folder {
+                if page == Page::Mods {
                    out.push(button(
                        cx - 154.0,
                        h - 27.0,
                        150.0,
-                        Text::literal(label),
-                        act,
+                        Text::literal("Open Mod Folder"),
+                        Act::OpenModFolder,
                    ));
                    out.push(button(cx + 4.0, h - 27.0, 150.0, tr("gui.done"), Act::Done));
                } else {
@@ -2331,9 +2032,6 @@ impl OptionsUi {
        atlas: &HudAtlas,
        cursor: (f32, f32),
    ) {
-        if self.shader_packs_shown() {
-            self.shader_packs.poll(crate::shader_pack::folder());
-        }
        let (w, h) = (batch.width, batch.height);
        if let Some(error) = &self.resource_error {
            ui::menu_background(batch, atlas, 0.0, 0.0, w, h, self.in_world);
@@ -2462,16 +2160,6 @@ impl OptionsUi {
                        170.0,
                    ));
                }
-                if let WKind::Button {
-                    act: Act::ShaderPackOption(i),
-                    ..
-                } = &wd.kind
-                    && let Some(cfg) = &self.shader_pack_config
-                    && let Some(opt) = cfg.options.get(*i)
-                    && !opt.description.is_empty()
-                {
-                    tooltip = Some(atlas.font.split(&Text::literal(&opt.description), 170.0));
-                }
            }
            match &wd.kind {
                WKind::Button { label, active, act } => {
@@ -2512,31 +2200,6 @@ impl OptionsUi {
                        true,
                    );
                }
-                WKind::ShaderOptionSlider {
-                    label,
-                    value,
-                    index,
-                } => {
-                    let dragging = self.dragging_shader_option == Some(*index);
-                    if hover
-                        && let Some(cfg) = &self.shader_pack_config
-                        && let Some(opt) = cfg.options.get(*index)
-                        && !opt.description.is_empty()
-                    {
-                        tooltip = Some(atlas.font.split(&Text::literal(&opt.description), 170.0));
-                    }
-                    ui::slider(
-                        batch,
-                        atlas,
-                        wd.x,
-                        wd.y,
-                        wd.w,
-                        label,
-                        *value,
-                        hover || dragging,
-                        true,
-                    );
-                }
                WKind::Text {
                    text,
                    color,
@@ -2669,7 +2332,6 @@ impl OptionsUi {
                    Action::ButtonClick => events.push(Event::ButtonClick),
                    Action::Changed => events.push(Event::Changed),
                    Action::OpenAdvanced => self.push(Page::GraphicsAdvanced),
-                    Action::OpenShaderPacks => self.push(Page::ShaderPacks),
                    Action::OpenSimple => {
                        if self.stack.len() >= 2
                            && self.stack[self.stack.len() - 2] == Page::Graphics
@@ -2751,19 +2413,6 @@ impl OptionsUi {
                set_slider(opt, s, v);
                events.push(Event::Changed);
            }
-            if let Some(idx) = self.dragging_shader_option
-                && let Some(wd) = widgets.iter().find(|wd| {
-                    matches!(&wd.kind, WKind::ShaderOptionSlider { index, .. } if *index == idx)
-                })
-            {
-                let v = ui::slider_value(wd.x, wd.w, x);
-                self.edit_shader_pack(|cfg| {
-                    if let Some(opt) = cfg.options.get_mut(idx) {
-                        opt.set_slider_pos(v);
-                    }
-                });
-                events.push(Event::Changed);
-            }
            return events;
        }
        // Controller Binds: a click cancels the wait.
@@ -2844,41 +2493,8 @@ impl OptionsUi {
                            events.push(Event::Changed);
                        }
                        Act::OpenModFolder => events.push(Event::OpenModFolder),
-                        Act::ToggleShaderPack(i) => {
-                            self.toggle_shader_pack(s, i);
-                            events.push(Event::Changed);
-                        }
-                        Act::OpenShaderPackFolder => events.push(Event::OpenShaderPackFolder),
                        Act::Credits => events.push(Event::Credits),
                        Act::CopyAgentDetails => events.push(Event::CopyAgentDetails),
-                        Act::ShaderPackProfile => {
-                            self.edit_shader_pack(|cfg| cfg.cycle_profile(false));
-                            events.push(Event::Changed);
-                        }
-                        Act::ShaderPackSubscreen(sub) => {
-                            if let Some(cfg) = &mut self.shader_pack_config {
-                                cfg.active_screen = Some(sub);
-                            }
-                            self.scroll = 0.0;
-                        }
-                        Act::ShaderPackBackScreen => {
-                            if let Some(cfg) = &mut self.shader_pack_config {
-                                cfg.active_screen = None;
-                            }
-                            self.scroll = 0.0;
-                        }
-                        Act::ShaderPackOption(i) => {
-                            self.edit_shader_pack(|cfg| {
-                                if let Some(opt) = cfg.options.get_mut(i) {
-                                    opt.cycle(false);
-                                }
-                            });
-                            events.push(Event::Changed);
-                        }
-                        Act::ResetShaderPackOptions => {
-                            self.edit_shader_pack(PackConfig::reset_all);
-                            events.push(Event::Changed);
-                        }
                        Act::None => {}
                    }
                }
@@ -2889,16 +2505,6 @@ impl OptionsUi {
                    set_slider(opt, s, v);
                    events.push(Event::Changed);
                }
-                WKind::ShaderOptionSlider { index, .. } => {
-                    self.dragging_shader_option = Some(index);
-                    let v = ui::slider_value(wd.x, wd.w, x);
-                    self.edit_shader_pack(|cfg| {
-                        if let Some(opt) = cfg.options.get_mut(index) {
-                            opt.set_slider_pos(v);
-                        }
-                    });
-                    events.push(Event::Changed);
-                }
                WKind::LanguageRow { code, .. } => {
                    if self.language_choice.as_deref() == Some(code.as_str()) {
                        events.extend(self.back(s));
@@ -2927,7 +2533,7 @@ impl OptionsUi {
        }
        // AbstractSliderButton suppresses the press sound and plays once on
        // release, even if the pointer has left the widget or its value stayed.
-        let slider = self.dragging.take().is_some() || self.dragging_shader_option.take().is_some();
+        let slider = self.dragging.take().is_some();
        let graphics_slider = self.graphics.release();
        if slider || graphics_slider {
            vec![Event::ButtonClick]
@@ -2983,14 +2589,6 @@ impl OptionsUi {
    /// Escape or Done: leave the current page, applying page results.
    pub fn back(&mut self, s: &mut Settings) -> Vec<Event> {
        let mut events = Vec::new();
-        if self.page() == Page::ShaderPackOptions
-            && let Some(cfg) = &mut self.shader_pack_config
-            && cfg.active_screen.is_some()
-        {
-            cfg.active_screen = None;
-            self.scroll = 0.0;
-            return events;
-        }
        let page = self.stack.pop().unwrap_or(Page::Main);
        self.scroll = 0.0;
        self.scrollbar_drag_y = None;
@@ -3007,12 +2605,6 @@ impl OptionsUi {
                    events.push(Event::Language(code));
                }
            }
-            // Iris's ShaderPackScreen applies its edits on Done, so the
-            // pack is rebuilt once, not on every click or slider step.
-            Page::ShaderPackOptions if std::mem::take(&mut self.shader_pack_edited) => {
-                self.save_shader_pack_config();
-                events.push(Event::ReloadShaderPack);
-            }
            Page::Packs => {
                // PackSelectionScreen.onClose: PackSelectionModel.commit.
                if let Some(p) = self.pack_screen.take()
@@ -3337,177 +2929,6 @@ mod tests {
        assert!(ui.resource_error.is_none());
    }

-    /// The Shader Packs page (Video Settings > Shader Packs..., or the
-    /// Shader Pack row of Advanced graphics): the folder's path, Open Shader
-    /// Pack Folder, and a switch per pack (#941, #925).
-    #[test]
-    fn classic_shader_packs_page_shows_the_folder_and_picks_a_pack() {
-        let atlas = atlas();
-        let mut s = Settings::default();
-        let mut ui = OptionsUi::default();
-        let size = (480.0, 240.0);
-        let dir = std::env::temp_dir().join(format!("horizon-shaderpacks-{}", std::process::id()));
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir_all(&dir).unwrap();
-        let find = |ui: &mut OptionsUi, s: &Settings, act: &dyn Fn(&Act) -> bool| {
-            ui.layout(s, size.0, size.1)
-                .0
-                .into_iter()
-                .find(|w| matches!(&w.kind, WKind::Button { act: a, active: true, .. } if act(a)))
-        };
-        ui.show(Page::Video);
-        let open = find(&mut ui, &s, &|a| *a == Act::Push(Page::ShaderPacks)).unwrap();
-        ui.click(
-            &mut s,
-            &atlas,
-            open.x + 1.0,
-            open.y + 1.0,
-            size,
-            [480, 240],
-            false,
-            false,
-        );
-        assert_eq!(ui.page(), Page::ShaderPacks);
-
-        ui.shader_packs.poll(dir.clone());
-        let empty = ui.layout(&s, size.0, size.1).0;
-        let path = dir.display().to_string();
-        for line in [path.as_str(), "No shader packs"] {
-            assert!(
-                empty.iter().any(
-                    |w| matches!(&w.kind, WKind::Text { text, .. } if text.plain().contains(line))
-                ),
-                "{line}"
-            );
-        }
-        let folder = find(&mut ui, &s, &|a| *a == Act::OpenShaderPackFolder).unwrap();
-        assert_eq!(
-            ui.click(
-                &mut s,
-                &atlas,
-                folder.x + 1.0,
-                folder.y + 1.0,
-                size,
-                [480, 240],
-                false,
-                false
-            ),
-            vec![Event::ButtonClick, Event::OpenShaderPackFolder]
-        );
-
-        std::fs::write(dir.join("Pack.zip"), b"").unwrap();
-        ui.shader_packs = Default::default();
-        ui.shader_packs.poll(dir.clone());
-        let pack = find(&mut ui, &s, &|a| *a == Act::ToggleShaderPack(0)).unwrap();
-        let events = ui.click(
-            &mut s,
-            &atlas,
-            pack.x + 1.0,
-            pack.y + 1.0,
-            size,
-            [480, 240],
-            false,
-            false,
-        );
-        assert!(events.contains(&Event::Changed));
-        assert_eq!(s.horizon.shader_pack, "Pack.zip");
-        ui.shader_pack_error = Some(("Pack.zip".into(), "broken".into()));
-        let label = |ui: &mut OptionsUi, s: &Settings| match find(ui, s, &|a| {
-            *a == Act::ToggleShaderPack(0)
-        })
-        .unwrap()
-        .kind
-        {
-            WKind::Button { label, .. } => label.plain(),
-            _ => unreachable!(),
-        };
-        assert!(
-            label(&mut ui, &s).ends_with("(Failed)"),
-            "{}",
-            label(&mut ui, &s)
-        );
-        ui.click(
-            &mut s,
-            &atlas,
-            pack.x + 1.0,
-            pack.y + 1.0,
-            size,
-            [480, 240],
-            false,
-            false,
-        );
-        assert_eq!(s.horizon.shader_pack, "", "a second click turns it off");
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn a_dropped_pack_is_picked_and_its_settings_apply_on_done() {
-        let atlas = atlas();
-        let mut s = Settings::default();
-        let mut ui = OptionsUi::default();
-        let size = (480.0, 240.0);
-        let dir =
-            std::env::temp_dir().join(format!("horizon-shaderpack-drop-{}", std::process::id()));
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir_all(&dir).unwrap();
-        ui.shader_packs.poll(dir.clone());
-        let sample = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../../examples/shaderpacks/horizon-sample");
-        assert_eq!(
-            ui.drop_shader_pack(&mut s, &sample),
-            None,
-            "only on its page"
-        );
-        ui.show(Page::ShaderPacks);
-        assert_eq!(ui.drop_shader_pack(&mut s, &sample), Some(Ok(())));
-        assert_eq!(s.horizon.shader_pack, "horizon-sample");
-        assert!(dir.join("horizon-sample/pack.toml").is_file());
-        let again = ui.drop_shader_pack(&mut s, &sample).unwrap().unwrap_err();
-        assert!(again.contains("already"), "{again}");
-
-        let click = |ui: &mut OptionsUi, s: &mut Settings, act: &dyn Fn(&Act) -> bool| {
-            let w = ui
-                .layout(s, size.0, size.1)
-                .0
-                .into_iter()
-                .find(|w| matches!(&w.kind, WKind::Button { act: a, active: true, .. } if act(a)))
-                .unwrap();
-            ui.click(
-                s,
-                &atlas,
-                w.x + 1.0,
-                w.y + 1.0,
-                size,
-                [480, 240],
-                false,
-                false,
-            )
-        };
-        click(&mut ui, &mut s, &|a| {
-            *a == Act::Push(Page::ShaderPackOptions)
-        });
-        assert_eq!(ui.page(), Page::ShaderPackOptions);
-        for _ in 0..3 {
-            let events = click(&mut ui, &mut s, &|a| matches!(a, Act::ShaderPackOption(_)));
-            assert!(!events.contains(&Event::ReloadShaderPack), "{events:?}");
-        }
-        let txt = dir.join("horizon-sample.txt");
-        assert!(!txt.exists(), "nothing is saved before Done");
-        let events = click(&mut ui, &mut s, &|a| *a == Act::Done);
-        assert!(events.contains(&Event::ReloadShaderPack), "{events:?}");
-        assert_eq!(ui.page(), Page::ShaderPacks);
-        assert!(txt.is_file(), "Done saves the values");
-        click(&mut ui, &mut s, &|a| {
-            *a == Act::Push(Page::ShaderPackOptions)
-        });
-        let events = click(&mut ui, &mut s, &|a| *a == Act::Done);
-        assert!(
-            !events.contains(&Event::ReloadShaderPack),
-            "no change: no reload"
-        );
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
    #[test]
    fn classic_mods_page_toggles_mods_and_keeps_dev_and_invalid_entries_inactive() {
        let atlas = atlas();
@@ -4618,7 +4039,6 @@ mod tests {
            [
                Page::Graphics,
                Page::GraphicsAdvanced,
-                Page::ShaderPacks,
                Page::Controller,
                Page::Extras,
                Page::Mods,
@@ -4652,7 +4072,7 @@ mod tests {
        // Vanilla's own pages keep the Horizon pages they had.
        ui.stack = vec![Page::Main, Page::Video];
        let video = pushes(&mut ui);
-        for page in [Page::Graphics, Page::GraphicsAdvanced, Page::ShaderPacks] {
+        for page in [Page::Graphics, Page::GraphicsAdvanced] {
            assert!(video.contains(&page), "{page:?}");
        }
        ui.stack = vec![Page::Main, Page::Controls];
@@ -1336,6 +1336,16 @@ impl ParticleEngine {
            ParticleType::ExplosionEmitter
        };
        self.add(&ParticleOptions::simple(ty), center, [1.0, 0.0, 0.0]);
+        self.explosion_blocks(center, radius, block_count, is_air);
+    }
+    /// `ClientExplosionTracker` with `Level.DEFAULT_EXPLOSION_BLOCK_PARTICLES`.
+    pub fn explosion_blocks(
+        &mut self,
+        center: [f64; 3],
+        radius: f32,
+        block_count: usize,
+        is_air: &dyn Fn([i32; 3]) -> bool,
+    ) {
        for _ in 0..block_count.min(512) {
            let r = &mut self.random;
            let d = Vec3::new(
@@ -3223,7 +3233,7 @@ impl ParticleEngine {
            } => {
                p.base_tick(level);
                let (fluid, source) = level.fluid_source(ParticleLevel::block_at(p.position));
-                if !p.removed && !(fluid == Fluid::Water && source) {
+                if !(p.removed || (fluid == Fluid::Water && source)) {
                    p.removed = true;
                }
                if !p.removed && p.position[1] >= y_end {
@@ -1,71 +0,0 @@
-// Horizon shader pack prelude, api 1 (docs/shader-packs.md): placed before
-// every stage's source. Bindings, the Frame uniform, the full-screen vertex
-// shader and helpers that hide the renderer's reversed depth.
-struct Frame {
-    view: mat4x4<f32>,
-    projection: mat4x4<f32>,
-    inverse_view: mat4x4<f32>,
-    inverse_projection: mat4x4<f32>,
-    camera_position: vec4<f32>,
-    resolution: vec4<f32>,
-    time: vec4<f32>,
-    sun: vec4<f32>,
-    moon: vec4<f32>,
-    sky_color: vec4<f32>,
-    fog_color: vec4<f32>,
-    fog: vec4<f32>,
-    weather: vec4<f32>,
-    camera_state: vec4<f32>,
-    view_params: vec4<f32>,
-    dimension: vec4<f32>,
-}
-@group(0) @binding(0) var scene_color: texture_2d<f32>;
-@group(0) @binding(1) var scene_depth: texture_depth_2d;
-@group(0) @binding(2) var previous: texture_2d<f32>;
-@group(0) @binding(3) var linear_sampler: sampler;
-@group(0) @binding(4) var nearest_sampler: sampler;
-@group(0) @binding(5) var<uniform> frame: Frame;
-
-struct StageIn {
-    @builtin(position) position: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-}
-@vertex fn horizon_stage_vertex(@builtin(vertex_index) i: u32) -> StageIn {
-    let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
-    var out: StageIn;
-    out.position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
-    out.uv = vec2(p.x, 1.0 - p.y);
-    return out;
-}
-
-// The world's depth at `uv`: 1 at the near plane, 0 for the sky.
-fn depth_at(uv: vec2<f32>) -> f32 {
-    return textureSampleLevel(scene_depth, nearest_sampler, uv, 0);
-}
-fn is_sky(depth: f32) -> bool {
-    return depth <= 0.0;
-}
-// Blocks from the eye along the view axis.
-fn linear_depth(depth: f32) -> f32 {
-    let near = frame.view_params.x;
-    let far = frame.view_params.y;
-    return near * far / ((far - near) * depth + near);
-}
-fn view_position(uv: vec2<f32>, depth: f32) -> vec3<f32> {
-    let v = frame.inverse_projection * vec4(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, depth, 1.0);
-    return v.xyz / v.w;
-}
-// World position relative to the eye (add frame.camera_position.xyz for the
-// absolute one).
-fn world_offset(uv: vec2<f32>, depth: f32) -> vec3<f32> {
-    return (frame.inverse_view * vec4(view_position(uv, depth), 1.0)).xyz;
-}
-fn luminance(c: vec3<f32>) -> f32 {
-    return dot(c, vec3(0.2126, 0.7152, 0.0722));
-}
-fn srgb_to_linear(c: vec3<f32>) -> vec3<f32> {
-    return select(pow((c + 0.055) / 1.055, vec3(2.4)), c / 12.92, c <= vec3(0.04045));
-}
-fn linear_to_srgb(c: vec3<f32>) -> vec3<f32> {
-    return select(1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, c * 12.92, c <= vec3(0.0031308));
-}
@@ -1,108 +0,0 @@
-// Horizon shader pack prelude, api 2 additions (docs/shader-packs.md): placed
-// after the api 1 prelude before the stages of an `api = 2` pack, so api 1
-// packs keep every name they may have declared themselves.
-struct FrameExt {
-    previous_view: mat4x4<f32>,
-    previous_projection: mat4x4<f32>,
-    shadow_view: mat4x4<f32>,
-    shadow_projection: mat4x4<f32>,
-    shadow_inverse_view: mat4x4<f32>,
-    shadow_inverse_projection: mat4x4<f32>,
-    // xyz: previous camera world position, w: frame delta time (seconds)
-    previous_camera: vec4<f32>,
-    // x: shadow map resolution, y: shadow distance (blocks), z: 0,
-    // w: 1 while the shadow map is drawn this frame, else 0
-    shadow_params: vec4<f32>,
-    // x: eye block light (0..240), y: eye sky light (0..240), z: smoothed
-    // rain (0..1), w: 0
-    environment: vec4<f32>,
-}
-
-@group(0) @binding(6) var<uniform> frame_ext: FrameExt;
-@group(0) @binding(7) var scene_normal: texture_2d<f32>;
-@group(0) @binding(8) var scene_material: texture_2d<f32>;
-@group(0) @binding(9) var opaque_depth: texture_depth_2d;
-@group(0) @binding(10) var shadow_depth: texture_depth_2d;
-@group(0) @binding(11) var shadow_sampler: sampler_comparison;
-@group(0) @binding(12) var noise_texture: texture_2d<f32>;
-@group(0) @binding(13) var repeat_sampler: sampler;
-
-// The opaque world's depth at `uv` (before translucent water and stained glass).
-fn opaque_depth_at(uv: vec2<f32>) -> f32 {
-    return textureSampleLevel(opaque_depth, nearest_sampler, uv, 0);
-}
-
-// World-space surface normal at `uv` from the G-buffer (or reconstructed from depth).
-fn world_normal_at(uv: vec2<f32>) -> vec3<f32> {
-    let encoded = textureSampleLevel(scene_normal, nearest_sampler, uv, 0.0);
-    if encoded.w > 0.001 {
-        return normalize(encoded.xyz * 2.0 - 1.0);
-    }
-    let step_uv = frame.resolution.zw;
-    let d0 = depth_at(uv);
-    let p0 = world_offset(uv, d0);
-    let px = world_offset(uv + vec2(step_uv.x, 0.0), depth_at(uv + vec2(step_uv.x, 0.0))) - p0;
-    let py = world_offset(uv + vec2(0.0, step_uv.y), depth_at(uv + vec2(0.0, step_uv.y))) - p0;
-    let n = cross(py, px);
-    let len = length(n);
-    if len > 1e-6 {
-        return n / len;
-    }
-    return vec3(0.0, 1.0, 0.0);
-}
-// G-buffer material data at `uv`: r = block light (0..1), g = sky light (0..1),
-// b = water/translucent mask (0..1), a = roughness (0..1).
-fn material_at(uv: vec2<f32>) -> vec4<f32> {
-    return textureSampleLevel(scene_material, nearest_sampler, uv, 0.0);
-}
-// Reproject a camera-relative world position into previous-frame UV and clip depth.
-fn reproject_uv(world_rel: vec3<f32>) -> vec3<f32> {
-    let camera_delta = frame.camera_position.xyz - frame_ext.previous_camera.xyz;
-    let prev_rel = world_rel + camera_delta;
-    let clip = frame_ext.previous_projection * (frame_ext.previous_view * vec4(prev_rel, 1.0));
-    if clip.w <= 1e-5 {
-        return vec3(-1.0);
-    }
-    let ndc = clip.xyz / clip.w;
-    return vec3(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5, ndc.z);
-}
-// Sample the directional sun/moon shadow map with 5-tap PCF and normal offset bias.
-// Returns 1.0 in full light and 0.0 in full shadow.
-fn sample_shadow(world_rel: vec3<f32>, world_normal: vec3<f32>) -> f32 {
-    if frame_ext.shadow_params.w <= 0.001 {
-        return 1.0;
-    }
-    let dist = length(world_rel);
-    let max_dist = max(frame_ext.shadow_params.y, 16.0);
-    if dist >= max_dist {
-        return 1.0;
-    }
-    let light_dir = normalize(select(frame.moon.xyz, frame.sun.xyz, frame.sun.y >= -0.05));
-    let ndotl = max(dot(world_normal, light_dir), 0.0);
-    let bias_pos = world_rel + world_normal * (0.06 + 0.12 * (1.0 - ndotl));
-    let light_clip = frame_ext.shadow_projection * (frame_ext.shadow_view * vec4(bias_pos, 1.0));
-    let ndc = light_clip.xyz / max(light_clip.w, 1e-5);
-    let shadow_uv = vec2(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
-    if any(shadow_uv < vec2(0.002)) || any(shadow_uv > vec2(0.998)) || ndc.z <= 0.0 || ndc.z >= 1.0 {
-        return 1.0;
-    }
-    let texel = 1.0 / max(frame_ext.shadow_params.x, 512.0);
-    let ref_z = clamp(ndc.z + 0.0008, 0.0, 1.0);
-    var sum = textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv, ref_z);
-    sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv + vec2(texel, 0.0), ref_z);
-    sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv - vec2(texel, 0.0), ref_z);
-    sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv + vec2(0.0, texel), ref_z);
-    sum += textureSampleCompareLevel(shadow_depth, shadow_sampler, shadow_uv - vec2(0.0, texel), ref_z);
-    let fade = smoothstep(max_dist, max_dist * 0.82, dist);
-    return mix(1.0, sum * 0.2, fade * frame_ext.shadow_params.w);
-}
-
-// ACES fitted filmic tonemapping curve (linear HDR -> linear 0..1).
-fn aces_tonemap(x: vec3<f32>) -> vec3<f32> {
-    let a = 2.51;
-    let b = 0.03;
-    let c = 2.43;
-    let d = 0.59;
-    let e = 0.14;
-    return clamp((x * (a * x + b)) / (x * (c * x + d) + e), vec3(0.0), vec3(1.0));
-}
@@ -103,7 +103,10 @@ pub fn shadow(
                let v = |wz: f64| (-((wz - pos.z) as f32) / 2.0 / radius + 0.5).clamp(0.0, 1.0);
                let a = (alpha * 255.0) as u32;
                let color = a << 24 | 0x00FF_FFFF;
-                let top = f64::from(y) + 0.001;
+                // ShadowFeatureRenderer: relativeY + shapeBelow.minY, the block top
+                // itself. A model's feet sit 0.001 above it (LivingEntityRenderer's
+                // translate(0, -1.501, 0)), so a lifted shadow fights with them.
+                let top = f64::from(y);
                for (wx, wz) in [(bx0, bz0), (bx0, bz1), (bx1, bz1), (bx1, bz0)] {
                    let p = DVec3::new(wx, top, wz) - camera;
                    out.push(Vertex {
@@ -113,7 +116,7 @@ pub fn shadow(
                            sprite.u0 + (sprite.u1 - sprite.u0) * u(wx),
                            sprite.v0 + (sprite.v1 - sprite.v0) * v(wz),
                        ],
-                        layer: 0,
+                        layer: crate::gfx::SHADOW_OVERLAY,
                        color,
                        light: 240 | 240 << 8,
                    });
@@ -127,6 +130,52 @@ pub fn shadow(
 mod tests {
    use super::*;
    #[test]
+    fn shadows_lie_on_the_block_top_under_model_feet() {
+        use crate::chunk::Chunk;
+        use horizon_world::level::data;
+        use std::{path::PathBuf, sync::Arc};
+        let root = std::env::var_os("HORIZON_RESOURCES")
+            .map(PathBuf::from)
+            .unwrap_or_else(|| {
+                PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                    .join("../../.local/horizon-client")
+                    .join(horizon_core::VANILLA_VERSION)
+            });
+        if !root.join("gameplay-facts.json").exists() {
+            eprintln!("skipping resource-backed shadow check: {}", root.display());
+            return;
+        }
+        let registry = data::load_registry(&root).unwrap();
+        let facts = BlockFacts::load(&root, &registry).unwrap();
+        let stone = registry.default_state("minecraft:stone").unwrap();
+        let mut world = World::new(facts.air, 0);
+        world.chunks.insert((0, 0), Arc::new(Chunk::empty(0, 0)));
+        for x in 0..16 {
+            for z in 0..16 {
+                world.set(x, 63, z, stone).unwrap();
+            }
+        }
+        let (camera, pos) = (DVec3::new(8.5, 66.0, 4.0), DVec3::new(8.5, 64.0, 8.5));
+        let mut out = Vec::new();
+        let sprite = Rect {
+            u0: 0.0,
+            v0: 0.0,
+            u1: 1.0,
+            v1: 1.0,
+            w: 16,
+            h: 16,
+        };
+        shadow(
+            &world, &facts, sprite, camera, pos, 0.3, 1.0, 0.0, 0, &mut out,
+        );
+        assert_eq!(out.len(), 4);
+        let feet = (pos.y + (1.501 - 24.0 / 16.0) - camera.y) as f32;
+        for v in &out {
+            assert_eq!(v.pos[1], (pos.y - camera.y) as f32);
+            assert!(v.pos[1] < feet);
+        }
+    }
+    #[test]
    fn vanilla_radii() {
        assert_eq!(shadow_params("minecraft:zombie"), (0.5, 1.0));
        assert_eq!(shadow_params("minecraft:item"), (0.15, 0.75));
@@ -17,7 +17,7 @@ pub mod pyjson;
 mod sounds;
 mod survival;

-pub use sounds::{fonts, panorama, sounds};
+pub use sounds::{fonts, packs, panorama, sounds, BUILT_IN_PACKS};

 use pyjson::Value;
 use sha2::Digest;
@@ -692,7 +692,7 @@ fn steps(
    }

    // The JAR holds only gray 1x1 panorama placeholders and an empty Unifont
-    // include. Import the indexed ones afterwards, including on reruns that just
+    // include, and none of the built-in packs. Import the indexed ones afterwards, including on reruns that just
    // extracted the JAR again. They are optional when preparing from
    // already-imported JARs.
    sounds::optional_assets(repo, minecraft, run.log);
@@ -19,6 +19,7 @@ Usage: horizon-prepare [--prepare] [--server-jar PATH] [--minecraft-dir PATH] [-
       horizon-prepare sounds [--minecraft-dir PATH] [--root PATH]
       horizon-prepare panorama [--minecraft-dir PATH] [--root PATH]
       horizon-prepare fonts [--minecraft-dir PATH] [--root PATH]
+       horizon-prepare packs [--minecraft-dir PATH] [--root PATH]

  --prepare             Import the pinned game files from your own copy first
  --server-jar PATH     The pinned server jar you downloaded yourself
@@ -34,7 +35,8 @@ The resources go to <root>/.local/horizon-client/<version>; pass that to horizon

 horizon-prepare panorama repairs the classic menu background in existing resources without Java.
 horizon-prepare fonts adds the GNU Unifont glyphs (characters the bitmap fonts lack) the same way.
-Full preparation also imports both after extracting the client JAR's placeholders.
+horizon-prepare packs adds the built-in Programmer Art and High Contrast resource packs the same way.
+Full preparation also imports all three after extracting the client JAR's placeholders.

 horizon-prepare sounds copies the pinned version's sounds (about 380 MB) from the official
 launcher's asset store into the same folder, checking every file. It is optional: without it the
@@ -66,7 +68,8 @@ fn main() -> ExitCode {
    };
    let mut root = None;
    let mut args = std::env::args_os().skip(1).peekable();
-    let assets = args.next_if(|a| a == "sounds" || a == "panorama" || a == "fonts");
+    let assets =
+        args.next_if(|a| matches!(a.to_str(), Some("sounds" | "panorama" | "fonts" | "packs")));
    while let Some(arg) = args.next() {
        let text = arg.to_string_lossy().into_owned();
        let (flag, inline) = match text.split_once('=') {
@@ -132,6 +135,9 @@ fn main() -> ExitCode {
        Some("fonts") => {
            horizon_prepare::fonts(&options.root, options.minecraft_dir.as_deref(), &log)
        }
+        Some("packs") => {
+            horizon_prepare::packs(&options.root, options.minecraft_dir.as_deref(), &log)
+        }
        _ => horizon_prepare::prepare(&options, &log),
    };
    match result {
@@ -1,5 +1,5 @@
-//! The pinned version's sounds and title panorama from the player's own official
-//! launcher install, each object checked against the asset index's SHA-1, copied into
+//! The pinned version's sounds, title panorama, Unifont glyphs and built-in resource packs
+//! from the player's own official launcher install, each object checked against the asset index's SHA-1, copied into
 //! `.local/horizon-client/<version>/assets` where the game reads them (tools/fetch_sounds.py and
 //! the tools/lab.py functions it called). Nothing is downloaded.

@@ -124,6 +124,11 @@ pub(crate) fn optional_assets(root: &Path, minecraft: Option<&Path>, log: Log) {
            "Unifont glyphs not imported: {error}; run horizon-prepare fonts later"
        ));
    }
+    if let Err(error) = packs(root, minecraft, log) {
+        log(&format!(
+            "Programmer Art and High Contrast not imported: {error}; run horizon-prepare packs later"
+        ));
+    }
 }

 const PANORAMA: [&str; 7] = [
@@ -145,6 +150,31 @@ const UNIFONT: [&str; 2] = [
    "minecraft/font/unifont.zip",
 ];

+/// Adds the built-in Programmer Art and High Contrast packs, which only the asset index holds
+/// (`BuiltInPackSource.populatePackList` lists `minecraft:resourcepacks` of the vanilla pack).
+/// Packs made to sit on Programmer Art, like Golden Days, show the default textures without it.
+/// Also usable on prepared resources without Java.
+pub fn packs(root: &Path, minecraft: Option<&Path>, log: Log) -> Result<PathBuf, String> {
+    copy_assets(
+        root,
+        minecraft,
+        log,
+        is_built_in_pack,
+        "Built-in pack",
+        &BUILT_IN_PACKS,
+    )
+}
+
+/// The built-in packs `packs` copies, under the prepared resources' `assets`.
+pub const BUILT_IN_PACKS: [&str; 2] = [
+    "minecraft/resourcepacks/programmer_art.zip",
+    "minecraft/resourcepacks/high_contrast.zip",
+];
+
+fn is_built_in_pack(name: &str) -> bool {
+    name.starts_with("minecraft/resourcepacks/")
+}
+
 /// The fonts only the asset index holds (the JAR has the bitmap fonts).
 fn is_font(name: &str) -> bool {
    name.starts_with("minecraft/font/")
@@ -228,11 +258,13 @@ mod tests {
        crate::hex(&sha1::Sha1::digest(data))
    }

-    /// Where the fixture's panorama objects start.
-    const FIRST_FACE: usize = 6;
+    /// Where the fixture's built-in packs and panorama objects start.
+    const FIRST_PACK: usize = 6;
+    const FIRST_FACE: usize = 8;

    /// A Horizon folder and an official launcher directory holding version `9.9` with
-    /// sounds, a language file and the full title panorama in its asset store.
+    /// sounds, a language file, Unifont, the built-in packs and the full title panorama in its
+    /// asset store.
    struct Fixture {
        dir: PathBuf,
        root: PathBuf,
@@ -263,6 +295,8 @@ mod tests {
                    b"{\"providers\": [{\"type\": \"unihex\"}]}".to_vec(),
                ),
                (UNIFONT[1], b"PK unifont".to_vec()),
+                (BUILT_IN_PACKS[0], b"PK programmer art".to_vec()),
+                (BUILT_IN_PACKS[1], b"PK high contrast".to_vec()),
            ];
            for &name in panorama {
                // Distinct object bytes let the test catch swapped faces too.
@@ -499,15 +533,25 @@ mod tests {
                lines[0],
                format!("Title panorama not imported: {error}; run horizon-prepare panorama later")
            );
-            // The fonts come on their own when only a panorama face is missing.
+            // The fonts and packs come on their own when only a panorama face is missing.
            match missing {
-                "last-object" => assert_eq!(lines[1], "Font assets ready: 2 files, 0.0 MB"),
-                _ => assert!(
-                    lines[1].starts_with("Unifont glyphs not imported: "),
-                    "{lines:?}"
+                "last-object" => assert_eq!(
+                    lines[1..],
+                    [
+                        "Font assets ready: 2 files, 0.0 MB",
+                        "Built-in pack assets ready: 2 files, 0.0 MB"
+                    ]
                ),
+                _ => {
+                    assert!(lines[1].starts_with("Unifont glyphs not imported: "));
+                    assert!(
+                        lines[2].starts_with("Programmer Art and High Contrast not imported: ")
+                            && lines[2].ends_with("; run horizon-prepare packs later"),
+                        "{lines:?}"
+                    );
+                }
            }
-            assert_eq!(lines.len(), 2);
+            assert_eq!(lines.len(), 3);
            for name in PANORAMA {
                assert_eq!(fs::read(target.join(name)).unwrap(), b"jar placeholder");
            }
@@ -528,7 +572,7 @@ mod tests {
            lines.borrow_mut().push(l.to_string())
        });
        assert_eq!(done.unwrap(), target);
-        for (name, data) in &f.objects[4..FIRST_FACE] {
+        for (name, data) in &f.objects[4..FIRST_PACK] {
            assert_eq!(&fs::read(target.join("assets").join(name)).unwrap(), data);
        }
        assert_eq!(*lines.borrow(), ["Font assets ready: 2 files, 0.0 MB"]);
@@ -536,6 +580,31 @@ mod tests {
        assert!(!target.join("assets/minecraft/textures").exists());
    }

+    /// Golden Days is made to sit on Programmer Art, which the client JAR lacks: the asset
+    /// index has it, where `BuiltInPackSource` lists `minecraft:resourcepacks`.
+    #[test]
+    fn packs_add_programmer_art_and_high_contrast_where_the_pack_list_finds_them() {
+        let f = Fixture::new("packs");
+        let target = f.root.join(".local/horizon-client/9.9");
+        let lines = std::cell::RefCell::new(Vec::new());
+        let done = packs(&f.root, Some(&f.minecraft), &|l| {
+            lines.borrow_mut().push(l.to_string())
+        });
+        assert_eq!(done.unwrap(), target);
+        for (name, data) in &f.objects[FIRST_PACK..FIRST_FACE] {
+            assert_eq!(&fs::read(target.join("assets").join(name)).unwrap(), data);
+        }
+        assert!(target
+            .join("assets/minecraft/resourcepacks/programmer_art.zip")
+            .is_file());
+        assert_eq!(
+            *lines.borrow(),
+            ["Built-in pack assets ready: 2 files, 0.0 MB"]
+        );
+        assert!(!target.join("assets/minecraft/sounds.json").exists());
+        assert!(!target.join("assets/minecraft/font").exists());
+    }
+
    #[test]
    fn the_index_must_hold_the_sounds() {
        let f = Fixture::new("index");
@@ -17,5 +17,10 @@ sha1 = "0.10"
 # Secure chat: SHA256withRSA message signatures.
 sha2 = "0.10"

+# Its own name, not `probe`: Cargo copies every crate's examples into one target/<profile>/examples.
+[[example]]
+name = "protocol_probe"
+path = "examples/probe.rs"
+
 [lints]
 workspace = true
@@ -2,7 +2,7 @@
 //! seconds, reporting packet counts and any decode failures. A differential
 //! check of the codecs against a real vanilla server:
 //!
-//!     cargo run -p horizon-protocol --example probe -- 127.0.0.1:25565 [seconds] [registries.json]
+//!     cargo run -p horizon-protocol --example protocol_probe -- 127.0.0.1:25565 [seconds] [registries.json]
 use horizon_protocol::{
    PROTOCOL_VERSION, State,
    connection::Connection,
@@ -32,6 +32,7 @@ pub mod component {
    pub const DYED_COLOR: i32 = 47;
    pub const MAP_ID: i32 = 48;
    pub const MAP_POST_PROCESSING: i32 = 50;
+    pub const CHARGED_PROJECTILES: i32 = 51;
    pub const WRITABLE_BOOK_CONTENT: i32 = 56;
    pub const WRITTEN_BOOK_CONTENT: i32 = 57;
 }
@@ -75,6 +76,8 @@ pub enum Component {
    /// `WritableBookContent`: the pages (raw text).
    WritableBook(Vec<String>),
    WrittenBook(WrittenBook),
+    /// `ChargedProjectiles`: a loaded crossbow's ammunition, as templates.
+    Stacks(Vec<Stack>),
 }

 /// `Filterable.streamCodec`: the raw value, then an optional filtered one
@@ -125,6 +128,10 @@ impl Component {
                    resolved: r.bool()?,
                })
            }
+            CHARGED_PROJECTILES => {
+                let n = r.count(1024)?;
+                Self::Stacks((0..n).map(|_| Template::read(r)).collect::<Result<_>>()?)
+            }
            DYED_COLOR => Self::Int(r.i32()?),
            UNBREAKABLE | CREATIVE_SLOT_LOCK => Self::Unit,
            ENCHANTMENT_GLINT_OVERRIDE => Self::Bool(r.bool()?),
@@ -283,6 +290,10 @@ impl Component {
                w.varint(hidden.len() as i32);
                hidden.iter().for_each(|h| w.varint(*h));
            }
+            Self::Stacks(stacks) => {
+                w.varint(stacks.len() as i32);
+                stacks.iter().for_each(|s| Template::write(s, w));
+            }
            Self::WritableBook(pages) => {
                w.varint(pages.len() as i32);
                for page in pages {
@@ -533,6 +544,21 @@ mod tests {
        round::<Option<Hashed>, HashedSlot>(None);
    }

+    #[test]
+    fn charged_projectiles_are_item_stack_templates() {
+        // A crossbow (id 7) loaded with one arrow (id 9): ChargedProjectiles
+        // is a list of ItemStackTemplate, the item before the count.
+        let bytes = [1, 7, 1, 0, 51, 1, 9, 1, 0, 0];
+        let stack = Slot::read(&mut Reader::new(&bytes)).unwrap().unwrap();
+        assert_eq!(
+            stack.component(component::CHARGED_PROJECTILES),
+            Some(&Component::Stacks(vec![Stack::new(9, 1)]))
+        );
+        let mut w = Writer::new();
+        Slot::write(&Some(stack), &mut w);
+        assert_eq!(w.data, bytes);
+    }
+
    #[test]
    fn filtered_book_pages_are_read_and_dropped() {
        // A writable book with one page "hi" and its filtered "**".
@@ -1,20 +0,0 @@
-[package]
-name = "horizon-shaderpack"
-version = "0.1.0"
-edition.workspace = true
-license.workspace = true
-rust-version.workspace = true
-description = "Java (OptiFine/Iris) shader packs for Horizon: Iris's preprocessor and the GLSL to WGSL translation"
-
-[dependencies]
-glsl-lang = "0.8.1"
-naga = { version = "30.0.1", features = ["glsl-in", "wgsl-in", "wgsl-out"] }
-# The C preprocessor naga's GLSL front end uses.
-pp-rs = "0.2.1"
-zip = { version = "2", default-features = false, features = ["deflate"] }
-
-[lints]
-workspace = true
-
-[dev-dependencies]
-zip = { version = "2", default-features = false, features = ["deflate"] }
@@ -1,198 +0,0 @@
-//! `#include` the way Iris resolves it (`IncludeGraph`, `IncludeProcessor`):
-//! before any other directive, so include guards don't apply; `/lib/x.glsl`
-//! from `shaders/`, `x.glsl` from the including file's folder. Every file
-//! reachable from the programs is read once into a graph, and a program is
-//! the graph inlined from its file.
-
-use crate::source::PackFiles;
-use std::collections::{BTreeMap, BTreeSet};
-
-/// One file of the graph: its lines and the include on each `#include` line.
-pub struct FileNode {
-    pub lines: Vec<String>,
-    /// Line index → included file (a normalised path relative to `shaders/`).
-    pub includes: BTreeMap<usize, String>,
-}
-
-pub struct IncludeGraph {
-    pub files: BTreeMap<String, FileNode>,
-    /// Files that couldn't be read or include themselves, with the reason.
-    pub failures: BTreeMap<String, String>,
-}
-
-/// A program after inlining: the source and, for each of its lines, the
-/// file and 1-based line it came from (to report errors where they are).
-pub struct Inlined {
-    pub text: String,
-    pub origin: Vec<(String, u32)>,
-}
-
-impl Inlined {
-    /// `file:line` of 1-based `line` of the inlined text.
-    pub fn locate(&self, line: u32) -> String {
-        match self.origin.get(line.saturating_sub(1) as usize) {
-            Some((file, at)) => format!("{file}:{at}"),
-            None => format!("line {line}"),
-        }
-    }
-}
-
-/// `target` from an `#include` in `from`, as a path relative to `shaders/`
-/// with `.` and `..` resolved (Iris's `AbsolutePackPath`).
-pub fn resolve(from: &str, target: &str) -> String {
-    let joined = match target.strip_prefix('/') {
-        Some(absolute) => absolute.to_owned(),
-        None => match from.rsplit_once('/') {
-            Some((dir, _)) => format!("{dir}/{target}"),
-            None => target.to_owned(),
-        },
-    };
-    let mut parts: Vec<&str> = Vec::new();
-    for segment in joined.split('/') {
-        match segment {
-            "" | "." => {}
-            ".." => {
-                parts.pop();
-            }
-            s => parts.push(s),
-        }
-    }
-    parts.join("/")
-}
-
-/// The target of an `#include` line, or `None` for any other line.
-fn include_target(line: &str) -> Option<&str> {
-    let t = line.trim();
-    if !t.starts_with("#include") {
-        return None;
-    }
-    let target = t.get("#include ".len()..).unwrap_or("").trim();
-    let target = target.strip_prefix('"').unwrap_or(target);
-    Some(target.strip_suffix('"').unwrap_or(target))
-}
-
-impl IncludeGraph {
-    /// Read `starts` and every file they include, transitively.
-    pub fn build(files: &PackFiles, starts: &[String]) -> Self {
-        let mut graph = Self {
-            files: BTreeMap::new(),
-            failures: BTreeMap::new(),
-        };
-        let mut seen: BTreeSet<String> = starts.iter().cloned().collect();
-        let mut queue: Vec<(String, Option<(String, usize)>)> =
-            starts.iter().map(|s| (s.clone(), None)).collect();
-        while let Some((path, from)) = queue.pop() {
-            let Some(text) = files.read(&path) else {
-                let why = match from {
-                    Some((file, line)) => {
-                        format!("{file}:{}: #include \"{path}\": file not found", line + 1)
-                    }
-                    None => format!("{path}: file not found"),
-                };
-                graph.failures.insert(path, why);
-                continue;
-            };
-            let lines: Vec<String> = text.lines().map(str::to_owned).collect();
-            let includes: BTreeMap<usize, String> = lines
-                .iter()
-                .enumerate()
-                .filter_map(|(i, l)| Some((i, resolve(&path, include_target(l)?))))
-                .collect();
-            if let Some((line, _)) = includes.iter().find(|(_, target)| **target == path) {
-                graph.failures.insert(
-                    path.clone(),
-                    format!("{path}:{}: file includes itself", line + 1),
-                );
-                continue;
-            }
-            for (&line, target) in &includes {
-                if seen.insert(target.clone()) {
-                    queue.push((target.clone(), Some((path.clone(), line))));
-                }
-            }
-            graph.files.insert(path, FileNode { lines, includes });
-        }
-        graph
-    }
-
-    /// The graph's weakly connected components (files linked by includes in
-    /// either direction), each sorted. Iris discovers options per component.
-    pub fn components(&self) -> Vec<Vec<String>> {
-        let names: Vec<&String> = self.files.keys().collect();
-        let index: BTreeMap<&str, usize> = names
-            .iter()
-            .enumerate()
-            .map(|(i, n)| (n.as_str(), i))
-            .collect();
-        let mut parent: Vec<usize> = (0..names.len()).collect();
-        fn root(parent: &mut [usize], mut i: usize) -> usize {
-            while parent[i] != i {
-                parent[i] = parent[parent[i]];
-                i = parent[i];
-            }
-            i
-        }
-        for (i, node) in self.files.values().enumerate() {
-            for target in node.includes.values() {
-                if let Some(&j) = index.get(target.as_str()) {
-                    let (a, b) = (root(&mut parent, i), root(&mut parent, j));
-                    parent[a] = b;
-                }
-            }
-        }
-        let mut groups: BTreeMap<usize, Vec<String>> = BTreeMap::new();
-        for (i, name) in names.iter().enumerate() {
-            let r = root(&mut parent, i);
-            groups.entry(r).or_default().push((*name).clone());
-        }
-        groups.into_values().collect()
-    }
-
-    /// Inline `start`, passing every line that isn't an `#include` through
-    /// `edit(file, line index, text)` first (Iris applies option values there).
-    pub fn inline(
-        &self,
-        start: &str,
-        edit: &dyn Fn(&str, usize, &str) -> String,
-    ) -> Result<Inlined, String> {
-        let mut out = Inlined {
-            text: String::new(),
-            origin: Vec::new(),
-        };
-        let mut stack = Vec::new();
-        self.inline_into(start, edit, &mut stack, &mut out)?;
-        Ok(out)
-    }
-
-    fn inline_into(
-        &self,
-        path: &str,
-        edit: &dyn Fn(&str, usize, &str) -> String,
-        stack: &mut Vec<String>,
-        out: &mut Inlined,
-    ) -> Result<(), String> {
-        if let Some(why) = self.failures.get(path) {
-            return Err(why.clone());
-        }
-        if stack.iter().any(|p| p == path) {
-            return Err(format!("#include cycle: {} -> {path}", stack.join(" -> ")));
-        }
-        let node = self
-            .files
-            .get(path)
-            .ok_or_else(|| format!("{path}: file not found"))?;
-        stack.push(path.to_owned());
-        for (i, line) in node.lines.iter().enumerate() {
-            match node.includes.get(&i) {
-                Some(target) => self.inline_into(target, edit, stack, out)?,
-                None => {
-                    out.text.push_str(&edit(path, i, line));
-                    out.text.push('\n');
-                    out.origin.push((path.to_owned(), i as u32 + 1));
-                }
-            }
-        }
-        stack.pop();
-        Ok(())
-    }
-}
@@ -1,205 +0,0 @@
-//! Java shader packs (OptiFine/Iris) for Horizon (docs/shader-packs.md,
-//! "Java shader packs"). This crate does the part that needs no GPU: open a
-//! pack, find its programs and options, and turn a program into plain GLSL
-//! the way Iris does before compiling it (`#include`s inlined, the player's
-//! option values written into the source, Iris's macros expanded), read its
-//! `shaders.properties`, and translate programs to WGSL.
-
-pub mod include;
-pub mod options;
-pub mod pipeline;
-pub mod preprocess;
-pub mod properties;
-pub mod source;
-pub mod translate;
-pub mod uniforms;
-
-use include::{IncludeGraph, Inlined};
-use options::{Annotated, OptionSet, OptionValues};
-use preprocess::{Environment, Preprocessed};
-use properties::{Properties, ShaderProperties};
-use source::PackFiles;
-use std::{
-    collections::{BTreeMap, BTreeSet},
-    path::Path,
-};
-use translate::{Link, Translated};
-
-/// A program's pipeline stage, from its file extension.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Stage {
-    Vertex,
-    Fragment,
-    Geometry,
-    Compute,
-    TessControl,
-    TessEval,
-}
-
-impl Stage {
-    /// The stage of `composite1.fsh` and the like; `None` for other files.
-    pub fn of(program: &str) -> Option<Self> {
-        Some(match program.rsplit_once('.')?.1 {
-            "vsh" => Self::Vertex,
-            "fsh" => Self::Fragment,
-            "gsh" => Self::Geometry,
-            "csh" => Self::Compute,
-            "tcs" => Self::TessControl,
-            "tes" => Self::TessEval,
-            _ => return None,
-        })
-    }
-}
-
-/// An opened Java shader pack.
-pub struct JavaPack {
-    pub files: PackFiles,
-    /// Every program source file (`composite1.fsh`, `world-1/final.vsh`).
-    pub programs: Vec<String>,
-    pub graph: IncludeGraph,
-    annotations: BTreeMap<String, Annotated>,
-    /// The options the player can set (`ShaderPackOptions`).
-    pub options: OptionSet,
-}
-
-impl JavaPack {
-    /// Open the pack folder or zip at `path` and read every program and file
-    /// they include.
-    pub fn open(path: &Path) -> Result<Self, String> {
-        let files = PackFiles::open(path)?;
-        let programs = files.programs();
-        if programs.is_empty() {
-            return Err("no programs in shaders/".into());
-        }
-        let graph = IncludeGraph::build(&files, &programs);
-        let annotations: BTreeMap<String, Annotated> = graph
-            .files
-            .iter()
-            .map(|(path, node)| (path.clone(), Annotated::parse(&node.lines)))
-            .collect();
-        // A boolean #define is an option when an #ifdef in its component
-        // refers to it.
-        let mut options = OptionSet::default();
-        for component in graph.components() {
-            let refs: BTreeSet<&String> = component
-                .iter()
-                .flat_map(|f| &annotations[f].ifdef_refs)
-                .collect();
-            for file in &component {
-                let a = &annotations[file];
-                a.bools
-                    .values()
-                    .filter(|o| refs.contains(&o.name))
-                    .for_each(|o| options.add_bool(o));
-                a.strings.values().for_each(|o| options.add_string(o));
-            }
-        }
-        Ok(Self {
-            files,
-            programs,
-            graph,
-            annotations,
-            options,
-        })
-    }
-
-    /// The player's values from saved `name=value` pairs (`shaderpacks/<pack>.txt`).
-    pub fn values(&self, saved: &BTreeMap<String, String>) -> OptionValues {
-        OptionValues::new(&self.options, saved)
-    }
-
-    /// `program` with its includes inlined and `values` applied.
-    pub fn source(&self, program: &str, values: &OptionValues) -> Result<Inlined, String> {
-        self.graph
-            .inline(program, &|file, i, line| match self.annotations.get(file) {
-                Some(a) => a.edit(values, i, line),
-                None => line.to_owned(),
-            })
-    }
-
-    /// `program` as plain GLSL: [`JavaPack::source`], then the preprocessor.
-    pub fn preprocess(
-        &self,
-        program: &str,
-        values: &OptionValues,
-        env: &Environment,
-    ) -> Result<Preprocessed, String> {
-        preprocess::preprocess(&self.source(program, values)?, env)
-    }
-
-    /// `program` translated to WGSL. The programs of one pass (its `.vsh`,
-    /// then its `.fsh`) share `link`.
-    pub fn translate(
-        &self,
-        program: &str,
-        values: &OptionValues,
-        env: &Environment,
-        link: &mut Link,
-    ) -> Result<Translated, String> {
-        let stage = Stage::of(program).ok_or_else(|| format!("{program}: not a program"))?;
-        let source = self.source(program, values)?;
-        let pre = preprocess::preprocess(&source, env)?;
-        translate::translate(stage, &pre.text, link, &|line| source.locate(line))
-            .map_err(|e| format!("{program}: {e}"))
-    }
-
-    /// The pack's `shaders.properties` with `values` (empty when it has none).
-    pub fn properties(
-        &self,
-        values: &OptionValues,
-        env: &Environment,
-    ) -> Result<ShaderProperties, String> {
-        match self.files.read("shaders.properties") {
-            Some(text) => ShaderProperties::new(&text, env, &self.options, values),
-            None => Ok(ShaderProperties::default()),
-        }
-    }
-
-    /// The pack's language translations (`shaders/lang/<code_lower>.lang` or
-    /// `en_US.lang`), mapping keys such as `option.SHADOW_QUALITY`,
-    /// `value.SHADOW_QUALITY.2`, `screen.LIGHTING`, and `profile.HIGH` to their
-    /// display labels.
-    pub fn translations(&self, lang_code: &str) -> BTreeMap<String, String> {
-        let mut out = BTreeMap::new();
-        let lower = lang_code.to_lowercase();
-        let upper = match lower.split_once('_') {
-            Some((l, r)) => format!("{l}_{}", r.to_uppercase()),
-            None => lower.clone(),
-        };
-        let mut candidates = vec!["lang/en_US.lang".to_owned(), "lang/en_us.lang".to_owned()];
-        if lower != "en_us" {
-            candidates.push(format!("lang/{lower}.lang"));
-            candidates.push(format!("lang/{upper}.lang"));
-        }
-        for path in candidates {
-            if let Some(text) = self.files.read(&path) {
-                for (k, v) in Properties::parse(&text).iter() {
-                    out.insert(k.to_owned(), v.to_owned());
-                }
-            }
-        }
-        out
-    }
-}
-
-impl JavaPack {
-    /// The block ids of the pack's `block.properties` (empty without one),
-    /// [`properties::block_ids`].
-    pub fn block_ids(
-        &self,
-        values: &OptionValues,
-        env: &Environment,
-    ) -> Result<BTreeMap<String, i32>, String> {
-        match self.files.read("block.properties") {
-            Some(text) => properties::block_ids(&text, env, &self.options, values)
-                .map_err(|e| format!("block.properties: {e}")),
-            None => Ok(BTreeMap::new()),
-        }
-    }
-}
-
-/// A program's name in `shaders.properties` (`world-1/composite1.fsh` is
-/// `world-1/composite1`).
-pub fn program_name(program: &str) -> &str {
-    program.rsplit_once('.').map_or(program, |(name, _)| name)
-}